Nodes.cc

/*
 * $Id: Nodes.cc,v 1.6 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 "Nodes.h"

#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::Nodes::Nodes ()
  : nodes_(), names_() {}
ClearSilver::Nodes::Nodes (const Nodes& n)
  : nodes_(n.nodes_), names_(n.names_) {}
ClearSilver::Nodes::~Nodes () {}

                                // assignment
ClearSilver::Nodes&
ClearSilver::Nodes::operator = (const Nodes& n)
{
  nodes_ = n.nodes_;
  names_ = n.names_;
  return *this;
}

                                // is the node path empty?
bool
ClearSilver::Nodes::empty () const
{
  return nodes_.empty();
}

                                // size of the node path.
ClearSilver::Nodes::size_type
ClearSilver::Nodes::size () const
{
  return nodes_.size();
}

                                // string representation of the entire path.
string
ClearSilver::Nodes::path () const
{
  string p;
  for (NameContainer::const_iterator i = names_.begin();
       i != names_.end(); ++i)
    {
      if (i != names_.begin())
        p += ".";
      p += string(*i);
    }
  return p;
}

ClearSilver::Nodes::size_type
ClearSilver::Nodes::depth () const
{
  return nodes_.size();
}

void
ClearSilver::Nodes::push (const Name& name, const ClearSilverNode& node)
{
  nodes_.push_back (node);
  names_.push_back (name);
}

void
ClearSilver::Nodes::pop ()
{
  if (nodes_.empty())
    {
      string message;
      message += "ClearSilver::Nodes::pop () const: ";
      message += "no nodes";
      throw logic_error (message);
    }
  if (names_.size() != nodes_.size())
    {
      string message;
      message += "ClearSilver::Nodes::pop () const: ";
      message += "mismatch in number of nodes (";
      message += boost::lexical_cast<string>(nodes_.size());
      message += ") and paths (";
      message += boost::lexical_cast<string>(names_.size()); 
      message += ")";
      throw logic_error (message);
    }
  nodes_.pop_back();
  names_.pop_back ();
}

ClearSilver::ClearSilverNode
ClearSilver::Nodes::top () const
{
  if (nodes_.empty())
    {
      string message;
      message += "ClearSilver::Nodes::top () const: ";
      message += "no nodes";
      throw logic_error (message);
    }
  return nodes_.back();
}

                                // swap contents with another object
void
ClearSilver::Nodes::swap (Nodes& n) throw()
{
  nodes_.swap (n.nodes_);
  names_.swap (n.names_);
}

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

                                // XXX
void
ClearSilver::Nodes::print () const
{
  int i = 1;
  NodeContainer::const_iterator ni = nodes_.begin();
  NameContainer::const_iterator pi = names_.begin();
  while (ni != nodes_.end())
    {
      string message;
      message += boost::lexical_cast<string>(i) + ". ";
      message += hex(ni->get()) + "  " + string(*pi);
      syslog(LOG_DEBUG, "%s", message.c_str());
      ++i;
      ++ni;
      ++pi;
    }
}

namespace ClearSilver
{
                                // logical comparison operators
  bool
  operator == (const Nodes& n1, const Nodes& n2)
  {
    if (n1.size() != n2.size())
      return false;

    Nodes::NodeContainer::const_iterator i = n1.nodes_.begin();
    Nodes::NodeContainer::const_iterator j = n2.nodes_.begin();
    while (i != n1.nodes_.end())
      {
        if (*i != *j)
          return false;
        ++i;
        ++j;
      }
    return true;
  }
};                              // namespace ClearSilver

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

---