HDF.cc

/*
 * $Id: HDF.cc,v 1.42 2006/04/03 15:11:18 brook Exp $
 */

/*
 * ClearSilver++ Software License.
 *
 * Copyright (c) 2005,2006 Brook Milligan <brook@nmsu.edu>
 * All rights reserved.
 * 
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above
 *    copyright notice, this list of conditions and the following
 *    disclaimer in the documentation and/or other materials provided
 *    with the distribution.
 * 3. The name of the author may not be used to endorse or promote
 *    products derived from this software without specific prior
 *    written permission.
 * 
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS
 * OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
 * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY
 * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE
 * GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
 * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
 * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
 * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */

#include "HDF.h"

#include <stdexcept>
#include <string.h>
#include <syslog.h>
#include <boost/lexical_cast.hpp>
#include <ClearSilver/util/neo_misc.h> // must precede neo_hdf.h
#include <ClearSilver/util/neo_hdf.h>
#include "ClearSilverError.h"
#include "ClearSilverException.h"

using namespace std;

                                // constructors
ClearSilver::HDF::HDF ()
  : TraceObject(debug(), "HDF"), ConstHDFNode(), HDFNode(), root_(), nodes_()
{}
ClearSilver::HDF::HDF (const char* path)
  : TraceObject(debug(), "HDF", "const char*"),
    ConstHDFNode(), HDFNode(), root_(), nodes_()
{
  if (path && *path)
    root_().read_file(path);
}
ClearSilver::HDF::HDF (const string& path)
  : TraceObject(debug(), "HDF", "const string&"),
    ConstHDFNode(), HDFNode(), root_(), nodes_()
{
  if (!path.empty())
    root_().read_file(path);
}
ClearSilver::HDF::HDF (const RootNode& root)
  : TraceObject(debug(), "HDF", "const RootNode&"),
    HDFNode(), root_(root), nodes_()
{}
ClearSilver::HDF::HDF (const HDF& hdf)
  : TraceObject(hdf), ConstHDFNode(hdf), HDFNode(hdf),
    root_(hdf.root_), nodes_(hdf.nodes_)
{}
ClearSilver::HDF::~HDF () throw()
{}

                                // assignment
ClearSilver::HDF&
ClearSilver::HDF::operator = (const HDF& hdf)
{
  TraceObject::operator = (hdf);
  if (debug())
    {
      string message;
      message += string("ClearSilver::HDF::operator = (const HDF&): ");
      if (this->is_dataset())
        message += "dataset=";
      else if (this->is_reference())
        message += "reference=";
      else if (this->is_iterator())
        message += "iterator=";
      else
        message += "???";
      if (hdf.is_dataset())
        message += "dataset";
      else if (hdf.is_reference())
        message += "reference";
      else if (hdf.is_iterator())
        message += "iterator";
      else
        message += "???";
      syslog (LOG_DEBUG, "%s", message.c_str());
    }
  if (this->is_dataset() && hdf.is_dataset()
      || this->is_iterator() && hdf.is_iterator())
    {
      HDF hdf0 (hdf);
      swap (hdf0);
    }
  else if (this->is_reference() && hdf.is_reference())
    set_value (hdf.get_value());
  else
    {
      string message;
      message += "ClearSilver::HDF::operator = (const HDF&): ";
      message += "mismatched argument types";
      throw invalid_argument(message);
    }
  return *this;
}

ClearSilver::HDF::HDF&
ClearSilver::HDF::operator = (const char* value)
{
  return operator = (std::string(value));
}

ClearSilver::HDF::HDF&
ClearSilver::HDF::operator = (const std::string& value)
{
  set_value (value);
  return *this;
}

ClearSilver::HDF::HDF&
ClearSilver::HDF::operator = (int value)
{
  set_value (value);
  return *this;
}

ClearSilver::HDF::HDF&
ClearSilver::HDF::operator = (bool value)
{
  set_value (value);
  return *this;
}

ClearSilver::HDF::HDF&
ClearSilver::HDF::operator = (const SymlinkTarget& target)
{
  ClearSilverError error (hdf_set_symlink (root_().get(), path().c_str(),
                                           target().c_str()));
  if (error)
    {
      string message;
      message += "ClearSilver::HDF::operator = (const SymlinkTarget&): ";
      ClearSilverException e (message);
      e += error;
      throw e;
    }
}

                                // inspectors
                                // depth of current node
ClearSilver::HDF::size_type
ClearSilver::HDF::depth () const
{
  return nodes_.depth();
}

                                // path to the current node
std::string
ClearSilver::HDF::path () const
{
  return nodes_.path();
}

                                // associative array-like interface
ClearSilver::HDF::const_reference
ClearSilver::HDF::operator [] (const char* key) const
{
  return operator [] (std::string(key));
}

ClearSilver::HDF::const_reference
ClearSilver::HDF::operator [] (const string& key) const
{
  return *find(key);
}

ClearSilver::HDF::reference
ClearSilver::HDF::operator [] (const char* key)
{
  return operator [] (std::string(key));
}

ClearSilver::HDF::reference
ClearSilver::HDF::operator [] (const string& key)
{
  if (key.empty())
    {
      string message;
      message += "ClearSilver::HDF::operator [] (const string&): ";
      message += "empty key";
      throw invalid_argument(message);
    }
  if (debug())
    {
      string message;
      message += string("HDF::operator [] (const string& key): key=") + key;
      syslog (LOG_DEBUG, "%s", message.c_str());
    }

  iterator i (*this);
  ClearSilverNode node (i->node().get_node(key));
  if (!node)
    {
      string message;
      message += "ClearSilver::HDF::operator [] (const string&): ";
      message += "impossible error: ";
      message += "'" + key + "' ";
      message += "does not refer to any node";
      throw invalid_argument (message);
    }
  return *find (key);
}

                                // STL iterators
