---

action_handler.hh

/*
*  Name:      action_handler.hh
*  Authors:   Francisco Rodrigo Escobedo Robles
*             Rafael Jesus Alcantara Perez
*  Summary:   Base Action Handler definitions
*  Date:      $Date: 2003/10/06 12:45:11 $
*  Revision:  $Revision: 1.1 $
*
*  Copyright (C) 1999       Francisco Rodrigo Escobedo Robles <frer@dedalo-ing.com>
*  Copyright (C) 2001-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_ACTION_HANDLER__
#define _MPCL_AUTOMATON_ACTION_HANDLER__

#include <algorithm>
#include <list>
#include "../event/action.hh"
#include "../util/collection/map.hh"
#include "../util/general-functions.hh"
#include "exceptions.hh"


namespace mpcl
{

  namespace automaton
  {

    using event::IAction;
    using text::TString;
    using util::collection::TMap;

    template <typename TState>
    class TActionHandler
    {

      private:

        typedef TMap<TString, IAction>   TNameToActionMap;

        const unsigned int   kuiRetries;


      protected:

        typedef std::list<IAction*>   TActionList;

        typedef TMap<TState, TActionList>   TStateToActionListMap;

        TActionList   tActionList;

        TStateToActionListMap   tStateToActionListMap;


      public:

        typedef std::list<TString>   TActionNamesList;


      private:

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

        int executeActions (const TActionList& rktACTION_LIST);


      public:

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

        TActionHandler (const unsigned int kuiRETRIES = 1)
          throw (TIntegrityException)        :
          kuiRetries            (kuiRETRIES) ,
          tActionList           ()           ,
          tStateToActionListMap ()
        {
          //
          //  Bad call to constructor.
          //
          if ( kuiRETRIES < 1 )
          {
            throw TIntegrityException ("retries set to less than 1", __FILE__, __LINE__);
          }
        }

        virtual ~TActionHandler (void)
        {
          using std::for_each;
          using util::MDelete;

          for_each (tActionList.begin(), tActionList.end(), MDelete<IAction*>());
        }

        int execute (const TState& rktSTATE)
        {
          typename TStateToActionListMap::const_iterator   I;

          I = tStateToActionListMap.find (rktSTATE);
          if ( I == tStateToActionListMap.end() )
          {
            throw TNotFoundException ("state not found", __FILE__, __LINE__);
          }
          return executeActions (I->second);
        }

        void setActions ( const TState&           rktSOURCE_STATE             ,
                          const TActionNamesList& rktSOURCE_ACTION_NAMES_LIST );


      public:

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

        TActionNamesList getActions (const TState& rktSOURCE_STATE) const;

    };  // class TActionHandler

  }  // namespace automaton

}  // namespace mpcl


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

template <typename TState>
int mpcl::automaton::TActionHandler<TState>::
executeActions (const TActionList& rktACTION_LIST)
{

  register int                           iExitCode    = 0;
  typename TActionList::const_iterator   ktActionIter = rktACTION_LIST.begin();

  for (; ( ktActionIter != rktACTION_LIST.end() ) ;++ktActionIter)
  {
    //
    //  Executes the action and checks for the reaction.
    //
    if ( !(**ktActionIter)() )
    {
      for (unsigned int I = 0; ( I < kuiRetries ) ;++I)
      {
        iExitCode = (*ktActionIter)->react();
        if ( !iExitCode )
        {
          //
          //  Reaction has ran correctly.
          //
          break;
        }
      }
    }
  }
  return iExitCode;

}  // executeActions()


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

template <typename TState>
typename mpcl::automaton::TActionHandler<TState>::TActionNamesList mpcl::automaton::TActionHandler<TState>::
getActions (const TState& rktSOURCE_STATE) const
{

  typename TStateToActionListMap::const_iterator   I;
  TActionNamesList                                 tActionNamesList;

  I = tStateToActionListMap.find (rktSOURCE_STATE);
  if ( I == tStateToActionListMap.end() )
  {
    throw TNotFoundException ("state not found", __FILE__, __LINE__);
  }
  else
  {
    typename TActionList::const_iterator   J = I->second.begin();
    
    //
    //  Translates action to action names.
    //
    for (; ( J != I->second.end() ) ;++J)
    {
      tActionNamesList.push_back ((*J)->getName());
    }
  }
  return tActionNamesList;

}  // getActions()


template <typename TState>
void mpcl::automaton::TActionHandler<TState>::
setActions ( const TState&           rktSOURCE_STATE             ,
             const TActionNamesList& rktSOURCE_ACTION_NAMES_LIST )
{

  typename TActionList::const_iterator        J;
  TActionList                                 tAuxActionList;
  typename TActionNamesList::const_iterator   I = rktSOURCE_ACTION_NAMES_LIST.begin();

  //
  //  State already exists.
  //

  if ( tStateToActionListMap.find (rktSOURCE_STATE) != tStateToActionListMap.end() )
  {
    throw TIntegrityException ("attempt to redefine a state", __FILE__, __LINE__);
  }
  //FIXME: dynamic dependence

  //
  //  Translates action names to action objects.
  //
  for (; ( I != rktSOURCE_ACTION_NAMES_LIST.end() ) ;++I)
  {
    for (J = tActionList.begin(); ( J != tActionList.end() ) ;++J)
    {
      if ( (*J)->getName() == *I )
      {
        break;
      }
    }
    if ( J == tActionList.end() )
    {
      throw TNotFoundException ("action name not found", __FILE__, __LINE__);
    }
    tAuxActionList.push_back (*J);
  }
  tStateToActionListMap.bind (rktSOURCE_STATE, tAuxActionList);

}  // setActions()


#endif  // not _MPCL_AUTOMATON_ACTION_HANDLER__

---