jccl::ConfigElement Class Reference

A unit of configuration information. More...

#include <jccl/Config/ConfigElement.h>

List of all members.

Public Member Functions
	ConfigElement ()
	Constructor.
	ConfigElement (ConfigDefinitionPtr def)
	Constructs a ConfigElement matching the given definition.
	ConfigElement (const ConfigElement &c)
	Copy constructor.
	~ConfigElement ()
	Destroys a ConfigElement and frees associated memory.
bool	isValid () const
bool	initFromNode (cppdom::NodePtr elementNode)
	Initializes this element from cppdom::Node.
ConfigElement &	operator= (const ConfigElement &c)
	Assignment operator.
bool	operator== (const ConfigElement &c) const
	Tests for value equality of two ConfigElements.
bool	operator!= (const ConfigElement &c) const
	Inequality.
bool	operator< (const ConfigElement &c) const
	Lexical comparison based on element names (alphabetically).
ConfigElementPtr	getChildElement (const std::string &path)
	Gets a child element from a property of self.
std::string	getName () const
	Returns the instance name of this ConfigElement without any hierarchy information.
std::string	getFullName () const
	Returns the fully qualified, unique name of this element.
unsigned int	getVersion () const
	Returns the version number of the definition used by this ConfigElement.
std::string	getID () const
	Returns the string that identifies self's ConfigDefinition.
template<class T>
T	getProperty (const std::string &prop, int ind) const
	Specialization for ConfigElementPtr's.
template<class T>
T	getProperty (const std::string &prop) const
	Gets value that defaults to property 0.
template<class T>
bool	setProperty (const std::string &prop, const int ind, T val)
	Sets a value for the given property.
bool	setProperty (const std::string &prop, const int ind, bool val)
	Specialization for boolean values.
bool	setProperty (const std::string &prop, const int ind, ConfigElementPtr val)
	Specialization for ConfigElementPtrs.
std::vector< std::string >	getElementPtrDependencies () const
	Returns a list of self's depenencies.
std::vector< jccl::ConfigElementPtr >	getChildElements () const
	Return a list of self's child (embedded) elements.
void	setDefinition (ConfigDefinitionPtr d)
	Associates the definintion d with this element.
ConfigDefinitionPtr	getConfigDefinition ()
	Returns the Config Definition for this ConfigElement.
cppdom::NodePtr	getNode () const
Protected Member Functions
std::string	getPropertyString (const std::string &prop, int ind) const
	Returns the string value of the given property.
cppdom::NodePtr	getPropertyCdataNode (const std::string &prop, int ind, bool autoCreate) const
	Get the property's cdata node.
bool	getProperty_bool (const std::string &prop, int ind) const
	Gets a boolean value from the given property.
ConfigElementPtr	getProperty_ElementPtr (const std::string &prop, int ind) const
	Gets an element ptr from the given property.
Protected Attributes
cppdom::NodePtr	mNode
	Node for the config element.
ConfigDefinitionPtr	mDef
	Definition for this element.
bool	mValid
	Flag to signal whether element is valid.
