ConfigElement.h

Go to the documentation of this file.

/*************** <auto-copyright.pl BEGIN do not edit this line> **************
 *
 * VR Juggler is (C) Copyright 1998-2005 by Iowa State University
 *
 * Original Authors:
 *   Allen Bierbaum, Christopher Just,
 *   Patrick Hartling, Kevin Meinert,
 *   Carolina Cruz-Neira, Albert Baker
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Library General Public
 * License as published by the Free Software Foundation; either
 * version 2 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
 * Library General Public License for more details.
 *
 * You should have received a copy of the GNU Library 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.
 *
 * -----------------------------------------------------------------
 * File:          $RCSfile$
 * Date modified: $Date: 2006-07-13 11:56:58 -0500 (Thu, 13 Jul 2006) $
 * Version:       $Revision: 19047 $
 * -----------------------------------------------------------------
 *
 *************** <auto-copyright.pl END do not edit this line> ***************/

#ifndef _JCCL_CONFIG_ELEMENT_H_
#define _JCCL_CONFIG_ELEMENT_H_

#include <jccl/jcclConfig.h>
#include <vector>

#include <sstream>
#include <cppdom/cppdom.h>
#include <vpr/Util/Assert.h>

#include <jccl/Config/ConfigElementPtr.h>
#include <jccl/Config/ConfigDefinitionPtr.h>

namespace jccl
{

class JCCL_CLASS_API ConfigElement
{
public:
   ConfigElement();

   ConfigElement(ConfigDefinitionPtr def);

   ConfigElement(const ConfigElement& c);

   ~ConfigElement();

   bool isValid() const;

   bool initFromNode(cppdom::NodePtr elementNode);

   ConfigElement& operator=(const ConfigElement& c);

   bool operator==(const ConfigElement& c) const;

   bool operator!=(const ConfigElement& c) const;

   bool operator<(const ConfigElement& c) const;

   ConfigElementPtr getChildElement(const std::string &path);

   friend JCCL_API(std::ostream&) operator<<(std::ostream& out,
                                             const ConfigElement& self);

   unsigned int getNum(const std::string& property) const;

   std::string getName() const;

   std::string getFullName() const;

   unsigned int getVersion() const;

   std::string getID() const;

   template<class T>
   T getProperty(const std::string& prop, int ind) const
   {
      std::string prop_string = getPropertyString(prop,ind);

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

   // Specializations of getProperty<T> placed inline for Visual Studio 7.
   // MIPSpro and GCC do not handle this.  They get out-of-line
   // specializations, found below.
#if defined(_MSC_VER) && _MSC_VER == 1300
   template<>
   std::string getProperty<std::string>(const std::string& prop, int ind) const
   {
      std::string prop_string = getPropertyString(prop,ind);
      return prop_string;
   }

   template<>
   bool getProperty<bool>(const std::string& prop, int ind) const
   {
      return getProperty_bool(prop, ind);
   }

   template<>
   ConfigElementPtr getProperty<ConfigElementPtr>(const std::string& prop,
                                                  int ind) const
   {
      return getProperty_ElementPtr(prop, ind);
   }
#endif /* defined(_MSC_VER) && _MSC_VER == 1300 */

#if defined(_MSC_VER) && _MSC_VER == 1300
   template<class T>
   T getProperty(const std::string& prop) const
   {
      return getProperty<T>(prop, 0);
   }
#else
   template<class T>
   T getProperty(const std::string& prop) const;
#endif

   template<class T>
   bool setProperty(const std::string& prop, const int ind, T val)
   {
      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 setProperty(const std::string& prop, const int ind, bool val);

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

   std::vector<std::string> getElementPtrDependencies() const;

   std::vector<jccl::ConfigElementPtr> getChildElements() const;

   void setDefinition(ConfigDefinitionPtr d);
   
   ConfigDefinitionPtr getConfigDefinition();

   cppdom::NodePtr getNode() const;

protected:
   std::string getPropertyString(const std::string& prop, int ind) const;

   cppdom::NodePtr getPropertyCdataNode(const std::string& prop, int ind,
                                        bool autoCreate) const;

   bool getProperty_bool(const std::string& prop, int ind) const;

   ConfigElementPtr getProperty_ElementPtr(const std::string& prop,
                                           int ind) const;

protected:
   cppdom::NodePtr     mNode;  
   ConfigDefinitionPtr mDef;   
   bool                mValid; 
};

#if ! defined(_MSC_VER) || _MSC_VER > 1300
template<>
inline std::string ConfigElement::getProperty<std::string>(const std::string& prop, int ind) const
{
   std::string prop_string = getPropertyString(prop,ind);
   return prop_string;
}

template<>
inline bool ConfigElement::getProperty<bool>(const std::string& prop, int ind) const
{
   return getProperty_bool(prop, ind);
}

template<>
inline ConfigElementPtr ConfigElement::getProperty<ConfigElementPtr>(const std::string& prop, int ind) const
{
   return getProperty_ElementPtr(prop,ind);
}

template<class T>
inline T ConfigElement::getProperty(const std::string& prop) const
{
   return getProperty<T>(prop, 0);
}
#endif /* ! defined(_MSC_VER) || _MSC_VER > 1300 */

} // namespace jccl

#endif

---