---

instruction_body.cc

/*
*  Name:      instruction_body.cc
*  Author:    Rafael Jesus Alcantara Perez
*  Summary:   Instruction body
*  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/codegen/defs.hh>
#include <mpcl/text/codegen/instruction_body.hh>
#include <mpcl/text/regex/matcher.hh>


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

mpcl::text::codegen::TInstructionBody& mpcl::text::codegen::TInstructionBody::
operator = (const TInstructionBody& rktSOURCE_INSTRUCTION_BODY)
{

  tClauseMap = rktSOURCE_INSTRUCTION_BODY.tClauseMap;
  return *this;

}  // operator =()


void mpcl::text::codegen::TInstructionBody::
read (std::basic_istream<char_type, traits_type>& rtSOURCE_STREAM)
{

  using text::regex::TMatcher;

  TMatcher   tMatcher (rtSOURCE_STREAM);
 
  tMatcher.setCaseSensitiveness (false);

  //
  //  Parse clauses.
  //
  rtSOURCE_STREAM >> tClauseMap;

  //
  //  Parse instruction end-tag.
  //
  while ( tMatcher.scan (pkcCommentTagPattern, NULL) );
  tMatcher.scan (pkcINSTRUCT_EndTagPattern, NULL);

}  // read()


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

bool mpcl::text::codegen::TInstructionBody::
existsClause (const char* pkcCLAUSE_NAME) const
{

  return ( tClauseMap.end() != tClauseMap.find (pkcCLAUSE_NAME) );

}  // existsClause()


const mpcl::text::codegen::TClauseTagString& mpcl::text::codegen::TInstructionBody::
clauseTag (const char* pkcSOURCE_CLAUSE_TAG) const
{

  TClauseMap::const_iterator   ktIter = tClauseMap.find (pkcSOURCE_CLAUSE_TAG);

  if ( ktIter == tClauseMap.end() )
  {
    TString   yMessage;
    
    yMessage = Format ("clause '%s' not found", pkcSOURCE_CLAUSE_TAG);
    throw TNotFoundException (yMessage, __FILE__, __LINE__);
  }
  return ktIter->first;

}  // clauseTag()


const mpcl::text::codegen::TClauseBodyString& mpcl::text::codegen::TInstructionBody::
clauseBody (const char* pkcSOURCE_CLAUSE_TAG) const
{

  TClauseMap::const_iterator   ktIter = tClauseMap.find (pkcSOURCE_CLAUSE_TAG);

  if ( ktIter == tClauseMap.end() )
  {
    TString   yMessage;
    
    yMessage = Format ("clause '%s' not found", pkcSOURCE_CLAUSE_TAG);
    throw TNotFoundException (yMessage, __FILE__, __LINE__);
  }
  return ktIter->second;

}  // clauseBody()


mpcl::util::collection::TMap<mpcl::text::TString, const mpcl::text::codegen::TClauseBodyString*> mpcl::text::codegen::TInstructionBody::
targetedVariablesForClause (const char* pkcSOURCE_CLAUSE_TAG) const
{

  using util::collection::TMap;

  TString                                   yClauseName;
  TMap<TString, const TClauseBodyString*>   tResultMap;
  size_t                                    zSeparatorPosition;
  TClauseMap::const_iterator                ktIter = tClauseMap.begin();
  TClauseMap::const_iterator                ktEnd  = tClauseMap.end();
  
  for (; ( ktIter != ktEnd ) ;++ktIter)
  {
    const TClauseTagString&   rkyCurrentClauseTag = ktIter->first;

    yClauseName = rkyCurrentClauseTag;
    if ( TString::npos != (zSeparatorPosition = yClauseName.find (pkcTargetSeparator)) )
    {
      yClauseName.erase (zSeparatorPosition);
    }
    if ( yClauseName == pkcSOURCE_CLAUSE_TAG )
    {
      if ( rkyCurrentClauseTag.hasTarget() )
      {
        tResultMap.bind (rkyCurrentClauseTag.target(), &ktIter->second);
      }
    }
  }
  return tResultMap;

}  // targetedVariablesForClause()


const mpcl::text::codegen::TClauseBodyString& mpcl::text::codegen::TInstructionBody::
operator [] (const char* pkcSOURCE_CLAUSE_TAG) const
{

  TClauseMap::const_iterator   ktIter = tClauseMap.find (pkcSOURCE_CLAUSE_TAG);
  
  if ( ktIter == tClauseMap.end() )
  {
    TString   yMessage;
    
    yMessage = Format ("clause '%s' not found", pkcSOURCE_CLAUSE_TAG);
    throw TNotFoundException (yMessage, __FILE__, __LINE__);
  }
  return ktIter->second;

}  // operator []()


bool mpcl::text::codegen::TInstructionBody::
operator == (const TInstructionBody& rktSOURCE_INSTRUCTION_BODY) const
{

  return ( tClauseMap == rktSOURCE_INSTRUCTION_BODY.tClauseMap );

}  // operator ==()


void mpcl::text::codegen::TInstructionBody::
write (std::basic_ostream<char_type, traits_type>& rtTARGET_STREAM) const
{

  rtTARGET_STREAM << tClauseMap << "</instruct>\n";

}  // write()

---