S3FC project page

S3FC home page

---

               

---

s3_config_node.cc

Go to the documentation of this file.

/*
 * Stone Three Foundation Class (s3fc) provides a number of utility classes.
 * Copyright (C) 2001 by Stone Three Signal Processing (Pty) Ltd.
 *
 * Authored by Stone Three Signal Processing (Pty) Ltd.
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2.1 of the License, or (at your option) any later version.
 * 
 * This library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.
 * 
 * You should have received a copy of the GNU Lesser General Public
 * License along with this library; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 * 
 * Please see the file 'COPYING' in the source root directory.
 */

#include <s3fc/s3_config_node.h>
#include <cstdlib>   // atoi
#include <sstream>
#include <string>

s3_config_node s3_config_node::empty_node;
s3_config_node s3_config_node::at_end;


#if 0
void s3_config_node::dump() const
{
   std::cerr << endl
        << " n: " << name << std::endl
        << " v: " << value << std::endl
        << " p: " << parent << std::endl
        << " e: " << &empty_node << std::endl
        << " t: " << this << std::endl
        << std::endl << std::flush;
}
#endif

// init ctor - init from supplied values and update parent
s3_config_node::s3_config_node(
   const std::string& n_name,
   const std::string& n_value,
   const s3_config_node* n_parent,
   const std::map<std::string,std::string>& n_attributes,
   const std::vector<s3_config_node>& n_children) :
   a_name(n_name),
   a_value(n_value),
   a_parent(const_cast<s3_config_node*>(n_parent)),
   a_attributes(n_attributes),
   a_children(n_children)
{
   for (std::vector<s3_config_node>::iterator it = a_children.begin();
   it != a_children.end();
   it++)
   {
      it->a_parent = this;
   }
}

// copy ctor - deep copy and update parent
s3_config_node::s3_config_node(const s3_config_node& src) :
   a_name(src.a_name),
   a_value(src.a_value),
   a_parent(&empty_node),
   a_attributes(src.a_attributes),
   a_children(src.a_children)
{
   for (std::vector<s3_config_node>::iterator it = a_children.begin();
   it != a_children.end();
   it++)
   {
      it->a_parent = this;
   }
}

// copy assign - recursive deep, but dont change parent
s3_config_node& s3_config_node::operator=(const s3_config_node& src)
{
   a_name = src.a_name;
   a_value = src.a_value;
   a_parent = &empty_node;
   a_attributes = src.a_attributes;
   a_children = src.a_children;
   for (std::vector<s3_config_node>::iterator it = a_children.begin();
   it != a_children.end();
   it++)
   {
      it->a_parent = this;
   }
   return *this;
}

// true if this == &empty_node
bool s3_config_node::empty() const
{
   return (this == &empty_node);
}

// true is parent 0
bool s3_config_node::is_rootnode() const
{
   return (a_parent == &empty_node);
}

//
s3_config_node*& s3_config_node::parent()
{
   return a_parent;
}

//
std::string& s3_config_node::name()
{
   return a_name;
}

//
std::string& s3_config_node::value()
{
   return a_value;
}

//
std::map<std::string, std::string>& s3_config_node::attributes()
{
   return a_attributes;
}

//
std::vector<s3_config_node>& s3_config_node::children()
{
   return a_children;
}

//
s3_config_node* s3_config_node::insert_child(const s3_config_node& child,
                    const s3_config_node& before)
{
   s3_config_node* rv;
   // add child at end
   if (&before == &at_end)
   {
      a_children.push_back(child);
      rv = &(a_children.back());
   }
   // add child somewhere else
   else
   {
      std::vector<s3_config_node>::iterator it = find_child(child);
      if (it == a_children.end())
      {
    throw s3_generic_exception("s3_config_node::insert_child()",
                "Precondition violation: "
                "find_children(before) != a_children.end()");
      }
      // insert before before
      it = a_children.insert(it, child);
      // set parent
      it->a_parent = this;
      rv = &(*it);
   }
   return rv;
}

//
void s3_config_node::remove_child(const s3_config_node& child)
{
      std::vector<s3_config_node>::iterator it = find_child(child);
      if (it == a_children.end())
      {
    throw s3_generic_exception("s3_config_node::remove_child()",
                "Precondition violation: "
                "find_children(child) != a_children.end()");
      }
      a_children.erase(it);
}

//
std::vector<s3_config_node>::iterator s3_config_node::find_child(
   const s3_config_node& child)
{
      bool found = false;
      std::vector<s3_config_node>::iterator it;
      for(it = a_children.begin(); it != a_children.end(); it++)
      {
    if (&(*it) == &child)
    {
       found = true;
       break;
    }
      }
      if (! found) 
      {
    it = a_children.end();
      }
      return it;
}

