---

container.hh

/*
*  Name:      container.hh
*  Author:    Rafael Jesus Alcantara Perez
*             Angel Jimenez Jimenez
*  Summary:   HTML container
*  Date:      $Date: 2003/04/14 00:18:34 $
*  Revision:  $Revision: 1.1 $
*
*  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_CONTAINER__
#define _MPCL_TEXT_HTML_CONTAINER__

#include "../../util/collection/map.hh"
#include "../../util/general-functions.hh"
#include "tag.hh"


namespace mpcl
{

  namespace text
  {

    namespace html
    {

      using util::collection::TMap;

      class TContainer;

      typedef
        TSmartPointer<TContainer>
        QTContainer;

      typedef
        TSmartPointer<const TContainer>
        QKTContainer;

      class TContainer : public TTag
      {

        public:

          typedef
            TMap<TString, QTTag>
            TStringToTagMap;


        protected:

          TTagList   tTagList;

          mutable TStringToTagMap   tStringToTagMap;


        public:

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

          TContainer (void)    :
            TTag            () ,
            tTagList        () ,
            tStringToTagMap ()
          {
            tAttributeMap ["class-identifier"] = "container";
            tAttributeMap.bind ("group-align", "misaligned");
          }

          TContainer ( const char* pkcIDENTIFIER                 ,
                       const char* pkcVALUE       = ""           ,
                       const char* pkcGROUP_ALIGN = "misaligned" ) :
            TTag            (pkcIDENTIFIER, pkcVALUE)              ,
            tTagList        ()                                     ,
            tStringToTagMap ()
          {
            tAttributeMap ["class-identifier"] = "container";
            tAttributeMap.bind ("group-align", pkcGROUP_ALIGN);
          }

          void clear (void)
          {
            tTagList.clear();
            tStringToTagMap.clear();
          }

          virtual QTTag findOrInsertTag (const TString& rkyIDENTIFIER);

          void insertAs ( const TString& rkyTAG_IDENTIFIER ,
                          const QTTag&   rkqtTAG           ,
                          iterator       tINDEX            );

          virtual void insertUpdating (const QTTag& rkqtTAG)
          {
            insertAs (rkqtTAG->identifier(), rkqtTAG, end());
          }

          virtual void insertUpdating (const QTTag& rkqtTAG, iterator tINDEX)
          {
            insertAs (rkqtTAG->identifier(), rkqtTAG, tINDEX);
          }

          virtual void insert (const QTTag& rkqtTAG)
          {
            insertUpdating (rkqtTAG);
          }

          virtual void insert (const QTTag& rkqtTAG, iterator tINDEX)
          {
            insertUpdating (rkqtTAG, tINDEX);
          }

          void reset (void)
          {
            iterator   I    = tTagList.begin();
            iterator   tEnd = tTagList.end();

            TTag::reset();
            for (; ( I != tEnd ) ;++I)
            {
              (*I)->reset();
            }
          }

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

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

          void setId (const char* pkcID, bool gDELEGATE = false);

          void setId (const TString& rkyID, bool gDELEGATE = false);

          void update (void)
          {
            iterator   I    = tTagList.begin();
            iterator   tEnd = tTagList.end();

            for (; ( I != tEnd ) ;++I)
            {
              (*I)->update();
            }
          }


        public:

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

          iterator begin (void)
          {
            return tTagList.begin();
          }

          const_iterator begin (void) const
          {
            return tTagList.begin();
          }

          iterator end (void)
          {
            return tTagList.end();
          }

          const_iterator end (void) const
          {
            return tTagList.end();
          }

          virtual QTTag findTag (const TString& rkyIDENTIFIER) const;

          virtual bool hasTag (const TString& rkyIDENTIFIER) const
          {
            return !findTag (rkyIDENTIFIER).isNull();
          }

          QTTag tag (const TString& rkyIDENTIFIER) const;

          const TTag& operator [] (const char* pkcIDENTIFIER) const
          {
            return *tag (pkcIDENTIFIER);
          }

          const TTag& operator [] (const TString& rkyIDENTIFIER) const
          {
            return *tag (rkyIDENTIFIER);
          }

          TTag& operator [] (const char* pkcIDENTIFIER)
          {
            return *tag (pkcIDENTIFIER);
          }

          TTag& operator [] (const TString& rkyIDENTIFIER)
          {
            return *tag (rkyIDENTIFIER);
          }

          size_type size (void) const
          {
            return tTagList.size();
          }


        protected:

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

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

      };  // class TContainer

    }  // namespace html

  }  // namespace text

}  // namespace mpcl


#endif  // not _MPCL_TEXT_HTML_CONTAINER__

---