---

container.cc

/*
*  Name:      container.cc
*  Author:    Rafael Jesus Alcantara Perez
*             Angel Jimenez Jimenez
*  Summary:   HTML container
*  Date:      $Date: 2003/04/14 00:18:35 $
*  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.
*/

#include <mpcl/text/html/container.hh>


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

mpcl::text::html::QTTag mpcl::text::html::TContainer::
findOrInsertTag (const TString& rkyIDENTIFIER)
{

  QTTag                       qtTag;
  std::size_t                 zOffset;
  TStringToTagMap::iterator   I = tStringToTagMap.begin();

  zOffset = rkyIDENTIFIER.find (kcIdentifierSeparator);
  if ( TString::npos == zOffset )
  {
    //
    //  There is no separator.
    //
    I = tStringToTagMap.find (rkyIDENTIFIER);
    if ( I != tStringToTagMap.end() )
    {
      qtTag = I->second;
    }
    else
    {
      if ( isDynamiclyLoadable() )
      {
        qtTag = new TTag (rkyIDENTIFIER.c_str(), true);
        insert (qtTag);
      }
    }
  }
  else
  {
    TString   yFirstIdentifierPart (rkyIDENTIFIER.substr (0, zOffset));
    TString   yLastIdentifierPart (rkyIDENTIFIER.substr (zOffset + 1));

    //
    //  If an tag with yFirstIdentifierPart as identifier is found, then it is
    //  a  container.  So  it  is  called using tag(), with the  rest  of  the
    //  identifier as parameter.
    //
    I = tStringToTagMap.find (yFirstIdentifierPart);
    if ( I != tStringToTagMap.end() )
    {
// <DELETE id="smart-pointers">
//       QTContainer   qtContainer;
      
//       DynamicCast (qtContainer, I->second);
// </DELETE>
      TContainer*   ptContainer = I->second.dynamicCast<TContainer*>();

      qtTag = ptContainer->findOrInsertTag (yLastIdentifierPart);
    }
  }
  if ( !qtTag )
  {
    TString   yMessage = Format ("there is no tag called '%s'", rkyIDENTIFIER.c_str());

    throw TConstraintException (yMessage, __FILE__, __LINE__);
  }
  return qtTag;
  
}  // findOrInsertTag()


void mpcl::text::html::TContainer::
insertAs ( const TString& rkyTAG_IDENTIFIER ,
           const QTTag&   rkqtTAG           ,
           iterator       tINDEX            )
{
  
  TString   yIdentifier (rkyTAG_IDENTIFIER);

  if ( yIdentifier.empty() )
  {
    yIdentifier.append (1, '_');
    insertAs (yIdentifier, rkqtTAG, tINDEX);
  }
  else
  {
    TStringToTagMap::const_iterator   I (tStringToTagMap.find (yIdentifier));
    
    if ( I == tStringToTagMap.end() )
    {
      //
      //  No tag found with name rkyTAG_IDENTIFIER.
      //
      tStringToTagMap.bind (yIdentifier, rkqtTAG);
      tTagList.insert (tINDEX, rkqtTAG);
    }
    else
    {
      //
      //  If there is another tag with the same name,
      //  then inserts this tag with another name.
      //
      yIdentifier.append (1, '_');
      insertAs (yIdentifier, rkqtTAG, tINDEX);
    }
  }

}  // insertAs()


void mpcl::text::html::TContainer::
setId (const char* pkcID, bool gDELEGATE)
{

  iterator   I    = tTagList.begin();
  iterator   tEnd = tTagList.end();
  
  TTag::setId (pkcID, gDELEGATE);
  if ( gDELEGATE )
  {
    for (; ( I != tEnd ) ;++I)
    {
      (*I)->setId (pkcID, gDELEGATE);
    }
  }

}  // setId()


void mpcl::text::html::TContainer::
setId (const TString& rkyID, bool gDELEGATE)
{

  iterator   I    = tTagList.begin();
  iterator   tEnd = tTagList.end();
  
  TTag::setId (rkyID, gDELEGATE);
  if ( gDELEGATE )
  {
    for (; ( I != tEnd ) ;++I)
    {
      (*I)->setId (rkyID, gDELEGATE);
    }
  }

}  // setId()


void mpcl::text::html::TContainer::
setClass (const TString& rkyCLASS, bool gDELEGATE)
{

  iterator   I    = tTagList.begin();
  iterator   tEnd = tTagList.end();
  
  TTag::setClass (rkyCLASS);
  if ( gDELEGATE )
  {
    for (; ( I != tEnd ) ;++I)
    {
      (*I)->setClass (rkyCLASS, gDELEGATE);
    }
  }

}  // setClass()


