XMLElement.h++

Go to the documentation of this file.

/* ---------------------------------------------------------------------------
   commonc++ - A C++ Common Class Library
   Copyright (C) 2005-2014  Mark A Lindner

   This file is part of commonc++.

   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., 675 Mass Ave, Cambridge, MA 02139, USA.
   ---------------------------------------------------------------------------
*/

#ifndef __ccxx_XMLElement_hxx
#define __ccxx_XMLElement_hxx

#include <commonc++/Common.h++>
#include <commonc++/InvalidArgumentException.h++>
#include <commonc++/String.h++>

#include <vector>

namespace ccxx {

class XMLElement; // fwd decl

class COMMONCPPXML_API XMLElement
{
  friend class XMLDocument;
  friend class XMLElementConstIterator;
  friend class XMLElementIterator;

 public:

  inline String getName() const
  { return(_name); }

  void setAttribute(const String& name, const String& value);

  void setAttribute(const String& name, int value);

  void setAttribute(const String& name, const int64_t& value);

  void setAttribute(const String& name, const double& value);

  void setAttribute(const String& name, bool value);

  XMLElement& getParent();

  const XMLElement& getParent() const;

  bool getAttribute(const String& name, String& value,
                    const String& defaultValue = "") const;

  bool getAttribute(const String& name, int& value, int defaultValue = 0)
    const;

  bool getAttribute(const String& name, int64_t& value,
                    const int64_t& defaultValue = 0) const;

  bool getAttribute(const String& name, bool& value,
                    bool defaultValue = false) const;

  bool getAttribute(const String& name, double& value,
                    const double& defaultValue = 0.0) const;

  void getAttributeNames(StringVec& names) const;

  void removeAttributes();

  bool hasAttributes() const;

  inline  bool hasContent() const
  { return(_content.getLength() > 0); }

  inline void setContent(const String& content)
  { _content = content; }

  inline const String getContent() const
  { return(_content); }

  bool hasChildren() const;

  uint_t getChildCount() const;

  XMLElement& addChild(const String& name);

  XMLElement& getChild(const String& name = String::null);

  const XMLElement& getChild(const String& name = String::null) const;

  XMLElement& getChild(uint_t index);

  const XMLElement& getChild(uint_t index) const;

  bool hasChild(const String& name) const;

  XMLElement& operator[](const String& name);

  XMLElement& operator[](const char* name);

  inline const XMLElement& operator[](const String& name) const
  { return(_getChild(name)); }

  inline const XMLElement& operator[](const char* name) const
  { return(_getChild(name)); }

  XMLElement& operator[](int index);

  const XMLElement& operator[](int index) const;

  void removeChildren();

  void removeChildren(const String& name);

  XMLElement& operator=(bool val);

  XMLElement& operator=(long val);

  XMLElement& operator=(unsigned long val);

  XMLElement& operator=(const int64_t& val);

  XMLElement& operator=(const uint64_t& val);

  XMLElement& operator=(float val);

  XMLElement& operator=(const double& val);

  XMLElement& operator=(const String& val);

  bool toBool() const;

  int toInt() const;

  uint_t toUInt() const;

  int64_t toInt64() const;

  uint64_t toUInt64() const;

  float toFloat() const;

  double toDouble() const;

  inline String toString() const
  { return(getContent()); }

  inline bool isNull() const
  { return(_name.isNull()); }

  inline operator const void*() const
  { return(isNull() ? NULL : this); }

  inline bool operator!() const
  { return(isNull()); }

  void write(std::ostream& stream, int depth, uint_t tabWidth) const;

  static void validateName(const String& name);

  static XMLElement null;

 private:

  const XMLElement& _getChild(const String& name = String::null) const;
  const XMLElement& _getChild(uint_t index) const;

  String _name;
  String _content;

  class XMLAttributeMap; // fwd decl

  XMLAttributeMap* _attrs;
  XMLElement* _firstChild;
  XMLElement* _lastChild;
  XMLElement* _next;
  XMLElement* _parent;

  XMLElement(const String& name, XMLElement* parent = NULL);
  ~XMLElement();

  CCXX_COPY_DECLS(XMLElement);
};

} // namespace ccxx

#endif // __ccxx_XMLElement_hxx