tag.h

/*
  Copyright (c) 2005-2009 by Jakob Schroeter <js@camaya.net>
  This file is part of the gloox library. http://camaya.net/gloox

  This software is distributed under a license. The full license
  agreement can be found in the file LICENSE in this distribution.
  This software may not be copied, modified, sold or distributed
  other than expressed in the named license agreement.

  This software is distributed without any warranty.
*/


#ifndef TAG_H__
#define TAG_H__

#include "gloox.h"

#include <string>
#include <list>
#include <utility>

namespace gloox
{

  class Tag;

  typedef std::list<Tag*> TagList;

  typedef std::list<const Tag*> ConstTagList;

  class GLOOX_API Tag
  {

    friend class Parser;

    public:

      class GLOOX_API Attribute
      {

        friend class Tag;

        public:
          Attribute( Tag* parent, const std::string& name, const std::string& value,
                     const std::string& xmlns = EmptyString );

          Attribute( const std::string& name, const std::string& value,
                     const std::string& xmlns = EmptyString );

          Attribute( const Attribute& attr );

          virtual ~Attribute() {}

          const std::string& name() const { return m_name; }

          const std::string& value() const { return m_value; }

          bool setValue( const std::string& value );

          const std::string& xmlns() const;

          bool setXmlns( const std::string& xmlns );

          bool setPrefix( const std::string& prefix );

          const std::string& prefix() const;

          const std::string xml() const;

          bool operator==( const Attribute &right ) const
            { return m_name == right.m_name && m_value == right.m_value && m_xmlns == right.m_xmlns; }

          bool operator!=( const Attribute &right ) const
            { return !( *this == right ); }

          operator bool() const { return !m_name.empty(); }

        private:
          void init( const std::string& name, const std::string& value,
                     const std::string& xmlns );
          Tag* m_parent;
          std::string m_name;
          std::string m_value;
          std::string m_xmlns;
          std::string m_prefix;

      };

      typedef std::list<Attribute*> AttributeList;

      Tag( const std::string& name, const std::string& cdata = EmptyString );

      Tag( Tag* parent, const std::string& name, const std::string& cdata = EmptyString );

      Tag( const std::string& name, const std::string& attrib, const std::string& value );

      Tag( Tag* parent, const std::string& name, const std::string& attrib, const std::string& value );

      virtual ~Tag();

      const std::string xml() const;

      bool setPrefix( const std::string& prefix );

      const std::string& prefix() const { return m_prefix; }

      const std::string& prefix( const std::string& xmlns ) const;

      /* *
       * Adds an XML namespace declaration to the Tag. If @b def is false, a unique prefix will
       * be created, else the default namespace is set (no prefix).
       * @param xmlns The namespace value.
       * @param def If @b true, this sets the default namespace; if @b false, a unique namespace
       * prefix will be created (unless one already exists for the namespace) and used for
       * all subsequent references to the same namespace.
       * @since 1.0
       */
//       const std::string addXmlns( const std::string& xmlns, bool def );

      bool setXmlns( const std::string& xmlns, const std::string& prefix = EmptyString );

      const std::string& xmlns() const;

      const std::string& xmlns( const std::string& prefix ) const;

      bool addAttribute( Attribute* attr );

      bool addAttribute( const std::string& name, const std::string& value );

      bool addAttribute( const std::string& name, int value );

      bool addAttribute( const std::string& name, long value );

      void setAttributes( const AttributeList& attributes );

      void addChild( Tag* child );

      void addChildCopy( const Tag* child );

      bool setCData( const std::string& cdata );

      bool addCData( const std::string& cdata );

      const std::string& name() const { return m_name; }

      const std::string cdata() const;

      const AttributeList& attributes() const;

      const TagList& children() const;

      const std::string& findAttribute( const std::string& name ) const;

      bool hasAttribute( const std::string& name, const std::string& value = EmptyString ) const;

      Tag* findChild( const std::string& name ) const;

      Tag* findChild( const std::string& name, const std::string& attr,
                      const std::string& value = EmptyString ) const;

      bool hasChild( const std::string& name, const std::string& attr = EmptyString,
                     const std::string& value = EmptyString ) const;

