RootNode.cc

/*
 * $Id: RootNode.cc,v 1.4 2006/03/27 19:17:47 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 "RootNode.h"

#include "ClearSilverException.h"
#include <ClearSilver/util/neo_hdf.h>

using namespace std;

namespace ClearSilver
{
  class Deleter
  {
  public:
    Deleter (bool);
    void operator () (ClearSilverNode::HDF*) const;

  private:
    bool owns_memory_;
  };


                                // constructors
  RootNode::RootNode ()
    : root_()
  {
    ClearSilverNode::HDF* root = 0;
    hdf_init (&root);
    RootNode r (root, true);
    swap (r);
  }

  RootNode::RootNode (ClearSilverNode::HDF* root, bool owns_memory)
    : root_(root, Deleter(owns_memory)) {}

  RootNode::RootNode (const RootNode& r)
    : root_(r.root_)
  {}

  RootNode::~RootNode () throw() {}

                                // assignment
  RootNode&
  RootNode::operator = (const RootNode& r)
  {
    RootNode r0 (r);
    swap (r0);
    return *this;
  }

                                // swap contents with another object.
  void
  RootNode::swap (RootNode& n) throw()
  {
    root_.swap (n.root_);
  }

  ClearSilverNode
  RootNode::operator () () const
  {
    return ClearSilverNode (root_.get());
  }

                                // is the root node empty?
  bool
  RootNode::empty () const
  {
    if (!root_)
      {
        string message;
        message += "RootNode::empty(): ";
        message += "root node is a nil pointer";
        ClearSilverException e (message);
        throw e;
      }
    return ClearSilverNode (root_.get()).child().empty();
  }

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

  Deleter::Deleter (bool owns_memory) : owns_memory_(owns_memory) {}

  void 
  Deleter::operator () (ClearSilverNode::HDF* root) const
  {
    if (owns_memory_)
      {
        ClearSilverNode n (root);
        n.remove_tree ();
      }
  }
};                              // namespace ClearSilver

---