void mpcl::text::html::TContainer::
setClass (const char* pkcCLASS, bool gDELEGATE)
{

  iterator   I    = tTagList.begin();
  iterator   tEnd = tTagList.end();
  
  TTag::setClass (pkcCLASS);
  if ( gDELEGATE )
  {
    for (; ( I != tEnd ) ;++I)
    {
      (*I)->setClass (pkcCLASS, gDELEGATE);
    }
  }

}  // setClass()


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

mpcl::text::html::QTTag mpcl::text::html::TContainer::
findTag (const TString& rkyIDENTIFIER) const
{

  TStringToTagMap::iterator   I;
  QTTag                       qtTag;
  std::size_t                 zOffset;

  zOffset = rkyIDENTIFIER.find (kcIdentifierSeparator);
  if ( TString::npos == zOffset )
  {
    //
    //  There is no separator.
    //
    I = tStringToTagMap.find (rkyIDENTIFIER);
    if ( I != tStringToTagMap.end() )
    {
      qtTag = I->second;
    }
  }
  else
  {
    TString   yFirstIdentifierPart (rkyIDENTIFIER.substr (0, zOffset));
    TString   yLastIdentifierPart (rkyIDENTIFIER.substr (zOffset + 1));

    //
    //  If an tag with yFirstIdentifierPart as identifier is found, then it is
    //  a  container.  So  it  is called using tag(), with  the  rest  of  the
    //  identifier as parameter.
    //
    I = tStringToTagMap.find (yFirstIdentifierPart);
    if ( I != tStringToTagMap.end() )
    {
// <DELETE id="smart-pointers">
//       QKTContainer   qktContainer;
      
//       DynamicCast (qktContainer, I->second);
// </DELETE>

      const TContainer*   pktContainer = I->second.dynamicCast<const TContainer*>();

      qtTag = pktContainer->findTag (yLastIdentifierPart);
    }
  }
  return qtTag;

}  // findTag()


mpcl::text::html::QTTag mpcl::text::html::TContainer::
tag (const TString& rkyIDENTIFIER) const
{

  QTTag   qtTag (findTag (rkyIDENTIFIER));
  
  if ( !qtTag )
  {
    TString   yMessage = Format ("there is no tag called '%s'", rkyIDENTIFIER.c_str());
    
    throw TConstraintException (yMessage, __FILE__, __LINE__);
  }
  return qtTag;

}  // tag()


void mpcl::text::html::TContainer::
writeUsing ( std::basic_ostream<char>& rtTARGET_OSTREAM        ,
             const TString&            rkyQUALIFIED_IDENTIFIER ) const
{

  if ( isVisible() )
  {
    TStringToStringMap   tTargetVariableMap;
    TString              yNewPathIdentifier;
    TString              yPathIdentifier        = rkyQUALIFIED_IDENTIFIER;
    TString              yGroupAlignInstruction = "group.";

    //
    //  Sets the proper instruction.
    //
    yGroupAlignInstruction += tAttributeMap ["group-align"];
    expand (tTargetVariableMap);
    if ( gIsQualified && !qualifiedIdentifier().empty() )
    {
      if ( !yPathIdentifier.empty() )
      {
        yPathIdentifier += kcIdentifierSeparator;
      }
      yPathIdentifier += qualifiedIdentifier();
    }
    tTargetVariableMap ["qualified-identifier"] = yPathIdentifier;
    if ( gIsRootNode )
    {
      if ( gIsQualified && gForwardIdentifier )
      {
        yNewPathIdentifier += qualifiedIdentifier();
      }
    }
    else
    {
      yNewPathIdentifier = rkyQUALIFIED_IDENTIFIER;
      if ( gIsQualified && gForwardIdentifier && !qualifiedIdentifier().empty() )
      {
        if ( !yNewPathIdentifier.empty() )
        {
          yNewPathIdentifier += kcIdentifierSeparator;
        }
        yNewPathIdentifier += qualifiedIdentifier();
      }
    }

    //
    //  Outputs container.
    //
    const_iterator   I     = tTagList.begin();
    const_iterator   ktEnd = tTagList.end();

    rtTARGET_OSTREAM << code (tTargetVariableMap ["class-identifier"].c_str(), "head", tTargetVariableMap);
    rtTARGET_OSTREAM << code (yGroupAlignInstruction.c_str(),                  "head");
    for (; ( I != ktEnd ) ;++I)
    {
      (*I)->writeUsing (rtTARGET_OSTREAM, yNewPathIdentifier);
      rtTARGET_OSTREAM << code (yGroupAlignInstruction.c_str(), "internal");
    }
    rtTARGET_OSTREAM << code (yGroupAlignInstruction.c_str(),                  "foot");
    rtTARGET_OSTREAM << code (tTargetVariableMap ["class-identifier"].c_str(), "foot", tTargetVariableMap);
  }

}  // writeUsing()

---