ClearSilverNode.cc

/*
 * $Id: ClearSilverNode.cc,v 1.13 2006/04/03 15:09:21 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 "ClearSilverNode.h"

#include <algorithm>
#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"
#include "ClearSilverNodeComparator.h"
#include "ConstHDF.h"
#include "RootNode.h"

using namespace std;

                                // node sorting function
static int sort_nodes (const void*, const void*);
                                // comparator used by node sorting function
ClearSilver::ClearSilverNodeComparator::Ptr comparator;


                                // constructors
ClearSilver::ClearSilverNode::ClearSilverNode ()
  : node_(0) {}

ClearSilver::ClearSilverNode::ClearSilverNode (HDF* node)
  : node_(node) {}

ClearSilver::ClearSilverNode::ClearSilverNode (const ClearSilverNode& n)
  : node_(n.node_) {}

ClearSilver::ClearSilverNode::~ClearSilverNode () throw()
{}

                                // assignment
ClearSilver::ClearSilverNode&
ClearSilver::ClearSilverNode::operator = (const ClearSilverNode& n)
{
  ClearSilverNode n0 (n);
  swap (n0);
  return *this;
}

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

                                // Note: the ClearSilver C API
                                // provides no function analogous to
                                // assignment.  Therefore, this
                                // function depends on the internals
                                // of the _hdf structure.
ClearSilver::ClearSilverNode&
ClearSilver::ClearSilverNode::operator = (const string& value)
{
  if (!node_)
    {
      string message;
      message += "ClearSilverNode::operator = (const std::string&): ";
      message += "cannot assign to null node";
      throw logic_error (message);
    }
  if (debug())
    {
      string message;
      message
        += "ClearSilver::ClearSilverNode::operator = (const string&): ";
      if (node_->name)
        message += string("name=") + node_->name + ", ";
      message += "value=" + value;
      syslog (LOG_DEBUG, "%s", message.c_str());
    }
  if (node_->value)
    free (node_->value);
  node_->value = strdup(value.c_str());
  return *this;
}

ClearSilver::ClearSilverNode&
ClearSilver::ClearSilverNode::operator = (int value)
{
  if (debug())
    {
      string message;
      message += "ClearSilver::ClearSilverNode::operator = (int): ";
      if (node_ && node_->name)
        message += string("name=") + node_->name + ", ";
      message += "value=" + value;
      syslog (LOG_DEBUG, "%s", message.c_str());
    }
  return operator = (boost::lexical_cast<string>(value));
}

ClearSilver::ClearSilverNode&
ClearSilver::ClearSilverNode::operator = (bool value)
{
  return operator = (std::string(value?True():False()));
}


                                // STL inspectors
                                // is this node empty?
bool
ClearSilver::ClearSilverNode::empty () const
{
  return node_ == 0;
}

                                // conversions
                                // is this node valid?
ClearSilver::ClearSilverNode::operator bool () const
{
  return !empty();
}

                                // node accessors
string
ClearSilver::ClearSilverNode::name () const
{
  if (debug())
    syslog (LOG_DEBUG, "%s", "ClearSilver::ClearSilverNode::name () const");
  if (!node_)
    {
      string message;
      message += "ClearSilverNode::name () const: ";
      message += "null node";
      throw logic_error (message);
    }
  return string(hdf_obj_name(node_));
}

string
ClearSilver::ClearSilverNode::value () const
{
  if (!node_)
    {
      string message;
      message += "ClearSilverNode::value () const: ";
      message += "null node";
      throw logic_error (message);
    }
  if (debug())
    {
      string message;
      message += string("ClearSilver::ClearSilverNode::value () const: ");
      if (node_->name)
        message += string("name=") + node_->name + ", ";
      if (node_->value)
        message += string("value=") + node_->value;
      syslog (LOG_DEBUG, "%s", message.c_str());
    }
  char * value = hdf_obj_value(node_);
  return value? string (value) : string();
}


                                //  tree traversers
                                // access the node structure directly.
ClearSilver::ClearSilverNode::HDF*
ClearSilver::ClearSilverNode::get () const
{
  return node_;
}

ClearSilver::ClearSilverNode
ClearSilver::ClearSilverNode::top () const
{
  if (debug())
    syslog (LOG_DEBUG, "%s", "ClearSilverNode::top () const");
  return ClearSilverNode (hdf_obj_top (node_));
}

ClearSilver::ClearSilverNode
ClearSilver::ClearSilverNode::next () const
{
  if (debug())
    syslog (LOG_DEBUG, "%s", "ClearSilverNode::next () const");
  return ClearSilverNode (hdf_obj_next (node_));
}

ClearSilver::ClearSilverNode
ClearSilver::ClearSilverNode::child () const
{
  if (debug())
    syslog (LOG_DEBUG, "%s", "ClearSilverNode::child () const");
  return ClearSilverNode (hdf_obj_child (node_));
}

ClearSilver::ClearSilverNode::HDF_ATTR*
ClearSilver::ClearSilverNode::attr () const
{
  if (debug())
    syslog (LOG_DEBUG, "%s", "ClearSilverNode::attr () const");
  return node_->attr;
}

                                // HDF dataset operations
string
ClearSilver::ClearSilverNode::get_value
(const string& key, const string& default_value) const
{
  if (key.empty())
    {
      string message;
      message += "ClearSilver::ClearSilverNode::get_value ";
      message += "(const string&, const string&) const: ";
      message += "empty key";
      throw invalid_argument (message);
    }
  if (debug())
    {
      string message;
      message += "ClearSilver::ClearSilverNode::get_value";
      message += "(const string& key, const string& default_value) const: ";
      message += "key=" + key + ", ";
      message += "default_value=" + default_value;
      syslog (LOG_DEBUG, "%s", message.c_str());
    }
  return string(hdf_get_value (node_, key.c_str(), default_value.c_str()));
}

void
ClearSilver::ClearSilverNode::set_value
(const std::string& key, const string& value)
{
  if (key.empty())
    {
      string message;
      message += "ClearSilver::ClearSilverNode::set_value ";
      message += "(const string&, int): ";
      message += "empty key";
      throw invalid_argument (message);
    }
  if (debug())
    {
      string message;
      message += string("ClearSilverNode::set_value ")
        + "(const string& key, const string& value): ";
      message += "key=" + key + ", ";
      message += "value=" + value;
      syslog (LOG_DEBUG, "%s", message.c_str());
    }
  ClearSilverError error (hdf_set_value(node_,key.c_str(),value.c_str()));
  if (error)
    {
      string message;
      message += "ClearSilver::ClearSilverNode::set_value ";
      message += "(const std::string&, const std::string&):";
      ClearSilverException e (message);
      e += error;
      throw e;
    }
}

void
ClearSilver::ClearSilverNode::set_value
(const std::string& key, int value)
{
  if (key.empty())
    {
      string message;
      message += "ClearSilver::ClearSilverNode::set_value ";
      message += "(const string&, int): ";
      message += "empty key";
      throw invalid_argument (message);
    }
  if (debug())
    {
      string message;
      message += string("ClearSilverNode::set_value ")
        + "(const string& key, int value): ";
      message += "key=" + key + ", ";
      message += "value=" + boost::lexical_cast<string>(value);
      syslog (LOG_DEBUG, "%s", message.c_str());
    }
  ClearSilverError error (hdf_set_int_value (node_, key.c_str(), value));
  if (error)
    {
      string message;
      message += "ClearSilver::ClearSilverNode::set_value ";
      message += "(const string&, int):";
      ClearSilverException e (message);
      e += error;
      throw e;
    }
}

void
ClearSilver::ClearSilverNode::set_value
(const std::string& key, unsigned int value)
{
  if (key.empty())
    {
      string message;
      message += "ClearSilver::ClearSilverNode::set_value ";
      message += "(const string&, unsigned int): ";
      message += "empty key";
      throw invalid_argument (message);
    }
  if (debug())
    {
      string message;
      message += string("ClearSilverNode::set_value ")
        + "(const string& key, unsigned int value): ";
      message += "key=" + key + ", ";
      message += "value=" + boost::lexical_cast<string>(value);
      syslog (LOG_DEBUG, "%s", message.c_str());
    }
  ClearSilverError error (hdf_set_int_value (node_, key.c_str(),
                                             static_cast<int>(value)));
  if (error)
    {
      string message;
      message += "ClearSilver::ClearSilverNode::set_value ";
      message += "(const string&, unsigned int):";
      ClearSilverException e (message);
      e += error;
      throw e;
    }
}

void
ClearSilver::ClearSilverNode::set_value
(const std::string& key, bool value)
{
  if (debug())
    {
      string message;
      message += string("ClearSilverNode::set_value ")
        + "(const string& key, bool value): ";
      message += "key=" + key + ", ";
      message += string("value=") + (value?"true":"false");
      syslog (LOG_DEBUG, "%s", message.c_str());
    }
  set_value (key, string(value? True() : False()));
}

ClearSilver::ClearSilverNode
ClearSilver::ClearSilverNode::get_node
(const string& key)
{
  if (key.empty())
    {
      string message;
      message += "ClearSilver::ClearSilverNode::get_node ";
      message += "(const string&) const: ";
      message += "empty key";
      throw invalid_argument (message);
    }
  if (debug())
    {
      string message;
      message += string("ClearSilverNode::get_node (const string& key): ");
      message += "key=" + key;
      syslog (LOG_DEBUG, "%s", message.c_str());
    }
  HDF* node;
  ClearSilverError error (hdf_get_node (node_, key.c_str(), &node));
  if (error)
    {
      string message;
      message += "ClearSilver::ClearSilverNode::get_node ";
      message += "(const string& key): ";
      message += "key=" + key;
      ClearSilverException e (message);
      e += error;
      throw e;
    }
  if (!node)
    {
      string message;
      message += "ClearSilver::ClearSilverNode::get_node ";
      message += "(const string&) const: ";
      message += "impossible error: ";
      message += "cannot create intermediate nodes";
      throw logic_error (message);
    }
  return ClearSilverNode(node);
}

ClearSilver::ClearSilverNode
ClearSilver::ClearSilverNode::get_obj
(const string& key) const
{
  if (key.empty())
    {
      string message;
      message += "ClearSilver::ClearSilverNode::get_obj ";
      message += "(const string&) const: ";
      message += "empty key";
      throw invalid_argument (message);
    }
  if (debug())
    {
      string message;
      message += string("ClearSilverNode::get_obj (const string& key): ");
      message += "key=" + key;
      syslog (LOG_DEBUG, "%s", message.c_str());
    }
  return ClearSilverNode (hdf_get_obj (node_, key.c_str()));
}

ClearSilver::ClearSilverNode
ClearSilver::ClearSilverNode::get_child
(const string& key) const
{
  if (key.empty())
    {
      string message;
      message += "ClearSilver::ClearSilverNode::get_child ";
      message += "(const string&) const: ";
      message += "empty key";
      throw invalid_argument (message);
    }
  if (debug())
    {
      string message;
      message += string("ClearSilverNode::get_child(const string& key): ");
      message += "key=" + key;
      syslog (LOG_DEBUG, "%s", message.c_str());
    }
  return ClearSilverNode (hdf_get_child (node_, key.c_str()));
}

void
ClearSilver::ClearSilverNode::remove_tree ()
{
  hdf_destroy (&node_);
  if (node_ != 0)
    {
      string message;
      message += "ClearSilver::ClearSilverNode::remove_tree(): ";
      message += "node_ not empty";
      throw logic_error(message);
    }
}

void
ClearSilver::ClearSilverNode::remove_tree
(const std::string& key)
{
  ClearSilverError error (hdf_remove_tree (node_, key.c_str()));
  if (error)
    {
      string message;
      message += "ClearSilver::ClearSilverNode::remove_tree ";
      message += "(const string& key): ";
      message += "key=" + key;
      ClearSilverException e (message);
      e += error;
      throw e;
    }
}

void
ClearSilver::ClearSilverNode::read_file
(const std::string& path)
{
  if (path.empty())
    {
      string message;
      message += "ClearSilver::ClearSilverNode::read_file ";
      message += "(const string&): ";
      message += "empty path";
      throw invalid_argument (message);
    }
  ClearSilverError error (hdf_read_file (node_, path.c_str()));
  if (error)
    {
      string message;
      message += "ClearSilver::ClearSilverNode::read_file ";
      message += "(const string& path): ";
      message += "path=" + path;
      ClearSilverException e (message);
      e += error;
      throw e;
    }
}

void
ClearSilver::ClearSilverNode::write_file
(const std::string& path) const
{
  if (path.empty())
    {
      string message;
      message += "ClearSilver::ClearSilverNode::write_file ";
      message += "(const string&): ";
      message += "empty path";
      throw invalid_argument (message);
    }
  ClearSilverError error (hdf_write_file_atomic (node_, path.c_str()));
  if (error)
    {
      string message;
      message += "ClearSilver::ClearSilverNode::write_file ";
      message += "(const string& path): ";
      message += "path=" + path;
      ClearSilverException e (message);
      e += error;
      throw e;
    }
}

void
ClearSilver::ClearSilverNode::dump
(const std::string& prefix) const
{
  ClearSilverError error (hdf_dump (node_, prefix.c_str()));
  if (error)
    {
      string message;
      message += "ClearSilver::ClearSilverNode::dump ";
      message += "(const string& prefix): ";
      message += "prefix=" + prefix;
      ClearSilverException e (message);
      e += error;
      throw e;
    }
}

void
ClearSilver::ClearSilverNode::copy (const string& key,
                                           const ClearSilverNode& src)
{
  ClearSilverError error (hdf_copy (node_, key.c_str(), src.node_));
  if (error)
    {
      string message;
      message += "ClearSilver::ClearSilverNode::copy ";
      message += "(const string&, const ClearSilverNode&): ";
      ClearSilverException e (message);
      e += error;
      throw e;
    }
}

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

                                // boolean constants
std::string
ClearSilver::ClearSilverNode::Boolean (bool b)
{
  return b? True() : False();
}

std::string
ClearSilver::ClearSilverNode::True ()
{
  return std::string("1");
}

std::string
ClearSilver::ClearSilverNode::False ()
{
  return std::string("0");
}

                                // swap contents with another object.
void
ClearSilver::ClearSilverNode::swap (ClearSilverNode& n) throw()
{
  std::swap (node_, n.node_);
}


                                // sort the children
void
ClearSilver::ClearSilverNode::sort (ClearSilverNodeComparator::Ptr c)
{
  comparator = c;
  ClearSilverError error (hdf_sort_obj (node_, sort_nodes));
  if (error)
    {
      string message;
      message += "ClearSilver::ClearSilverNode::sort ";
      message += "(const ClearSilverNodeComparator::Ptr): ";
      ClearSilverException e (message);
      e += error;
      throw e;
    }
}

int
sort_nodes (const void* lhs, const void* rhs)
{
  ClearSilver::ConstHDF n1
    (ClearSilver::RootNode(*(ClearSilver::ClearSilverNode::HDF**) lhs, false));
  ClearSilver::ConstHDF n2
    (ClearSilver::RootNode(*(ClearSilver::ClearSilverNode::HDF**) rhs, false));
  return (*comparator) (n1, n2);
}

namespace ClearSilver
{
                                // logical comparison operators
  bool
  operator == (const ClearSilverNode& n1, const ClearSilverNode& n2)
  {
    return n1.node_ == n2.node_;
  }
};                              // namespace ClearSilver

---