PhxXmlDescription.h

Go to the documentation of this file.

#ifndef PHX_XML_DESCRIPTION_H
#define PHX_XML_DESCRIPTION_H

#include <Phx/PhxConfig.h>
#include <Phx/PhxTypes.h>
#include <Phx/Util/PhxXml.h>
#include <sstream>
#include <map>
#include <vector>
#include <set>

namespace Phx {

  class XmlDescriptionNode {

  public:
    class AttribSpec {
    public:
      AttribSpec(const String& name) : mName(name), mIndex("") {}

      AttribSpec(const String& name, const String& index) :
        mName(name), mIndex(index) {}


      const String& name(void) const { return mName; }

      const String& index(void) const { return mIndex; }

    private:
      String mName, mIndex;
    };

  private:
    // Comparator that defines an ordering on AttribSpec's; used by std::map.
    struct AttribSpecComp {
      bool operator()(const AttribSpec& lhs, const AttribSpec& rhs) const {
        if (lhs.name() < rhs.name()) return true;
        if (lhs.name() > rhs.name()) return false;
        return lhs.index() < rhs.index();
      }
    };
  public:

    typedef std::set<AttribSpec, AttribSpecComp>  AttribSpecSet;

    XmlDescriptionNode(XmlNode* node);

    XmlDescriptionNode(const String& descType);

    XmlDescriptionNode(const XmlDescriptionNode& node);

    const XmlDescriptionNode& operator=(const XmlDescriptionNode& rhs);

    const String& type(void) const { return mType; }

    void type(const String& type) { mType = type; }

    void file(const String& file) { mFile = file; }

    const String& file(void) const { return mFile; }

    uint32_t attributeCount(void) const
    { return (uint32_t)(mAttributes.size()+mChildren.size()); }

    AttribSpecSet attributes(const String& name = "") const;

    XmlDescriptionNode* childAttribute(const AttribSpec& attrib);
    // const version of the above
    const XmlDescriptionNode* childAttribute(const AttribSpec& attrib) const;

    XmlDescriptionNode childAttributeSubstitute(const AttribSpec& attrib) const;

    void childAttribute(const AttribSpec& attrib, const XmlDescriptionNode* node);
    
    void childAttribute(const AttribSpec& attrib, const XmlDescriptionNode& node);

    String stringAttributeDefault(const AttribSpec& attrib, const String& defaultValue = "") const;

    String stringAttribute(const AttribSpec& attrib) const {
      return stringAttributeDefault(attrib);
    }

    void stringAttribute(const AttribSpec& attrib, const String& value);

    float floatAttribute(const AttribSpec& attrib) const {
      return floatAttributeDefault(attrib, 0.0f);
    }
    double   doubleAttribute(const AttribSpec& attrib) const {
      return doubleAttributeDefault(attrib, 0.0f);
    }
    uint64_t uint64Attribute(const AttribSpec& attrib) const {
      return uint64AttributeDefault(attrib, 0);
    }
    uint32_t uint32Attribute(const AttribSpec& attrib) const {
      return uint32AttributeDefault(attrib, 0);
    }
    uint16_t uint16Attribute(const AttribSpec& attrib) const {
      return uint16AttributeDefault(attrib, 0);
    }
    uint8_t uint8Attribute(const AttribSpec& attrib) const {
      return uint8AttributeDefault(attrib, 0);
    }
    int64_t int64Attribute(const AttribSpec& attrib) const {
      return int64AttributeDefault(attrib, 0);
    }
    int32_t int32Attribute(const AttribSpec& attrib) const {
      return int32AttributeDefault(attrib, 0);
    }
    int16_t int16Attribute(const AttribSpec& attrib) const {
      return int16AttributeDefault(attrib, 0);
    }
    int8_t int8Attribute(const AttribSpec& attrib) const {
      return int8AttributeDefault(attrib, 0);
    }
    bool boolAttribute(const AttribSpec& attrib) const {
      return boolAttributeDefault(attrib, false);
    }