ClearSilver::HDF::const_iterator
ClearSilver::HDF::begin () const
{
  if (empty())                  // XXX
    return end();

  const_iterator i (*this);
  i.is_iterator() = true;
  ClearSilverNode child (i->node().child());
  string name;
  if (child)
    name = child.name();
  i->push(name, child);
  return i;
}

ClearSilver::HDF::const_iterator
ClearSilver::HDF::end () const
{
  const_iterator i (*this);
  i.is_iterator() = true;
  i->push (string(), ClearSilverNode());
  return i;
}

ClearSilver::HDF::iterator
ClearSilver::HDF::begin ()
{
  if (empty())                  // XXX
    return end();

  iterator i (*this);
  i.is_iterator() = true;
  ClearSilverNode child (i->node().child());
  string name;
  if (child)
    name = child.name();
  i->push(name, child);
  return i;
}

ClearSilver::HDF::iterator
ClearSilver::HDF::end ()
{
  iterator i (*this);
  i.is_iterator() = true;
  i->push (string(), ClearSilverNode());
  return i;
}

ClearSilver::HDF::const_iterator
ClearSilver::HDF::find (const char* key) const
{
  return find(std::string(key));
}

ClearSilver::HDF::const_iterator
ClearSilver::HDF::find (const string& key) const
{
  if (debug())
    {
      string message;
      message += string("HDF::find (const string& key) const: ");
      message += "key=" + key;
      syslog (LOG_DEBUG, "%s", message.c_str());
    }
  Nodes nodes (find_node (key));
  const_iterator i (*this);
  i.is_iterator() = true;
  i->nodes() = nodes;
  if (debug())
    i->nodes().print();
  if (debug())
    syslog (LOG_DEBUG, "%s", "HDF::find (const string& key) const: done");
  return i;
}

ClearSilver::HDF::iterator
ClearSilver::HDF::find (const char* key)
{
  return find (std::string(key));
}

ClearSilver::HDF::iterator
ClearSilver::HDF::find (const string& key)
{
  if (debug())
    {
      string message;
      message += string("HDF::find (const string& key): key=") + key;
      syslog (LOG_DEBUG, "%s", message.c_str());
      nodes().print();
    }
  Nodes nodes (find_node (key));
  iterator i (*this);
  i.is_iterator() = true;
  i->nodes() = nodes;
  if (debug())
    {
      syslog (LOG_DEBUG, "%s", "HDF::find (const string& key): done");
      i->nodes().print();
    }
  return i;
}

                                // iterator methods
ClearSilver::HDF::iterator&
ClearSilver::HDF::operator ++ ()
{
  ClearSilverNode node (this->node().next());
  string name;
  if (node)
    name = node.name();
  pop();
  push(name, node);
  return *this;
}

ClearSilver::HDF::iterator
ClearSilver::HDF::operator ++ (int)
{
  iterator i (*this);
  operator++();
  return i;
}

                                // XXX - no longer an iterator
ClearSilver::HDF::value_type
ClearSilver::HDF::operator * ()
{
  value_type v(*this);
  v.is_iterator() = false;
  return v;
}

ClearSilver::HDF::pointer
ClearSilver::HDF::operator -> ()
{
  return this;
 }

                                // deep copy methods
ClearSilver::HDF&
ClearSilver::HDF::copy (const HDF& dataset)
{
  return copy("", dataset);
}

ClearSilver::HDF&
ClearSilver::HDF::copy (const char* key, const HDF& dataset)
{
  return copy(std::string(key), dataset);
}

ClearSilver::HDF&
ClearSilver::HDF::copy (const std::string& key, const HDF& dataset)
{
  node().copy (key, dataset.node());
  return *this;
}

ClearSilver::Nodes
ClearSilver::HDF::nodes () const
{
  return nodes_;
}

ClearSilver::Nodes&
ClearSilver::HDF::nodes ()
{
  return nodes_;
}

ClearSilver::ClearSilverNode
ClearSilver::HDF::node () const
{
  if (nodes_.empty())
    return root_();
  return nodes_.top();
}

                                // access the root node
ClearSilver::ClearSilverNode
ClearSilver::HDF::root () const
{
  return root_();
}

                                // access the node attributes.
ClearSilver::HDFAttributes
ClearSilver::HDF::attributes ()
{
  return HDFAttributes (nodes_, node().attr());
}

void
ClearSilver::HDF::swap (HDF& hdf) throw()
{
  TraceObject::swap (hdf);
  ConstHDFNode::swap (hdf);
  HDFNode::swap (hdf);
  root_.swap (hdf.root_);
  nodes_.swap (hdf.nodes_);
}

void
ClearSilver::HDF::push (const ConstHDFNode::Name& name,
                        const ClearSilverNode& node)
{
  nodes_.push(name, node);
}

void
ClearSilver::HDF::pop ()
{
  if (nodes_.empty())
    {
      string message;
      message += "ClearSilver::HDF::pop (): ";
      message += "empty stack";
      throw invalid_argument (message);
    }
  nodes_.pop();
}

ClearSilver::ClearSilverNode
ClearSilver::HDF::top () const
{
  if (nodes_.empty())
    return ClearSilverNode();
  return nodes_.top();
}

                                // debug flag
bool&
ClearSilver::HDF::debug ()
{
  static bool debug_ = false;
  return debug_;
}


namespace ClearSilver
{
                                // logical comparison operators
  bool
  operator == (const HDF::reference& r1, const HDF::reference& r2)
  {
    return r1.root_() == r2.root_() && r1.nodes_ == r2.nodes_;
  }
};                              // namespace ClearSilver

---