      Tag* findChildWithAttrib( const std::string& attr, const std::string& value = EmptyString ) const;

      inline bool hasChildWithAttrib( const std::string& attr,
                                      const std::string& value = EmptyString ) const
        { return findChildWithAttrib( attr, value ) ? true : false; }

      TagList findChildren( const std::string& name, const std::string& xmlns = EmptyString ) const;

      void removeChild( const std::string& name, const std::string& xmlns = EmptyString );

      void removeChild( Tag* tag );

      void removeAttribute( const std::string& attr, const std::string& value = EmptyString,
                            const std::string& xmlns = EmptyString );

      bool hasChildWithCData( const std::string& name, const std::string& cdata ) const;

      Tag* parent() const { return m_parent; }

      Tag* clone() const;

      const std::string findCData( const std::string& expression ) const;

      const Tag* findTag( const std::string& expression ) const;

      ConstTagList findTagList( const std::string& expression ) const;

      bool operator==( const Tag &right ) const;

      bool operator!=( const Tag &right ) const { return !( *this == right ); }

      operator bool() const { return !m_name.empty(); }

    private:
      Tag( Tag* tag );

      enum XPathError
      {
        XPNoError,                  
        XPExpectedLeftOperand,      
        XPUnexpectedToken
      };

      enum NodeType
      {
        TypeTag,                    
        TypeString                  
      };

      struct Node
      {
        Node( NodeType _type, Tag* _tag ) : type( _type ), tag( _tag ) {}
        Node( NodeType _type, std::string* _str ) : type( _type ), str( _str ) {}
        ~Node() {}

        NodeType type;
        union
        {
          Tag* tag;
          std::string* str;
        };
      };

      typedef std::list<Node*> NodeList;

      Tag* m_parent;
      TagList* m_children;
      StringPList* m_cdata;
      AttributeList* m_attribs;
      NodeList* m_nodes;
      std::string m_name;
      std::string m_xmlns;
      StringMap* m_xmlnss;
      std::string m_prefix;

      enum TokenType
      {
        XTNone,
        XTLeftParenthesis,
        XTRightParenthesis,
        XTNodeSet,
        XTInteger,
        XTElement,
        XTLeftBracket,
        XTRightBracket,
        XTFunction,
        XTAsterisk,
        XTAttribute,
        XTLiteralInside,
        XTLiteral,
        XTDot,
        XTDoubleDot,
        XTOperatorOr,
        XTOperatorAnd,
        XTOperatorEq,
        XTOperatorNe,
        XTOperatorGt,
        XTOperatorLt,
        XTOperatorLtEq,
        XTOperatorGtEq,
        XTOperatorPlus,
        XTOperatorMinus,
        XTOperatorMul,
        XTOperatorDiv,
        XTOperatorMod,
        XTUnion,
        XTSlash,
        XTDoubleSlash
      };

      void setXmlns( StringMap* xmlns )
        { delete m_xmlnss; m_xmlnss = xmlns; }

      Tag* parse( const std::string& expression, unsigned& len, TokenType border = XTNone ) const;

      void closePreviousToken( Tag**, Tag**, TokenType&, std::string& ) const;
      void addToken( Tag **root, Tag **current, TokenType type, const std::string& token ) const;
      void addOperator( Tag **root, Tag **current, Tag* arg, TokenType type,
                        const std::string& token ) const;
      bool addPredicate( Tag **root, Tag **current, Tag* token ) const;

      TagList findChildren( const TagList& list, const std::string& name,
                            const std::string& xmlns = EmptyString ) const;
      ConstTagList evaluateTagList( Tag* token ) const;
      ConstTagList evaluateUnion( Tag* token ) const;
      ConstTagList allDescendants() const;

      static TokenType getType( const std::string& c );

      static bool isWhitespace( const char c );
      bool isNumber() const;

      bool evaluateBoolean( Tag* token ) const;
      bool evaluatePredicate( Tag* token ) const { return evaluateBoolean( token ); }
      bool evaluateEquals( Tag* token ) const;

      static void add( ConstTagList& one, const ConstTagList& two );
  };

}

#endif // TAG_H__