tag.h

/*
  Copyright (c) 2005-2008 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 GLOOX_API Tag
  {
    public:
      typedef std::pair<std::string, std::string> Attribute;

      typedef std::list<Attribute> AttributeList;

      typedef std::list<Tag*> TagList;

      GLOOX_DEPRECATED_CTOR Tag();

      explicit Tag( const std::string& name, const std::string& cdata = "", bool incoming = false );

      explicit Tag( Tag *parent, const std::string& name, const std::string& cdata = "",
                    bool incoming = false );

      explicit Tag( const std::string& name, const std::string& attrib, const std::string& value,
                    bool incoming = false );

      explicit Tag( Tag *parent, const std::string& name, const std::string& attrib, const std::string& value,
                    bool incoming = false );

      virtual ~Tag();

      virtual const std::string xml() const;

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

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

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

      virtual void setAttributes( const AttributeList& attributes ) { m_attribs = attributes; }

      virtual void addChild( Tag *child );

      virtual void addChildCopy( const Tag *child );

      virtual void setCData( const std::string& cdata )
        { m_cdata = m_incoming ? relax( cdata ) : cdata; }

      virtual void addCData( const std::string& cdata )
        { m_cdata += m_incoming ? relax( cdata ) : cdata; }

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

      virtual const std::string& cdata() const { return m_cdata; }

      virtual AttributeList& attributes() { return m_attribs; }

      virtual const AttributeList& attributes() const { return m_attribs; }

      virtual TagList& children() { return m_children; }

      virtual const TagList& children() const { return m_children; }

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

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

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

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

      virtual inline bool hasChild( const std::string& name, const std::string& attr = "",
                                    const std::string& value = "" ) const
        { return findChild( name, attr, value ) ? true : false; }

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

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

      TagList findChildren( const std::string& name ) const;

      void removeChild( Tag *tag ) { m_children.remove(tag); }

      virtual GLOOX_DEPRECATED bool empty() const { return m_name.empty(); }

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

      Tag* parent() const { return m_parent; }

      virtual StanzaType type() const { return m_type; }

      virtual Tag* clone() const;

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

      Tag::TagList findTagList( const std::string& expression );

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

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

      operator bool() const { return m_valid; }

      static const std::string escape( std::string what );

      static const std::string relax( std::string what );

    protected:
      enum XPathError
      {
        XPNoError,                  
        XPExpectedLeftOperand,      
        XPUnexpectedToken
      };

      AttributeList m_attribs;
      std::string m_name;
      std::string m_cdata;
      TagList m_children;
      Tag *m_parent;
      StanzaType m_type;
      bool m_incoming;

    private:
      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
      };


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

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

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

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

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

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

      static void add( Tag::TagList& one, const Tag::TagList& two );

      bool m_valid;
  };

}

#endif // TAG_H__