ConstHDFNode.cc

/*
 * $Id: ConstHDFNode.cc,v 1.5 2006/03/29 05:35:58 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 "ConstHDFNode.h"

#include <algorithm>
#include <stdexcept>
#include <string.h>
#include <syslog.h>
#include <boost/lexical_cast.hpp>

#define CGI ClearSilverCGI
#define HDF ClearSilverHDF
#include <ClearSilver/ClearSilver.h>
#undef CGI
#undef HDF

using namespace std;

static string hex(void*);

                                // constructors
ClearSilver::ConstHDFNode::ConstHDFNode ()
  : is_iterator_(false) {}

ClearSilver::ConstHDFNode::ConstHDFNode (const ConstHDFNode& n)
  : is_iterator_(n.is_iterator_) {}

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

                                // assignment
#if 0                           // XXX
ClearSilver::ConstHDFNode&
ClearSilver::ConstHDFNode::operator = (const ConstHDFNode& n)
{
  ConstHDFNode n0 (n);
  swap (n0);
  return *this;
}
#endif

                                // STL inspectors
bool
ClearSilver::ConstHDFNode::empty () const
{
  return node().empty();
}

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

                                // convert to the value of the node.
ClearSilver::ConstHDFNode::operator std::string () const
{
  return node().value();
}

                                // node accessors
                                // name of the node.
std::string
ClearSilver::ConstHDFNode::name () const
{
  return node().name();
}

// value of the node.
std::string
ClearSilver::ConstHDFNode::value () const
{
  return node().value();
}

                                // HDF dataset operations
std::string
ClearSilver::ConstHDFNode::get_value () const
{
  return node().value();
}

std::string
ClearSilver::ConstHDFNode::get_value (const char* key) const
{
  return get_value(std::string(key));
}

std::string
ClearSilver::ConstHDFNode::get_value (const std::string& key) const
{
  return get_value(key, std::string());
}

std::string
ClearSilver::ConstHDFNode::get_value (const char* key,
                                      const char* default_value) const
{
  return get_value(std::string(key), std::string(default_value));
}

std::string
ClearSilver::ConstHDFNode::get_value (const std::string& key,
                         const std::string& default_value) const
{
  return node().get_value(key, default_value);
}
    
void
ClearSilver::ConstHDFNode::write_file (const char * filename) const
{
  write_file(std::string(filename));
}

void
ClearSilver::ConstHDFNode::write_file (const std::string& filename) const
{
  node().write_file(filename);
}

void
ClearSilver::ConstHDFNode::dump () const
{
  dump("<BR>");
}

void
ClearSilver::ConstHDFNode::dump (const char* prefix) const
{
  dump(std::string(prefix));
}

void
ClearSilver::ConstHDFNode::dump (const std::string& prefix) const
{
  node().dump(prefix);
}

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

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

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

                                // is this a dataset?
bool
ClearSilver::ConstHDFNode::is_dataset () const
{
  return nodes().empty();
}

                                // is this a node within a dataset?
bool
ClearSilver::ConstHDFNode::is_reference () const
{
  return !nodes().empty() && !is_iterator_;
}

bool
ClearSilver::ConstHDFNode::is_iterator () const
{
  return !nodes().empty() && is_iterator_;
}

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

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

ClearSilver::Nodes
ClearSilver::ConstHDFNode::find_node (const string& key) const
{
  if (key.empty())
    {
      string message;
      message += "ClearSilver::ConstHDFNode::find_node ";
      message += "(const string&) const: ";
      message += "empty key";
      throw invalid_argument(message);
    }
  if (*key.rbegin() == '.')
    {
      string message;
      message += "ClearSilver::ConstHDFNode::find_node ";
      message += "(const string&) const: ";
      message += "'" + key + "' ends in a period (.)";
      throw invalid_argument(message);
    }
  if (empty())
    {
      string message;
      message += "ClearSilver::ConstHDFNode::find_node ";
      message += "(const string&) const: ";
      message += "empty dataset";
      throw logic_error(message);
    }

  if (debug())
    {
      string message;
      message += string("ConstHDFNode::find_node (const string& key) const: ");
      message += "key=" + key;
      syslog (LOG_DEBUG, "%s", message.c_str());
    }
  Nodes n (nodes());
  ClearSilverNode node (this->node());
  if (debug())
    {
      string message;
      message += string("ConstHDFNode::find_node (const string& key) const: ");
      message += string("node=") + hex(node.get());
      if (node)
        {
          message += ", ";
          if (node.get()->name)
            message += string("name=") + node.get()->name + ", ";
          if (node.get()->value)
            message += string("value=") + node.get()->value + ", ";
          message += string("top=") + hex(node.get()->top) + ", ";
          message += string("child=") + hex(node.get()->child);
        }
      syslog (LOG_DEBUG, "%s", message.c_str());
    }
  string::size_type begin (0);
  while (1)                     // for each path component
    {
      string::size_type end(key.find(".", begin));
      string k (key.substr(begin, end == string::npos?string::npos:end-begin));
      if (debug())
        {
          string message;
          message
            += string("ConstHDFNode::find_node (const string& key) const: ");
          message += string("range: [") + boost::lexical_cast<string>(begin)
            + "," + boost::lexical_cast<string>(end) + "], ";
          message += string("key(0,end)=") + key.substr(0,end) + ", ";
          message += string("key(begin,end)=") + k;
          syslog (LOG_DEBUG, "%s", message.c_str());
        }
      node = node.get_obj(k);
      if (debug())
        {
          string message;
          message
            += string("ConstHDFNode::find_node (const string& key) const: ");
          message += string("node=") + hex(node.get());
          if (node)
            {
              message += ", ";
              if (node.get()->name)
                message += string("name=") + node.get()->name + ", ";
              if (node.get()->value)
                message += string("value=") + node.get()->value + ", ";
              message += string("top=") + hex(node.get()->top) + ", ";
              message += string("child=") + hex(node.get()->child);
            }
          syslog (LOG_DEBUG, "%s", message.c_str());
        }
      if (!node)
        {
          n = nodes();
          n.push(string(), ClearSilverNode());
          break;
        }
      n.push(k, node);
      if (end == string::npos)
        break;
      begin = ++end;
    }
  if (debug())
    {
      string message;
      message += string("ConstHDFNode::find_node (const string& key) const: ")
        + "done";
      syslog (LOG_DEBUG, "%s", message.c_str());
      n.print();
    }
  return n;
}

                                // access the iterator flag.
bool&
ClearSilver::ConstHDFNode::is_iterator ()
{
  return is_iterator_;
}

string
hex (void* p)
{
  ostringstream s;
  s << std::hex << p;
  return s.str();
}

---