// const parent return
const s3_config_node& s3_config_node::get_parent() const
{
   return *a_parent;
}

// parent return
s3_config_node& s3_config_node::get_parent()
{
   return *a_parent;
}

// set parent
void s3_config_node::set_parent(s3_config_node& n_parent)
{
   a_parent = &n_parent;
}

//
const std::string& s3_config_node::get_name() const
{
   return a_name;
}

//
void s3_config_node::set_name(const std::string& n_name) 
{
   a_name = n_name;
}

//
const std::string& s3_config_node::get_value() const
{
   return a_value;
}

//
void s3_config_node::set_value(const std::string& n_value)
{
   a_value = n_value;
}

// const attribute return
const std::map<std::string, std::string>& s3_config_node::get_attributes() const
{
   return a_attributes;
}

// attribute return
std::map<std::string, std::string>& s3_config_node::get_attributes()
{
   return a_attributes;
}

//
unsigned int s3_config_node::get_num_children() const
{
   return a_children.size();
}

// return child node by ref
const s3_config_node& s3_config_node::get_child(unsigned int i) const
{
   if (! (i < get_num_children()) )
   {
      throw s3_generic_exception("s3_config_node::get_child()",
             "Precondition violation: "
             "i < get_num_children()");
   }
   return a_children[i];
}

// child node by ref
s3_config_node& s3_config_node::get_child(unsigned int i)
{
   return const_cast<s3_config_node&>(
      const_cast<const s3_config_node*>(this)->get_child(i));
}

// return const list of children matching name
const std::vector<const s3_config_node*>
s3_config_node::get_children(const std::string& name_filter) const
{
   std::vector<const s3_config_node*> lst;
   
   for (std::vector<s3_config_node>::const_iterator it = a_children.begin();
   it != a_children.end();
   ++it)
   {
      if ( (name_filter == "") || (it->get_name() == name_filter) )
      {
         lst.push_back(&(*it));
      }
   }
   return lst;
}

// return list of children matching name
std::vector<s3_config_node*>
s3_config_node::get_children(const std::string& name_filter)
{
   std::vector<const s3_config_node*> lst =
      const_cast<const s3_config_node*>(this)->get_children(name_filter);
   return reinterpret_cast<std::vector<s3_config_node*>&>(lst);
}

//
bool s3_config_node::node_exists(const std::string& path) const
{
   const s3_config_node* nptr = gna_helper(path);
   return (nptr != 0);
}

// const return specified node
const s3_config_node&
s3_config_node::get_node_at(const std::string& path) const
{
   const s3_config_node* nptr = gna_helper(path);
   if (nptr == 0)
   {
      throw s3_generic_exception("s3_config_node::get_child()",
             "Precondition violation: "
             "i < get_num_children()");
   }
   return *nptr;
}

// return specified node
s3_config_node&
s3_config_node::get_node_at(const std::string& path)
{
   return const_cast<s3_config_node&>(
      const_cast<const s3_config_node*>(this)->get_node_at(path));
}

//
const s3_config_node* s3_config_node::gna_helper(const std::string& path) const
{
   std::vector<std::string> vs;
   // current position - at start
   size_t pos = 0;

   // First split path into a vector of child names.
   while (true)
   {
      // find first token starting at pos
      unsigned int strt_i = path.find_first_not_of(" \t\n\r:#", pos);
      // find ws after token
      unsigned int end_i = path.find_first_of(":", strt_i);
      if (strt_i != std::string::npos)
      {
         vs.push_back(path.substr(strt_i, end_i - strt_i));
         pos = end_i;
      }
      else
      {
         break;
      }
   }

   std::string name;
   unsigned int idx;
   const s3_config_node* node = this;

   //
   std::vector<const s3_config_node*> child_list;
   
   // Next, traverse down the tree.
   for (std::vector<std::string>::const_iterator ptr = vs.begin();
   ptr != vs.end();
   ptr++)
   {
      unsigned int i_pos = ptr->find_first_of("#", 0);
      idx = 0;
      if (i_pos != std::string::npos)
      {
         name = ptr->substr(0, i_pos);
         if (i_pos < ptr->size() - 1)
         {
            idx=atoi((ptr->substr(i_pos + 1, ptr->size() - i_pos - 1)).c_str());
         }
      }
      else
      {
         name = *ptr;
      }
      child_list = node->get_children(name);
      // invalid path - leave
      if (child_list.size() < (idx + 1))
      {
    node = 0;
    break;
      }
      node = child_list[idx];
   }
   return node;
}

---

Send comments to: s3fc@stonethree.com