---

pattern_page.cc

/*
*  Name:      pattern_page.cc
*  Author:    Rafael Jesus Alcantara Perez
*  Summary:   HTML pattern page
*  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 <fstream>
#include <mpcl/system/defs.hh>
#include <mpcl/text/html/pattern_page.hh>


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

void mpcl::text::html::TPatternPage::
read (std::basic_istream<char>& rtSOURCE_ISTREAM)
{

  using std::getline;
  using system::GetErrorMessage;

  TString   yText;

  yPattern = "";
  while ( getline (rtSOURCE_ISTREAM, yText).good() )
  {
    yPattern.append (yText);
    yPattern.append (1, '\n');
  }
  if ( !rtSOURCE_ISTREAM.eof() )
  {
    TString   yMessage;

    yMessage = Format ( "error while reading pattern page file '%s'; %s" ,
                        yFileName.c_str()                                ,
                        GetErrorMessage()                                );

    //
    //  It could not read til the end of source pattern page file.
    //
    throw TConstraintException (yMessage, __FILE__, __LINE__);
  }

}  // read()


void mpcl::text::html::TPatternPage::
readFromFile (const TString& rkyFILE_NAME)
{

  std::ifstream   tIfstream;

  yFileName = rkyFILE_NAME;
  if ( !tIfstream )
  {
    throw TConstraintException ("could not find pattern page file", __FILE__, __LINE__);
  }
  else
  {
    tIfstream.open (yFileName.c_str());
    read (tIfstream);
  }

}  // readFromFile()


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

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

  if ( isVisible() )
  {
    TStringToStringMap   tTargetVariableMap;
    TString              yNewPathIdentifier;
    TString              yPathIdentifier        = rkySOURCE_QUALIFIED_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 = rkySOURCE_QUALIFIED_IDENTIFIER;
      if ( gIsQualified && gForwardIdentifier && !qualifiedIdentifier().empty() )
      {
        if ( !yNewPathIdentifier.empty() )
        {
          yNewPathIdentifier += kcIdentifierSeparator;
        }
        yNewPathIdentifier += qualifiedIdentifier();
      }
    }

    //
    //  Outputs container.
    //
    TString              yTagIdentifier;
    TString::size_type   zDifference;
    TString::size_type   zFirstPercentOffset;
    TString              yPatternInstance (yPattern);
    TString::size_type   zLastPercentOffset = 0;

    while ( true )
    {
      zFirstPercentOffset = yPatternInstance.find ('%', zLastPercentOffset);
      if ( TString::npos == zFirstPercentOffset )
      {
        rtTARGET_OSTREAM << yPatternInstance.c_str() + zLastPercentOffset;
        break;
      }
      else
      {
        yPatternInstance [zFirstPercentOffset] = '\0';
        rtTARGET_OSTREAM << yPatternInstance.c_str() + zLastPercentOffset;
        ++zFirstPercentOffset;
        zLastPercentOffset = yPatternInstance.find ('%', zFirstPercentOffset);
        if ( TString::npos == zLastPercentOffset )
        {
          throw TConstraintException ("bad syntax in tag", __FILE__, __LINE__);
        }
        else
        {
          zDifference = zLastPercentOffset - zFirstPercentOffset;
          if ( !zDifference )
          {
            //
            //  This is the  escape  sequence for the  symbol '%': '%%',  so it
            //  writes a percentage symbol.
            //
            rtTARGET_OSTREAM << '%';
          }
          else
          {
            yTagIdentifier.assign (yPatternInstance, zFirstPercentOffset, zDifference);
            yPatternInstance [zLastPercentOffset] = '\0';
            tStringToTagMap [yTagIdentifier]->writeUsing ( rtTARGET_OSTREAM   ,
                                                           yNewPathIdentifier );
          }
          ++zLastPercentOffset;
        }
      }
    }
  }

}  // writeUsing()

---