Friends
JCCL_API(std::ostream	getNum (const std::string &property) const &) operator<<(std unsigned int
	Returns the number of values for the specified property.

---

Detailed Description

A unit of configuration information.

References a config element DOM node and a definition for the given configuration element type.

Definition at line 55 of file ConfigElement.h.

---

Constructor & Destructor Documentation

jccl::ConfigElement::ConfigElement

(

)

Constructor.

Definition at line 83 of file ConfigElement.cpp.

References mValid.

Referenced by getChildElement(), and getProperty_ElementPtr().

{
   mValid = true;
}

jccl::ConfigElement::ConfigElement

(

ConfigDefinitionPtr

def

)

Constructs a ConfigElement matching the given definition.

Parameters:

def

Points to a valid ConfigDefinition.

Definition at line 88 of file ConfigElement.cpp.

References mNode, mValid, and setDefinition().

{
   mValid = true;
   setDefinition(def);
   mNode = ElementFactory::instance()->createXMLNode(); // Create a fresh node
}

jccl::ConfigElement::ConfigElement

(

const ConfigElement &

c

)

Copy constructor.

Definition at line 95 of file ConfigElement.cpp.

References mValid.

{
   mValid = true;
   *this = c;
}

jccl::ConfigElement::~ConfigElement

(

)

Destroys a ConfigElement and frees associated memory.

Postcondition:

Self has been destroyed, along with all properties and values associated with it (but _not_ the memory associated with its ConfigDefinition).

Definition at line 101 of file ConfigElement.cpp.

References mValid.

{
   mValid = false;
}

---

Member Function Documentation

bool jccl::ConfigElement::isValid

(

)

const

Definition at line 106 of file ConfigElement.cpp.

References mValid.

{
   return mValid;
}

bool jccl::ConfigElement::initFromNode

(

cppdom::NodePtr

elementNode

)

Initializes this element from cppdom::Node.

Constructs the element to reference the given element node.

Postcondition:

This element is set up and initialized.

Returns:

false if failed to initialize.

Definition at line 111 of file ConfigElement.cpp.

References mNode, mValid, setDefinition(), and jccl::configuration_tokens::VERSION().

{
   bool ret_val(false);
   vprASSERT(elementNode.get() != NULL);    // Make sure we have a valid node

   // Lookup our definintion.
   std::string my_type = elementNode->getName();
   ConfigDefinitionPtr def_ptr =
      ElementFactory::instance()->getConfigDefinition(my_type);

   if(def_ptr.get() == NULL)
   {
      const unsigned int my_version =
         elementNode->getAttribute(tokens::VERSION).getValue<unsigned int>();
      vprDEBUG(vprDBG_ALL, vprDBG_WARNING_LVL)
         << clrOutBOLD(clrYELLOW, "WARNING")
         << ": Failed to get definition for element type '" << my_type
         << "' version " << my_version
         << "\n\tYou may have an invalid configuration element.\n"
         << vprDEBUG_FLUSH;
      ret_val = false;
   }
   else
   {
      mNode = elementNode;
      mValid = true;
      setDefinition(def_ptr);
      ret_val = true;
   }
   return ret_val;
}

ConfigElement & jccl::ConfigElement::operator=

(

const ConfigElement &

c

)

Assignment operator.

Definition at line 143 of file ConfigElement.cpp.

References mDef, mNode, and mValid.

{
   if (! (this == &c) )    // Different objects
   {
      mNode  = c.mNode;
      mDef   = c.mDef;
      mValid = c.mValid;
   }

   return *this;
}

bool jccl::ConfigElement::operator==

(

const ConfigElement &

c

)

const

Tests for value equality of two ConfigElements.

Returns:

True iff self and c have the same values for all properties.

Definition at line 155 of file ConfigElement.cpp.

References mDef, and mNode.

{
   // Check definitions first, then check the xml node contents
   if ( mDef.get() != c.mDef.get() )
   {
      return false;
   }

   bool is_equal = mNode->isEqual(c.mNode);
   /*
   std::ostringstream self_string, c_string;
   mNode->save(self_string);
   c.mNode->save(c_string);
   */

   return is_equal;
}

bool jccl::ConfigElement::operator!=

(

const ConfigElement &

c

)

const

Inequality.

Definition at line 173 of file ConfigElement.cpp.

{
   return !(*this == c);
}

bool jccl::ConfigElement::operator<

(

const ConfigElement &

c

)

const

Lexical comparison based on element names (alphabetically).

Definition at line 178 of file ConfigElement.cpp.

References getName().

{
   std::string s1 = getName();
   std::string s2 = c.getName();
   return (s1 < s2);
}

ConfigElementPtr jccl::ConfigElement::getChildElement

(

const std::string &

path

)

Gets a child element from a property of self.

Parameters:

path

The complete name of a child element in self. The form is, for example, "property_token/instance_name".

Note:

This uses the name attribute of the elements.

Returns:

The ConfigElementPtr that is the child element. This may be a NULL ConfigElementPtr if the child element name was not found. Check before use.

Definition at line 203 of file ConfigElement.cpp.

References ConfigElement(), getFirstNameComponent(), getRemainder(), jccl::PropertyDefinition::getVarType(), hasSeparator(), mDef, mNode, and jccl::T_CHILD_ELEMENT.

{
   std::string working_path(path), prop_token;
   cppdom::NodePtr root(mNode);
   cppdom::NodeList props;

   while ( hasSeparator(working_path) )
   {
      prop_token = getFirstNameComponent(working_path);

      // Move on to the next element in the path.
      working_path = getRemainder(working_path);

      PropertyDefinition prop_def = mDef->getPropertyDefinition(prop_token);

      // Now find the property child matching the current path element and the
      // corresponding property definition.
      props = root->getChildren(prop_token);

      if ( prop_def.getVarType() == jccl::T_CHILD_ELEMENT && ! props.empty() )
      {
         // Get the name of the child element we want.
         std::string child_element_name = getFirstNameComponent(working_path);
         working_path = getRemainder(working_path);

         // Reset root to NULL so that we can use its internal value later to
         // determine if we are done.
         root.reset();

         NamePred name_pred(child_element_name);
         cppdom::NodeList children;

         // Search the properties for a child whose "name" attribute matches
         // child_element_name.
         for ( cppdom::NodeList::iterator i = props.begin();
               i != props.end();
               ++i )
         {
            children = (*i)->getChildrenPred(name_pred);
            vprASSERT((children.empty() || children.size() <= 1) && "Element name not unique");

            if ( ! children.empty() )
            {
               root = *(children.begin());
               break;
            }
         }
      }
   }

   if ( root.get() != NULL )
   {
      ConfigElementPtr ret_node(new ConfigElement());
      ret_node->initFromNode(root);
      return ret_node;
   }
   else
   {
      return ConfigElementPtr();
   }
}

std::string jccl::ConfigElement::getName

(

)

const

Returns the instance name of this ConfigElement without any hierarchy information.

See also:

getFullName

Definition at line 265 of file ConfigElement.cpp.

References mNode, and jccl::configuration_tokens::NAME().

Referenced by getFullName(), getProperty_bool(), and operator<().

{
   return mNode->getAttribute(tokens::NAME).getString();
}

std::string jccl::ConfigElement::getFullName

(

)

const

Returns the fully qualified, unique name of this element.

This will be different from getName() when this element is a child of another element. In that case, the name will be based on the element hierarchy and the property token. The format in that case will be "element name 0/property_token_0/element name 1/property_token_1/..."

Definition at line 270 of file ConfigElement.cpp.

References jccl::configuration_tokens::ELEMENTS(), jccl::EMBEDDED_SEPARATOR(), getName(), mNode, and jccl::configuration_tokens::NAME().

{
   cppdom::Node *element_parent, *prop_parent;
   std::string full_name(getName());

   element_parent = mNode.get();

   while ( (prop_parent = element_parent->getParent()) != NULL &&
           prop_parent->getName() != std::string("root") &&
           prop_parent->getName() != tokens::ELEMENTS )
   {
      full_name = prop_parent->getName() + jccl::EMBEDDED_SEPARATOR + full_name;
      element_parent = prop_parent->getParent();
      full_name = element_parent->getAttribute(tokens::NAME).getString() +
                  EMBEDDED_SEPARATOR + full_name;
   }

   return full_name;
}

unsigned int jccl::ConfigElement::getVersion

(

)

const

Returns the version number of the definition used by this ConfigElement.

Definition at line 290 of file ConfigElement.cpp.

References mNode, and jccl::configuration_tokens::VERSION().

{
   return mNode->getAttribute(tokens::VERSION).getValue<unsigned int>();
}

std::string jccl::ConfigElement::getID

(

)

const

Returns the string that identifies self's ConfigDefinition.

Definition at line 457 of file ConfigElement.cpp.

References mDef.

{
   return mDef->getToken();
}

ConfigElementPtr jccl::ConfigElement::getProperty< ConfigElementPtr >	(	const std::string &	prop,
		int	ind
	)			const [inline]

Specialization for ConfigElementPtr's.

Parameters:

	prop	The token string for a property.
	ind	The index to the property's list of values. Use getNum() to determine the number of values for a given property. The valid range is 0 to getNum()-1.

Note:

Call with a template parameter equal to the type to return ie. getProperty<int>("int_property", 3);

Todo:

This function could throw I/O exceptions. Maybe catch those and turn them into something JCCL'ish.

Definition at line 174 of file ConfigElement.h.

   {
      std::string prop_string = getPropertyString(prop,ind);

      T ret_val = T();
      std::istringstream iss(prop_string);
      iss >> ret_val;
      return ret_val;
   }

template<class T>

T jccl::ConfigElement::getProperty

(

const std::string &

prop

)

const [inline]

Gets value that defaults to property 0.

Note:

Can't use default param because GCC doesn't allow specialization in a declaration. In other words we couldn't use a default value for the property index within the std::string and ConfigElementPtr specializations.

Definition at line 363 of file ConfigElement.h.

{
   return getProperty<T>(prop, 0);
}

template<class T>

bool jccl::ConfigElement::setProperty	(	const std::string &	prop,
		const int	ind,
		T	val
	)			[inline]

Sets a value for the given property.

Parameters:

	prop	The token string for a property.
	ind	The index to the property's list of values.
	val	The value to set.

Note:

If property does not exist yet, then we create it in the element.

Definition at line 242 of file ConfigElement.h.

   {
      cppdom::NodePtr cdata_node = getPropertyCdataNode(prop, ind, true);
      vprASSERT(cdata_node.get() != NULL && "Autogrow failed");

      std::ostringstream oss;
      oss << val;
      cdata_node->setCdata(oss.str());
      return true;
   }

bool jccl::ConfigElement::setProperty	(	const std::string &	prop,
		const int	ind,
		bool	val
	)

Specialization for boolean values.

Definition at line 462 of file ConfigElement.cpp.

References getPropertyCdataNode().

{
   cppdom::NodePtr cdata_node = getPropertyCdataNode(prop, ind, true);
   vprASSERT(cdata_node.get() != NULL && "Autogrow failed");

   std::string str_val;

   if (true == val)
   {
      str_val = "true";
   }
   else
   {
      str_val = "false";
   }
   cdata_node->setCdata(str_val);

   return true;
}

bool jccl::ConfigElement::setProperty	(	const std::string &	prop,
		const int	ind,
		ConfigElementPtr	val
	)

Specialization for ConfigElementPtrs.

Definition at line 482 of file ConfigElement.cpp.

{
   boost::ignore_unused_variable_warning(prop);
   boost::ignore_unused_variable_warning(ind);
   boost::ignore_unused_variable_warning(val);
   vprASSERT(false && "Not implemented");
   return false;
}

std::vector< std::string > jccl::ConfigElement::getElementPtrDependencies

(

)

const

Returns a list of self's depenencies.

Dependencies are any config elements named by an "Element Pointer" property of self (or any element embedded in self).

Returns:

A vector of the names of all config elements referenced by self, which can be used for dependency checking.

Definition at line 369 of file ConfigElement.cpp.

References getNum, mDef, jccl::T_CHILD_ELEMENT, and jccl::T_ELEMENT_PTR.

{
   std::vector<std::string> dep_list;     // Create return vector
   std::string prop_token;

   std::vector<PropertyDefinition> prop_defs = mDef->getAllPropertyDefinitions();

   //cout << "Dependency test for " << getProperty ("name") << endl;
   // For each property definition.
   for ( unsigned int i = 0; i < prop_defs.size(); ++i )
   {
      VarType var_type = prop_defs[i].getVarType();

      // If it is an element ptr or a child element.
      if ( (var_type == T_ELEMENT_PTR) || (var_type == T_CHILD_ELEMENT) )
      {
         std::string prop_token = prop_defs[i].getToken();         // Get the property name
         unsigned int num_props = getNum(prop_token);    // How many entries

         // For each sub property.
         for ( unsigned int j = 0; j < num_props; ++j )
         {
            // Just get the element names and add it.
            if(var_type == T_ELEMENT_PTR)
            {
               std::string element_name = this->getProperty<std::string>(prop_token, j);
               if ( element_name != "")
               {
                  dep_list.push_back(element_name);
               }
            }
            else if(var_type == T_CHILD_ELEMENT)   // Recurse and add
            {
               std::vector<std::string> child_deps;
               ConfigElementPtr child_element = this->getProperty<ConfigElementPtr>(prop_token, j);
               vprASSERT(child_element.get() != NULL);
               child_deps = child_element->getElementPtrDependencies();
               dep_list.insert(dep_list.end(), child_deps.begin(), child_deps.end());
            }
         }
      }
   }

   return dep_list;      // Return the list
}

std::vector< jccl::ConfigElementPtr > jccl::ConfigElement::getChildElements

(

)

const

Return a list of self's child (embedded) elements.

Returns:

A vector of ConfigElementPtr objects that are the config elements embedded in self.

Definition at line 415 of file ConfigElement.cpp.

References getNum, mDef, and jccl::T_CHILD_ELEMENT.

{
   std::vector<jccl::ConfigElementPtr> embedded_list;     // Create return vector
   std::string prop_token;

   std::vector<PropertyDefinition> prop_defs = mDef->getAllPropertyDefinitions();

   //cout << "Dependency test for " << getProperty ("name") << endl;
   // For each property definition.
   for ( unsigned int i = 0; i < prop_defs.size(); ++i )
   {
      VarType var_type = prop_defs[i].getVarType();
      if ( (var_type == T_CHILD_ELEMENT) )   // If property is a child element
      {
         prop_token = prop_defs[i].getToken();         // Get the property name
         unsigned int num_props = getNum(prop_token);    // How many entries

         // For each entry.
         for ( unsigned int j = 0; j < num_props; ++j )
         {
            ConfigElementPtr child_element =
               this->getProperty<ConfigElementPtr>(prop_token, j);
            vprASSERT(child_element.get() != NULL);
            embedded_list.push_back(child_element);
         }
      }
   }

   return embedded_list;      // Return the list
}

void jccl::ConfigElement::setDefinition

(

ConfigDefinitionPtr

d

)

Associates the definintion d with this element.

Postcondition:

Set the definintion for this element.

Definition at line 491 of file ConfigElement.cpp.

References mDef.

Referenced by ConfigElement(), and initFromNode().

{
   vprASSERT(def.get() != NULL && "Trying to set a null definition");
   mDef = def;
}

ConfigDefinitionPtr jccl::ConfigElement::getConfigDefinition

(

)

Returns the Config Definition for this ConfigElement.

Definition at line 497 of file ConfigElement.cpp.

References mDef.

{
   return mDef;
}

cppdom::NodePtr jccl::ConfigElement::getNode

(

)

const

Definition at line 502 of file ConfigElement.cpp.

References mNode.

{
   return mNode;
}

std::string jccl::ConfigElement::getPropertyString	(	const std::string &	prop,
		int	ind
	)			const [protected]

Returns the string value of the given property.

Postcondition:

If property is found, then return the contents. Else return "".

Parameters:

	prop	The token string for the property.
	ind	The index of the property.

Definition at line 564 of file ConfigElement.cpp.

References jccl::definition_tokens::ENUM_VALUE(), jccl::definition_tokens::ENUMERATION(), jccl::PropertyDefinition::getDefaultValueString(), jccl::PropertyDefinition::getNode(), getPropertyCdataNode(), jcclDBG_CONFIG(), jccl::definition_tokens::LABEL(), mDef, mNode, jccl::configuration_tokens::NAME(), and jccl::definition_tokens::VALUE().

Referenced by getProperty_bool().

{
   vprASSERT(mNode.get() != NULL);
   vprASSERT(tokens::NAME != prop && "Use getName() to get an element's name");

   std::string prop_string_rep("");     // The String rep to convert from
   PropertyDefinition prop_def = mDef->getPropertyDefinition(prop);

   // Ensure that a valid property was requested before taking any action.
   if ( prop_def.getNode().get() == NULL )
   {
      vprDEBUG(vprDBG_ERROR, vprDBG_CRITICAL_LVL)
         << clrOutBOLD(clrRED, "ERROR")
         << ": [jccl::ConfigElement::getPropertyString()] Invalid property '"
         << prop << "' requested!\n" << vprDEBUG_FLUSH;
      vprASSERT(false && "Invalid property requested.");
   }
   else
   {
      // Get the cdata node without auto create
      cppdom::NodePtr cdata_node = getPropertyCdataNode(prop,ind,false);

      if(cdata_node.get() != NULL)
      {
         prop_string_rep = cdata_node->getCdata();            // Get the cdata
      }
      // Fall back on the default value.
      else
      {
         prop_string_rep = prop_def.getDefaultValueString(ind);
      }

      cppdom::NodePtr enum_child(prop_def.getNode()->getChild(definition_tokens::ENUMERATION));

      if ( enum_child.get() != NULL )
      {
         cppdom::NodeList enum_vals(enum_child->getChildren(definition_tokens::ENUM_VALUE));

         // If the property definition has an enumeration, the string in
         // prop_string_rep may be symbolic.  We need to translate it to the
         // real value before returning.
         if ( ! enum_vals.empty() )
         {
            for ( cppdom::NodeList::iterator i = enum_vals.begin();
                  i != enum_vals.end();
                  ++i )
            {
               if ( prop_string_rep == (std::string) (*i)->getAttribute(definition_tokens::LABEL) )
               {
                  vprDEBUG(jcclDBG_CONFIG, vprDBG_HVERB_LVL)
                     << "jccl::ConfigElement::getPropertyString(): Converting '"
                     << prop_string_rep << "' to '"
                     << (std::string) (*i)->getAttribute(definition_tokens::VALUE)
                     << "'\n" << vprDEBUG_FLUSH;
                  prop_string_rep =
                     (std::string) (*i)->getAttribute(definition_tokens::VALUE);
               }
            }
         }
      }
   }

   return prop_string_rep;
}

cppdom::NodePtr jccl::ConfigElement::getPropertyCdataNode	(	const std::string &	prop,
		int	ind,
		bool	autoCreate
	)			const [protected]

Get the property's cdata node.

Parameters:

	prop	The property token.
	ind	The index inside the property.
	autoCreate	If true, then autocreate the property node to use.

Note:

We always autocreate the cdata node if need be.

Definition at line 514 of file ConfigElement.cpp.

References jccl::PropertyDefinition::getDefaultValueString(), mDef, and mNode.

Referenced by getPropertyString(), and setProperty().

{
   vprASSERT(mNode.get() != NULL);

   cppdom::NodePtr cdata_node(NULL);
   cppdom::NodeList prop_children(mNode->getChildren(prop));    // Get all children call prop

   // -- Autogrow for children --- //
   if( !(prop_children.size() > unsigned(ind)) && autoCreate)      // If child not in range and autocreate
   {
      PropertyDefinition prop_def = mDef->getPropertyDefinition(prop);

      while( !(prop_children.size() > unsigned(ind) ))     // While not in range
      {
         cppdom::NodePtr new_node = ElementFactory::instance()->createXMLNode();
         new_node->setName(prop);
         new_node->setCdata(prop_def.getDefaultValueString(ind));
         mNode->addChild(new_node);                      // Add Child
         prop_children = mNode->getChildren(prop);       // Get children again to check size
      }
   }

   // --- GET the cdata node --- //
   if(prop_children.size() > unsigned(ind))                                 // If we have children in range
   {
      cppdom::NodeList::iterator property_i(prop_children.begin());
      std::advance(property_i, ind);                                    // Advance to the correct child
      cdata_node = (*property_i)->getChild("cdata");        // Get the text node

      if(cdata_node.get() == NULL)     // If no cdata node, then make one
      {
         cppdom::NodePtr new_cdata_node = ElementFactory::instance()->createXMLNode();
         new_cdata_node->setName("cdata");
#if CPPDOM_VERSION_MAJOR == 0 && CPPDOM_VERSION_MINOR < 4
         new_cdata_node->setType(cppdom::xml_nt_cdata);
#else
         new_cdata_node->setType(cppdom::Node::xml_nt_cdata);
#endif
         (*property_i)->addChild(new_cdata_node);
         cdata_node = new_cdata_node;
      }

      vprASSERT(cdata_node.get() != NULL);
   }
   else
   { vprASSERT(!autoCreate && "Auto create failed"); }

   return cdata_node;
}

bool jccl::ConfigElement::getProperty_bool	(	const std::string &	prop,
		int	ind
	)			const [protected]

Gets a boolean value from the given property.

Have to call this way because std::stringstring does not convert "true" and "false" into corresponding bool values.

Definition at line 295 of file ConfigElement.cpp.

References getName(), getPropertyString(), and jcclDBG_CONFIG().

{
   const std::string prop_string = getPropertyString(prop, ind);
   if ( std::string("false") == prop_string || std::string("0") == prop_string )
   {
      return false;
   }
   else if ( std::string("true") == prop_string ||
             std::string("1") == prop_string )
   {
      return true;
   }
   else
   {
      vprDEBUG(jcclDBG_CONFIG, vprDBG_CONFIG_LVL)
         << "Expecting boolean string for property '" << prop
         << "' in config element '" << getName() << "'. Got '"
         << prop_string << "' instead. Assuming value of true.\n"
         << vprDEBUG_FLUSH;
      return true;
   }
}

ConfigElementPtr jccl::ConfigElement::getProperty_ElementPtr	(	const std::string &	prop,
		int	ind
	)			const [protected]

Gets an element ptr from the given property.

Have to call this way because specialization would use symbols that aren't available.

Definition at line 318 of file ConfigElement.cpp.

References ConfigElement(), mDef, mNode, and jccl::T_CHILD_ELEMENT.

{
   // Get the var type
   vprASSERT(mDef->getPropertyDefinition(prop).getVarType() == T_CHILD_ELEMENT);
   vprASSERT(mNode.get() != NULL);

   // Get all property children matching the given property type.
   cppdom::NodeList prop_children(mNode->getChildren(prop));

   cppdom::NodePtr embedded_node(NULL);

   // --- GET the cdata node --- //
   if(prop_children.size() > unsigned(ind))                       // If we have children in range
   {
      cppdom::NodeList::iterator property_i(prop_children.begin());
      std::advance(property_i, ind);                              // Advance to the correct property

      // Get the children of this property.  There should only be one child
      // that is the element.
      cppdom::NodeList emb_nodes = (*property_i)->getChildren();
      vprASSERT(! emb_nodes.empty() && "Empty property");
      embedded_node = *(emb_nodes.begin());
   }

   ConfigElementPtr ret_val;
   if(embedded_node.get() != NULL)
   {
      // Create a new config element refrencing the embedded node.
      ret_val = ConfigElementPtr( new ConfigElement());
      bool init_status = ret_val->initFromNode(embedded_node);
      // check for failure
      if(!init_status)
      {
         vprDEBUG(vprDBG_ALL, vprDBG_CRITICAL_LVL)
            << "Failed to initialize embedded config element" << std::endl
            << vprDEBUG_FLUSH;
         vprDEBUG_NEXT(vprDBG_ALL, vprDBG_CRITICAL_LVL)
            << "(property '" << prop << "')\n" << vprDEBUG_FLUSH;

         ret_val = ConfigElementPtr();      // Set to NULL
      }
   }

   return ret_val;
}

---

Friends And Related Function Documentation

unsigned int jccl::ConfigElement::getNum

(

const std::string &

property

)

const [friend]

Returns the number of values for the specified property.

Precondition:

The named property exists in the definition for this config element.

Parameters:

property

The token of a property. This comes from the definition for this config element.

Returns:

The number of values that exist for the given property which may be 0.

Definition at line 452 of file ConfigElement.cpp.

Referenced by getChildElements(), and getElementPtrDependencies().

{
   return mNode->getChildren(property_token).size();
}

---

Member Data Documentation

cppdom::NodePtr jccl::ConfigElement::mNode [protected]

Node for the config element.

Definition at line 329 of file ConfigElement.h.

Referenced by ConfigElement(), getChildElement(), getFullName(), getName(), getNode(), getProperty_ElementPtr(), getPropertyCdataNode(), getPropertyString(), getVersion(), initFromNode(), operator=(), and operator==().

ConfigDefinitionPtr jccl::ConfigElement::mDef [protected]

Definition for this element.

Definition at line 330 of file ConfigElement.h.

Referenced by getChildElement(), getChildElements(), getConfigDefinition(), getElementPtrDependencies(), getID(), getProperty_ElementPtr(), getPropertyCdataNode(), getPropertyString(), operator=(), operator==(), and setDefinition().

bool jccl::ConfigElement::mValid [protected]

Flag to signal whether element is valid.

Definition at line 331 of file ConfigElement.h.

Referenced by ConfigElement(), initFromNode(), isValid(), operator=(), and ~ConfigElement().

---

The documentation for this class was generated from the following files:

• ConfigElement.h
• ConfigElement.cpp

---