---

tag.hh

/*
*  Name:      tag.hh
*  Author:    Angel Jimenez Jimenez
*             Rafael Jesus Alcantara Perez
*  Summary:   HTML base tag
*  Date:      $Date: 2003/08/08 23:30:34 $
*  Revision:  $Revision: 1.2 $
*
*  Copyright (C) 1994-2002  Rafael Jesus Alcantara Perez <rafa@dedalo-ing.com>
*
*  This program is free software; you can redistribute it and/or modify
*  it under the terms of the GNU General Public License as published by
*  the Free Software Foundation; either version 2 of the License, or
*  (at your option) any later version.
*
*  This program 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 General Public License for more details.
*
*  You should have received a copy of the GNU General Public License
*  along with this program; if not, write to the Free Software
*  Foundation, Inc., 59 Temple Place, Suite 330, Boston,
*  MA 02111-1307, USA.
*/

#ifndef _MPCL_TEXT_HTML_TAG__
#define _MPCL_TEXT_HTML_TAG__

#include <list>
#include <memory>
#include "../../io/output_streamable.hh"
#include "../../memory/smart_pointer.hh"
#include "../../util/collection/string_to_string_map.hh"
#include "../codegen/pattern_based_code_generator.hh"
#include "../string.hh"
#include "defs.hh"


namespace mpcl
{

  namespace text
  {

    namespace html
    {

      using memory::TSmartPointer;
      using text::codegen::TPatternBasedCodeGenerator;
      using util::collection::TStringToStringMap;

      class TTag;

      typedef
        TSmartPointer<TTag>
        QTTag;

      typedef
        TSmartPointer<const TTag>
        QKTTag;

      class TTag : public IOutputStreamable<>
      {

        public:

          typedef
            std::list<QTTag>
            TTagList;

          typedef
            TTagList::const_iterator
            const_iterator;

          typedef
            TTagList::iterator
            iterator;

          typedef
            TTagList::size_type
            size_type;


        protected:

          static TPatternBasedCodeGenerator*   _ptCodeGenerator;

          bool   gForwardIdentifier;

          bool   gHasBeenDynamiclyCreated;

          bool   gIsDynamiclyLoadable;

          bool   gIsQualified;

          bool   gIsRootNode;

          bool   gIsVisible;

          TStringToStringMap   tAttributeMap;


        public:

          //
          //  L O C A L   F U N C T I O N S
          //

          static void _setCodeGenerator (const TPatternBasedCodeGenerator& rktCG);


        public:

          //
          //  C O N S T R U C T O R S
          //

          TTag (bool gDYNAMICALLY_CREATED = false);

          TTag (const char* pkcIDENTIFIER, const char* pkcVALUE = "");

          TTag (const char* pkcIDENTIFIER, bool gDYNAMICALLY_CREATED);

          virtual ~TTag (void);

          virtual void clear (void) {}

          virtual void reset (void)
          {
            //
            //  If this is an assignable tag.
            //
            if ( isAssignable() )
            {
              tAttributeMap ["value"].erase();
            }
          }

          virtual void setClass ( const TString& rkyCLASS          ,
                                  bool           gDELEGATE = false );

          virtual void setClass ( const char* pkcCLASS          ,
                                  bool        gDELEGATE = false );

          void setDynamiclyLoadable (bool gDYNAMICLY_LOADABLE)
          {
            gIsDynamiclyLoadable = gDYNAMICLY_LOADABLE;
          }

          virtual void setId (const char* pkcID, bool = false)
          {
            attribute ("id") = pkcID;
          }

          virtual void setId (const TString& rkyID, bool = false)
          {
            attribute ("id") = rkyID;
          }

          virtual void setValue (const TString& rkyVALUE)
          {
            setValue (rkyVALUE.c_str());
          }

          virtual void setValue (const char* pkcVALUE)
          {
            if ( !isAssignable() )
            {
              throw TConstraintException ("instance is not assignable", __FILE__, __LINE__);
            }
            tAttributeMap ["value"] = pkcVALUE;
          }

          void setVisibility (bool gIS_VISIBLE)
          {
            gIsVisible = gIS_VISIBLE;
          }

          virtual void update (void) {}


        public:

          //
          //  S E L E C T O R S
          //

          virtual TString& attribute (const char* pkcNAME)
          {
            return tAttributeMap [pkcNAME];
          }

          virtual const TString& attribute (const char* pkcNAME) const
          {
            return tAttributeMap [pkcNAME];
          }

          virtual iterator begin (void);

          virtual const_iterator begin (void) const;

          virtual iterator end (void);

          virtual const_iterator end (void) const;

          TString getClass (void) const
          {
            return tAttributeMap ["class"];
          }

          const TString& getId (void) const
          {
            return tAttributeMap ["id"];
          }

          virtual const TString& getValue (void) const
          {
            return tAttributeMap ["value"];
          }

          virtual bool hasAttribute (const char* pkcNAME) const
          {
            return ( tAttributeMap.end() != tAttributeMap.find (pkcNAME) );
          }

          bool hasBeenDynamiclyCreated (void) const
          {
            return gHasBeenDynamiclyCreated;
          }

          virtual const TString& identifier (void) const
          {
            return tAttributeMap ["identifier"];
          }

          virtual bool isAssignable (void) const
          {
            return !identifier().empty();
          }

          bool isDynamiclyLoadable (void) const
          {
            return gIsDynamiclyLoadable;
          }

          bool isQualified (void) const
          {
            return gIsQualified;
          }

          virtual bool isVisible (void) const
          {
            return gIsVisible;
          }

          virtual bool operator == (const TTag& rktTAG) const
          {
            return ( identifier() == rktTAG.identifier() );
          }

          virtual QTTag tag (const TString& rkyIDENTIFIER) const;

          virtual TString& operator () (const char* pkcNAME)
          {
            return attribute (pkcNAME);
          }

          virtual const TString& operator () (const char* pkcNAME) const
          {
            return attribute (pkcNAME);
          }

          virtual const TTag& operator [] (const char* pkcIDENTIFIER) const;

          virtual const TTag& operator [] (const TString& rkyIDENTIFIER) const
          {
            return operator [] (rkyIDENTIFIER.c_str());
          }

          virtual TTag& operator [] (const char* pkcIDENTIFIER);

          virtual TTag& operator [] (const TString& rkyIDENTIFIER)
          {
            return operator [] (rkyIDENTIFIER.c_str());
          }

          virtual const TString& qualifiedIdentifier (void) const
          {
            return tAttributeMap ["qualified-identifier"];
          }

          virtual size_type size (void) const;

          void write (std::basic_ostream<char>& rtOUTPUT_OSTREAM) const
          {
            writeUsing (rtOUTPUT_OSTREAM, "");
          }

          virtual void writeUsing ( std::basic_ostream<char>& rtTARGET_OSTREAM        ,
                                    const TString&            rkyQUALIFIED_IDENTIFIER ) const;


        protected:

          //
          //  S E L E C T O R S
          //

          TString code (const char* pkcINSTRUCTION, const char* pkcCLAUSE) const;

          TString code ( const char*               pkcINSTRUCTION ,
                         const char*               pkcCLAUSE      ,
                         const TStringToStringMap& rktVALUE_MAP   ) const;

          void expand (TStringToStringMap& rtTARGET_VALUE_MAP) const;

      };  // class TTag

    }  // namespace html

  }  // namespace text

}  // namespace mpcl


#endif  // not _MPCL_TEXT_HTML_TAG__

---