---

executable_streamable_dfa.hh

/*
*  Name:      executable_streamable_dfa.hh
*  Author:    Rafael Jesus Alcantara Perez
*  Summary:   Executable Streamable Deterministic Finite Automaton
*  Date:      $Date: 2003/10/06 12:45:11 $
*  Revision:  $Revision: 1.2 $
*
*  Copyright (C) 1999-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_AUTOMATON_EXECUTABLE_STREAMABLE_DFA__
#define _MPCL_AUTOMATON_EXECUTABLE_STREAMABLE_DFA__

#include <iterator>
#include "action_handler.hh"
#include "defs.hh"
#include "streamable_dfa.hh"


namespace mpcl
{

  namespace automaton
  {

    using text::regex::TMatcher;

    template <typename TState, typename TEvent>
    class TExecutableStreamableDfa : public TStreamableDfa<TState, TEvent>
    {

      public:

        typedef
          typename TStreamableDfa<TState, TEvent>::char_type
          char_type;

        typedef
          typename TStreamableDfa<TState, TEvent>::traits_type
          traits_type;


      protected:

        typedef
          typename TStreamableDfa<TState, TEvent>::TStringToStateMap
          TStringToStateMap;

        typedef
          typename TActionHandler<TState>::TActionNamesList
          TActionNamesList;

        TActionHandler<TState>&   rtActionHandler;


      public:

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

        TExecutableStreamableDfa ( TEventHandler<TEvent>&  rtSOURCE_BASE_EVENT_HANDLER ,
                                   TActionHandler<TState>& rtSOURCE_ACTION_HANDLER     ) :
          TStreamableDfa<TState, TEvent> (rtSOURCE_BASE_EVENT_HANDLER)                   ,
          rtActionHandler                (rtSOURCE_ACTION_HANDLER)                       {}

        void move (const TState& rktSTATE)
        {
          TDeterministicFiniteAutomaton<TState, TEvent>::move (rktSTATE);
          if ( rtActionHandler.execute (rktSTATE) )
          {
            throw TIntegrityException ("action failed", __FILE__, __LINE__);
          }
        }


      protected:

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

        void read (std::basic_istream<char_type, traits_type>& rtSOURCE_ISTREAM);

        void readActionList (TMatcher& rtSOURCE_MATCHER);


      protected:

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

        void write (std::basic_ostream<char_type, traits_type>& rtTARGET_OSTREAM) const
        {
          writeHeader          (rtTARGET_OSTREAM);
          writeTransitionTable (rtTARGET_OSTREAM);
          writeActionList      (rtTARGET_OSTREAM);
          writeFooter          (rtTARGET_OSTREAM);
        }

        void writeActionList (std::basic_ostream<char_type, traits_type>& rtTARGET_OSTREAM) const;

    };  // class TExecutableStreamableDfa

  }  // namespace automaton

}  // namespace mpcl


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

template <typename TState, typename TEvent>
inline void mpcl::automaton::TExecutableStreamableDfa<TState, TEvent>::
read (std::basic_istream<char_type, traits_type>& rtSOURCE_ISTREAM)
{
  
  //
  //  DFAML document must be validated, so parsing
  //  doesn't have to worry about syntax errors.
  //  First it musts find DFAML tag, and then skip
  //  it.
  //
  TMatcher   tMatcher (rtSOURCE_ISTREAM);

  tTransitionMap.clear();  
  tMatcher.setCaseSensitiveness (false);
  readHeader (tMatcher);
  if ( !yPublic.empty() )
  {
    if ( ( yPublic != pkcDOCTYPE_VERSION_1_0 ) &&
         ( yPublic != pkcDOCTYPE_VERSION_2_0 )  )
    {
      throw TNotDfamlFileException ("this isn't a DFAML doctype");
    }
  }
  readTransitionTable (tMatcher);
  readActionList (tMatcher);
  readFooter (tMatcher);
  check();

}  // read()


template <typename TState, typename TEvent>
inline void mpcl::automaton::TExecutableStreamableDfa<TState, TEvent>::
readActionList (TMatcher& rtSOURCE_MATCHER)
{

# define DFA_REMOVE_COMMENTS(rtMATCHER)                           \
         {                                                        \
           while ( rtMATCHER.scan (pkcCommentTagPattern, NULL) ); \
         }

  using text::Format;

  typename TStringToStateMap::const_iterator   I;
  TActionNamesList                             tActionNamesList;
  TString                                      yActions;
  TString                                      yStateName;

  //
  //  Reads ACTLIST tag/DECLARE end-tag.
  //
  if ( rtSOURCE_MATCHER.scan (pkcACTLIST_TagPattern, NULL) )
  {
    while (true)
    {
      DFA_REMOVE_COMMENTS (rtSOURCE_MATCHER);
      if ( !rtSOURCE_MATCHER.scan (pkcACTION_ElementPattern_1, &yStateName, &yActions, NULL) )
      {
        if ( !rtSOURCE_MATCHER.scan (pkcACTION_ElementPattern_2, &yActions, &yStateName, NULL) )
        {
          break;
        }
      }
      yStateName.lowercase();
      yActions.lowercase();
      I = tStringToStateMap.find (yStateName);
      if ( I == tStringToStateMap.end() )
      {
        TString   yMessage;
        
        yMessage = Format ("can't find state '%s'", yStateName.c_str());
        throw TNotFoundException (yMessage.c_str(), __FILE__, __LINE__);
      }
      tActionNamesList.clear();
      yActions.suppress (' ');
      yActions.split (',', std::back_insert_iterator<TActionNamesList> (tActionNamesList));
      rtActionHandler.setActions (I->second, tActionNamesList);
    }
    DFA_REMOVE_COMMENTS (rtSOURCE_MATCHER);
    rtSOURCE_MATCHER.scan (pkcACTLIST_EndTagPattern, NULL);
    DFA_REMOVE_COMMENTS (rtSOURCE_MATCHER);
  }
  
# undef DFA_REMOVE_COMMENTS

}  // readActionList()


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

template <typename TState, typename TEvent>
inline void mpcl::automaton::TExecutableStreamableDfa<TState, TEvent>::
writeActionList (std::basic_ostream<char_type, traits_type>& rtTARGET_OSTREAM) const
{

  typename TActionNamesList::const_iterator    J;
  TActionNamesList                             tActionNamesList;
  typename TStringToStateMap::const_iterator   I = tStringToStateMap.begin();

  //
  //  Writes ACTLIST beginning tag.
  //
  rtTARGET_OSTREAM << "  <actlist>\n";

  //
  //  Iterates over string to state map.
  //
  for (; ( I != tStringToStateMap.end() ) ;++I)
  {
    //
    //  Writes STATE beginning tag.
    //
    tActionNamesList = rtActionHandler.getActions (I->second);
    rtTARGET_OSTREAM << "    <action state=\""
                     << I->first
                     << "\" actions=\"";
    J = tActionNamesList.begin();
    if ( J != tActionNamesList.end() )
    {
      rtTARGET_OSTREAM << *J;
      ++J;
      for (; ( J != tActionNamesList.end() ) ;++J)
      {
        rtTARGET_OSTREAM << ", " << *J;
      }
    }
    rtTARGET_OSTREAM << "\">\n";
  }
  rtTARGET_OSTREAM << "  </actlist>\n";
  
}  // writeActionList()


#endif  // not _MPCL_AUTOMATON_EXECUTABLE_STREAMABLE_DFA__

---