XMLElement.h++

Go to the documentation of this file.

/* ---------------------------------------------------------------------------
   commonc++ - A C++ Common Class Library
   Copyright (C) 2005-2012  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++/String.h++>
#include <commonc++/InvalidArgumentException.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)
    throw(InvalidArgumentException);

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

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

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

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

  XMLElement & getParent() throw();

  const XMLElement & getParent() const throw();

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

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

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

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

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

  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) throw(InvalidArgumentException);

  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 throw(InvalidArgumentException);

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

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

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

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

  XMLElement & operator[](int index) throw(OutOfBoundsException);

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

  void removeChildren();

  void removeChildren(const String &name) throw(InvalidArgumentException);

  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 throw()
  { 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)
    throw(InvalidArgumentException);

  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

/* end of header file */