    float    floatAttributeDefault(const AttribSpec& attrib, float defaultValue) const;
    double   doubleAttributeDefault(const AttribSpec& attrib, double defaultValue) const;
    uint64_t uint64AttributeDefault(const AttribSpec& attrib, uint64_t defaultValue) const;
    uint32_t uint32AttributeDefault(const AttribSpec& attrib, uint32_t defaultValue) const;
    uint16_t uint16AttributeDefault(const AttribSpec& attrib, uint16_t defaultValue) const;
    uint8_t uint8AttributeDefault(const AttribSpec& attrib, uint8_t defaultValue) const;
    int64_t int64AttributeDefault(const AttribSpec& attrib, int64_t defaultValue) const;
    int32_t int32AttributeDefault(const AttribSpec& attrib, int32_t defaultValue) const;
    int16_t int16AttributeDefault(const AttribSpec& attrib, int16_t defaultValue) const;
    int8_t int8AttributeDefault(const AttribSpec& attrib, int8_t defaultValue) const;
    bool boolAttributeDefault(const AttribSpec& attrib, bool defaultValue) const;

    void floatAttribute(const AttribSpec& attrib, float value);
    void doubleAttribute(const AttribSpec& attrib, double value);
    void uint64Attribute(const AttribSpec& attrib, uint64_t value);
    void uint32Attribute(const AttribSpec& attrib, uint32_t value);
    void uint16Attribute(const AttribSpec& attrib, uint16_t value);
    void uint8Attribute(const AttribSpec& attrib, uint8_t value);
    void int64Attribute(const AttribSpec& attrib, int64_t value);
    void int32Attribute(const AttribSpec& attrib, int32_t value);
    void int16Attribute(const AttribSpec& attrib, int16_t value);
    void int8Attribute(const AttribSpec& attrib, int8_t value);
    void boolAttribute(const AttribSpec& attrib, bool value);

  private:

    // ---- private implementation ----
    void clearChildren(void);
    void deleteChild(const AttribSpec& attrib);

    // Templatized attribute parser used to implement the attribute parsers.
    template <typename T>
    T readAttribute(const AttribSpec& attrib, T defaultVal) const {
      T value = defaultVal;
      AttribStringMapType::const_iterator itr = mAttributes.find(attrib);

      if (itr != mAttributes.end()) {
        std::istringstream istr(itr->second);
        istr >> value;
        if (!istr.bad() && !istr.fail()) {
          return value;
        } else {
          std::clog << "Failure while parsing attribute " 
                    << attrib.name() << ":" << attrib.index() << std::endl;
        }
      }

      return value;
    }

    // Templated attribute writer.
    template <typename T>
    void writeAttribute(const AttribSpec& attrib, T value) {
      std::stringstream stream;
      stream << value;
      if (stream.good()) {
        stringAttribute(attrib, stream.str());
      } else {
        std::clog << "Failure while writing attribute " 
                  << attrib.name() << ":" << attrib.index() << std::endl;
      }
    }


    // Prints the content of the node, excluding the leading "<TYPE"
    // portion of the printout.  That part is produced by std::ostream
    // or by the parent node that calls this method (because the
    // parent may need to insert name="xxx" and index="xxx" attribute
    // values into the text before allowing us to print).
    void print(std::ostream& os) const;

    // helper for childAttributeSubstitute()
    XmlDescriptionNode substituteFile(const XmlDescriptionNode& node) const;

    // ---- private data -----

    String mType;
    String mFile;

    typedef std::map<AttribSpec,String, AttribSpecComp>  AttribStringMapType;
    typedef std::map<AttribSpec, XmlDescriptionNode*, AttribSpecComp> AttribChildMapType; 
    AttribStringMapType mAttributes;
    AttribChildMapType  mChildren;

    friend std::ostream& operator<<(std::ostream& os, const XmlDescriptionNode& node);
  }; // class XmlDescriptionNode

  std::ostream& operator<<(std::ostream& os, const XmlDescriptionNode& node);

  std::ostream& operator<<(std::ostream& os, const XmlDescriptionNode::AttribSpec& attrib);

}; // namespace Phx

#endif /* PHX_XML_DESCRIPTION_H */

---