From 0ea5fc66924303d1bf73ba283a383e2aadee02f2 Mon Sep 17 00:00:00 2001 From: neodarz Date: Sat, 11 Aug 2018 20:21:34 +0200 Subject: Initial commit --- docs/doxygen/nel/a02824.html | 1096 ++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 1096 insertions(+) create mode 100644 docs/doxygen/nel/a02824.html (limited to 'docs/doxygen/nel/a02824.html') diff --git a/docs/doxygen/nel/a02824.html b/docs/doxygen/nel/a02824.html new file mode 100644 index 00000000..51e9702f --- /dev/null +++ b/docs/doxygen/nel/a02824.html @@ -0,0 +1,1096 @@ + + +NeL: NLLOGIC::CLogicState class Reference + + + +
+Main Page | Namespace List | Class Hierarchy | Alphabetical List | Data Structures | File List | Namespace Members | Data Fields | Globals | Related Pages | Search for 
+

NLLOGIC::CLogicState Class Reference

#include <logic_state.h> +

+

Detailed Description

+CLogicState

+

Author:
Stephane Coutelas

+Nevrax France

+
Date:
2001
+ +

+ +

+Definition at line 56 of file logic_state.h. + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

Public Member Functions

void addEvent (CLogicEvent event)
void addSIdMap (const TSIdMap &sIdMap)
 CLogicState ()
void enterState ()
void exitState ()
void fillVarMap (std::multimap< NLMISC::CEntityId, std::string > &stateMachineVariables)
void getMessagesToSend (std::multimap< NLMISC::CEntityId, NLNET::CMessage > &msgs)
std::string getName ()
void processLogic ()
void read (xmlNodePtr node)
void setLogicStateMachine (CLogicStateMachine *logicStateMachine)
void setName (std::string name)
void trySendEntryMessages ()
void trySendEventMessages ()
void write (xmlNodePtr node) const

Data Fields

std::vector< CLogicEventMessage > _EntryMessages
 entry messages

std::vector< CLogicEvent > _Events
 logic

std::vector< CLogicEventMessage > _ExitMessages
 exit messages

CLogicStateMachine * _LogicStateMachine
 state machine containing this state

std::multimap< NLMISC::CEntityId,
+ NLNET::CMessage > 		_MessagesToSend
 messages to send by the service

std::string _StateName
 state name

+

Constructor & Destructor Documentation

+

+ + + + +
+ + + + + + + + + +
NLLOGIC::CLogicState::CLogicState (   ) 
+
+ + + + + +
+   + + +

+Default constructor +

+Definition at line 42 of file logic_state.cpp. +

+References _StateName. +

+

00043 {
+00044         _StateName = "no_state";
+00045         _LogicStateMachine = 0;
+00046 
+00047 } // CLogicState //
+
+

Member Function Documentation

+

+ + + + +
+ + + + + + + + + + +
void NLLOGIC::CLogicState::addEvent ( CLogicEvent  event  ) 
+
+ + + + + +
+   + + +

+Add an event

+

Parameters:
+ + +
event is the event to add
+
+ +

+Definition at line 81 of file logic_state.cpp. +

+References NLLOGIC::CLogicEvent::setLogicStateMachine(). +

+

00082 { 
+00083         event.setLogicStateMachine( _LogicStateMachine );
+00084         _Events.push_back( event ); 
+00085 
+00086 } // addEvent //
+
+

+ + + + +
+ + + + + + + + + + +
void NLLOGIC::CLogicState::addSIdMap ( const TSIdMap &  sIdMap  ) 
+
+ + + + + +
+   + + +

+Associate message destination name with sid

+

Parameters:
+ + +
sIdMap is the map associating destination name with a destination id
+
+ +

+Definition at line 96 of file logic_state.cpp. +

+References _EntryMessages, _ExitMessages, trySendEntryMessages(), trySendEventMessages(), and NLLOGIC::TSIdMap. +

+

00097 {
+00098         vector<CLogicEventMessage>::iterator itMsg;
+00099 
+00101         for( itMsg = _EntryMessages.begin(); itMsg != _EntryMessages.end(); ++itMsg )
+00102         {
+00103                 TSIdMap::const_iterator itId = sIdMap.find( (*itMsg).Destination );
+00104                 // if message destination exists in the map we associate the sid with the message
+00105                 if( itId != sIdMap.end() )
+00106                 {
+00107                         (*itMsg).DestinationId = (*itId).second;
+00108                 }
+00109         }
+00111         trySendEntryMessages();
+00112                 
+00113 
+00114         // event messages
+00115         vector<CLogicEvent>::iterator itEvt;
+00116         for( itEvt = _Events.begin(); itEvt != _Events.end(); ++itEvt )
+00117         {
+00118                 string dest = (*itEvt).EventAction.EventMessage.Destination;
+00119                 TSIdMap::const_iterator itId = sIdMap.find( dest );
+00120                 // if message destination exists in the map we associate the sid with the message
+00121                 if( itId != sIdMap.end() )
+00122                 {
+00123                         (*itEvt).EventAction.EventMessage.DestinationId = (*itId).second;
+00124                 }
+00125         }
+00127         trySendEventMessages();
+00128 
+00129 
+00131         for( itMsg = _ExitMessages.begin(); itMsg != _ExitMessages.end(); ++itMsg )
+00132         {
+00133                 TSIdMap::const_iterator itId = sIdMap.find( (*itMsg).Destination );
+00134                 // if message destination exists in the map we associate the sid with the message
+00135                 if( itId != sIdMap.end() )
+00136                 {
+00137                         (*itMsg).DestinationId = (*itId).second;
+00138                 }
+00139         }
+00140         
+00141 } // addSIdMap //
+
+

+ + + + +
+ + + + + + + + + +
void NLLOGIC::CLogicState::enterState (   ) 
+
+ + + + + +
+   + + +

+send the entry messages +

+Definition at line 184 of file logic_state.cpp. +

+References trySendEntryMessages(). +

+

00185 {
+00187         trySendEntryMessages();
+00188 
+00189 } // enterState //
+
+

+ + + + +
+ + + + + + + + + +
void NLLOGIC::CLogicState::exitState (   ) 
+
+ + + + + +
+   + + +

+send the exit messages +

+Definition at line 196 of file logic_state.cpp. +

+References _EntryMessages, _ExitMessages, _MessagesToSend, and NLMISC::CMemStream::serial(). +

+

00197 {
+00198         vector<CLogicEventMessage>::iterator itMsg;
+00199         for( itMsg = _ExitMessages.begin(); itMsg != _ExitMessages.end(); ++itMsg )
+00200         {
+00201                 if( (*itMsg).DestinationId != CEntityId() )
+00202                 {
+00203                         CMessage msgOut( (*itMsg).MessageId );
+00204                         msgOut.serial( (*itMsg).Arguments );
+00205                         
+00206                         _MessagesToSend.insert( make_pair((*itMsg).DestinationId,msgOut) );
+00207                 }
+00208         }
+00209 
+00210         // reset the entry messages send status
+00211         for( itMsg = _EntryMessages.begin(); itMsg != _EntryMessages.end(); ++itMsg )
+00212         {
+00213                 (*itMsg).ToSend = false;
+00214                 (*itMsg).Sent = false;
+00215         }
+00216 
+00217         // reset all events
+00218         vector<CLogicEvent>::iterator itEvent;
+00219         for( itEvent = _Events.begin(); itEvent != _Events.end(); ++itEvent )
+00220         {
+00221                 (*itEvent).reset();
+00222         }
+00223 
+00224         // reset the exit messages send status
+00225         for( itMsg = _ExitMessages.begin(); itMsg != _ExitMessages.end(); ++itMsg )
+00226         {
+00227                 (*itMsg).ToSend = false;
+00228                 (*itMsg).Sent = false;
+00229         }
+00230         
+00231 } // exitState //
+
+

+ + + + +
+ + + + + + + + + + +
void NLLOGIC::CLogicState::fillVarMap ( std::multimap< NLMISC::CEntityId, std::string > &  stateMachineVariables  ) 
+
+ + + + + +
+   + + +

+Fill a map associating all the referenced var in the state with the id of service managing them (debug purpose) +

+Definition at line 315 of file logic_state.cpp. +

+References condition, and NLLOGIC::CLogicStateMachine::getCondition(). +

+

00316 {
+00317         // events
+00318         vector<CLogicEvent>::iterator itEvt;
+00319         for( itEvt = _Events.begin(); itEvt != _Events.end(); ++itEvt )
+00320         {
+00321                 // get the condition used in the event
+00322                 CLogicCondition condition;
+00323                 if( _LogicStateMachine->getCondition((*itEvt).ConditionName,condition) )
+00324                 {
+00325                         // get vars used in the conditions
+00326                         set<string> condVars;
+00327                         condition.fillVarSet( condVars );
+00328 
+00329                         // add var with related service
+00330                         set<string>::iterator itCV;
+00331                         for( itCV = condVars.begin(); itCV != condVars.end(); ++itCV )
+00332                         {
+00333                                 stateMachineVariables.insert( make_pair((*itEvt).EventAction.EventMessage.DestinationId,*itCV) );
+00334                         }
+00335                 }
+00336         }
+00337 
+00338 } // fillVarMap //
+
+

+ + + + +
+ + + + + + + + + + +
void NLLOGIC::CLogicState::getMessagesToSend ( std::multimap< NLMISC::CEntityId, NLNET::CMessage > &  msgs  ) 
+
+ + + + + +
+   + + +

+Get the messages to send

+

Parameters:
+ + +
msgs is the map associating all the message to send with their destination id
+
+ +

+Definition at line 296 of file logic_state.cpp. +

+References _MessagesToSend. +

+

00297 {
+00298         multimap<CEntityId,CMessage>::iterator itMsg;
+00299         for( itMsg = _MessagesToSend.begin(); itMsg != _MessagesToSend.end(); ++itMsg )
+00300         {
+00301                 msgs.insert( *itMsg );
+00302         }
+00303 
+00304         // erase all the messages
+00305         _MessagesToSend.clear();
+00306 
+00307 } // getMessagesToSend //
+
+

+ + + + +
+ + + + + + + + + + +
std::string NLLOGIC::CLogicState::getName ( void   )  [inline]
+
+ + + + + +
+   + + +

+get the state name

+

Returns:
the state's name
+ +

+Definition at line 104 of file logic_state.h. +

+References _StateName. +

+Referenced by NLLOGIC::CLogicStateMachine::addState(). +

+

00104 { return _StateName; }
+
+

+ + + + +
+ + + + + + + + + +
void NLLOGIC::CLogicState::processLogic (   ) 
+
+ + + + + +
+   + + +

+Test the conditions of this state +

+Definition at line 148 of file logic_state.cpp. +

+References NLLOGIC::CLogicStateMachine::setCurrentState(), and trySendEventMessages(). +

+

00149 {
+00150         // test all conditions managed by this state
+00151         vector<CLogicEvent>::iterator itEvent;
+00152         for( itEvent = _Events.begin(); itEvent != _Events.end(); ++itEvent )
+00153         {
+00154                 if( (*itEvent).testCondition() )
+00155                 {
+00156                         //nlinfo("The condition %s is valid",(*itEvent).ConditionName.c_str());
+00157                         if( (*itEvent).EventAction.IsStateChange )
+00158                         {
+00159                                 _LogicStateMachine->setCurrentState( (*itEvent).EventAction.StateChange );
+00160                         }
+00161                         else
+00162                         {
+00163                                 // this message will be sent as soon as the dest id will be given
+00164                                 (*itEvent).EventAction.enableSendMessage();
+00165 
+00167                                 trySendEventMessages();
+00168                         }
+00169                 }
+00170                 else
+00171                 {
+00172                         // reset message send status here to be able to send messages several times in the logic state
+00173                         // --> this has to be done if we want messages to be sent every time the condition becomes verified
+00174                 }
+00175         }
+00176 
+00177 } // processLogic //
+
+

+ + + + +
+ + + + + + + + + + +
void NLLOGIC::CLogicState::read ( xmlNodePtr  node  ) 
+
+ + + + + +
+   + + +

+ +

+Definition at line 379 of file logic_state.cpp. +

+References _EntryMessages, _ExitMessages, _StateName, NLLOGIC::getXMLProp(), uint, v, and NLLOGIC::xmlCheckNodeName(). +

+

00380 {
+00381         xmlCheckNodeName (node, "STATE");
+00382 
+00383         _StateName = getXMLProp (node, "Name");
+00384 
+00385         {
+00386                 // Count the parent
+00387                 uint nb = CIXml::countChildren (node, "ENTRY_EVENT_MESSAGE");
+00388                 uint i = 0;
+00389                 xmlNodePtr parent = CIXml::getFirstChildNode (node, "ENTRY_EVENT_MESSAGE");
+00390                 while (i<nb)
+00391                 {
+00392                         CLogicEventMessage v;
+00393                         v.read(parent);
+00394                         _EntryMessages.push_back(v);
+00395 
+00396                         // Next parent
+00397                         parent = CIXml::getNextChildNode (parent, "ENTRY_EVENT_MESSAGE");
+00398                         i++;
+00399                 }
+00400         }
+00401         
+00402         {
+00403                 // Count the parent
+00404                 uint nb = CIXml::countChildren (node, "EXIT_EVENT_MESSAGE");
+00405                 uint i = 0;
+00406                 xmlNodePtr parent = CIXml::getFirstChildNode (node, "EXIT_EVENT_MESSAGE");
+00407                 while (i<nb)
+00408                 {
+00409                         CLogicEventMessage v;
+00410                         v.read(parent);
+00411                         _ExitMessages.push_back(v);
+00412 
+00413                         // Next parent
+00414                         parent = CIXml::getNextChildNode (parent, "EXIT_EVENT_MESSAGE");
+00415                         i++;
+00416                 }
+00417         }
+00418 
+00419         {
+00420                 // Count the parent
+00421                 uint nb = CIXml::countChildren (node, "EVENT");
+00422                 uint i = 0;
+00423                 xmlNodePtr parent = CIXml::getFirstChildNode (node, "EVENT");
+00424                 while (i<nb)
+00425                 {
+00426                         CLogicEvent v;
+00427                         v.read(parent);
+00428                         _Events.push_back(v);
+00429 
+00430                         // Next parent
+00431                         parent = CIXml::getNextChildNode (parent, "EVENT");
+00432                         i++;
+00433                 }
+00434         }
+00435 
+00436 }
+
+

+ + + + +
+ + + + + + + + + + +
void NLLOGIC::CLogicState::setLogicStateMachine ( CLogicStateMachine *  logicStateMachine  ) 
+
+ + + + + +
+   + + +

+Set the state machine which contains this state

+

Parameters:
+ + +
logicStateMachine is the state machine containing this block
+
+ +

+Definition at line 54 of file logic_state.cpp. +

+References nlwarning. +

+Referenced by NLLOGIC::CLogicStateMachine::addState(). +

+

00055 { 
+00056         if( logicStateMachine == 0 )
+00057         {
+00058                 nlwarning("(LOGIC)<CLogicCondition::setLogicStateMachine> The state machine is null");
+00059         }
+00060         else
+00061         {
+00062                 // init the logic state machine for this state
+00063                 _LogicStateMachine = logicStateMachine; 
+00064 
+00065                 // init the logic state machine in each event
+00066                 vector<CLogicEvent>::iterator itEvent;
+00067                 for( itEvent = _Events.begin(); itEvent != _Events.end(); ++itEvent )
+00068                 {
+00069                         (*itEvent).setLogicStateMachine( logicStateMachine );
+00070                 }
+00071         }
+00072 
+00073 } // setLogicStateMachine //
+
+

+ + + + +
+ + + + + + + + + + +
void NLLOGIC::CLogicState::setName ( std::string  name  )  [inline]
+
+ + + + + +
+   + + +

+set the state name

+

Parameters:
+ + +
name is the new state's name
+
+ +

+Definition at line 97 of file logic_state.h. +

+References _StateName. +

+

00097 { _StateName = name; }
+
+

+ + + + +
+ + + + + + + + + +
void NLLOGIC::CLogicState::trySendEntryMessages (   ) 
+
+ + + + + +
+   + + +

+Try to send the entry messages +

+Definition at line 239 of file logic_state.cpp. +

+References _EntryMessages, _MessagesToSend, and NLMISC::CMemStream::serial(). +

+Referenced by addSIdMap(), and enterState(). +

+

00240 {
+00242         vector<CLogicEventMessage>::iterator itMsg;
+00243         for( itMsg = _EntryMessages.begin(); itMsg != _EntryMessages.end(); ++itMsg )
+00244         {
+00245                 if( !(*itMsg).Sent && (*itMsg).DestinationId.getType() != 0xfe )
+00246                 {
+00247                         CMessage msgOut( (*itMsg).MessageId );
+00248                         msgOut.serial( (*itMsg).Arguments );
+00249 
+00250                         _MessagesToSend.insert( make_pair((*itMsg).DestinationId,msgOut) );
+00251                         
+00252                         (*itMsg).ToSend = false;
+00253                         (*itMsg).Sent = true;
+00254                 }
+00255         }
+00256 
+00257 } // trySendEntryMessages //
+
+

+ + + + +
+ + + + + + + + + +
void NLLOGIC::CLogicState::trySendEventMessages (   ) 
+
+ + + + + +
+   + + +

+Try to send the event messages +

+Definition at line 265 of file logic_state.cpp. +

+References _MessagesToSend, and NLMISC::CMemStream::serial(). +

+Referenced by addSIdMap(), and processLogic(). +

+

00266 {
+00267         // test all conditions managed by this state
+00268         vector<CLogicEvent>::iterator itEvent;
+00269         for( itEvent = _Events.begin(); itEvent != _Events.end(); ++itEvent )
+00270         {
+00271                 if( (*itEvent).EventAction.EventMessage.ToSend == true )
+00272                 {
+00273                         if( (*itEvent).EventAction.EventMessage.Sent == false )
+00274                         {
+00275                                 if( (*itEvent).EventAction.EventMessage.DestinationId.getType() != 0xfe )
+00276                                 {
+00277                                         CMessage msgOut( (*itEvent).EventAction.EventMessage.MessageId );
+00278                                         msgOut.serial( (*itEvent).EventAction.EventMessage.Arguments );
+00279                                         
+00280                                         _MessagesToSend.insert( make_pair((*itEvent).EventAction.EventMessage.DestinationId,msgOut) );
+00281 
+00282                                         (*itEvent).EventAction.EventMessage.ToSend = false;
+00283                                         (*itEvent).EventAction.EventMessage.Sent = true;
+00284                                 }
+00285                         }
+00286                 }
+00287         }
+00288 
+00289 } // trySendEventMessages //
+
+

+ + + + +
+ + + + + + + + + + +
void NLLOGIC::CLogicState::write ( xmlNodePtr  node  )  const
+
+ + + + + +
+   + + +

+serial +

+Definition at line 359 of file logic_state.cpp. +

+References _EntryMessages, _ExitMessages, _StateName, and uint. +

+

00360 {
+00361         xmlNodePtr elmPtr = xmlNewChild ( node, NULL, (const xmlChar*)"STATE", NULL);
+00362         xmlSetProp (elmPtr, (const xmlChar*)"Name", (const xmlChar*)_StateName.c_str());
+00363 
+00364         uint i;
+00365         for (i = 0; i < _EntryMessages.size(); i++)
+00366         {
+00367                 _EntryMessages[i].write(elmPtr, "ENTRY_");
+00368         }
+00369         for (i = 0; i < _ExitMessages.size(); i++)
+00370         {
+00371                 _ExitMessages[i].write(elmPtr, "EXIT_");
+00372         }
+00373         for (i = 0; i < _Events.size(); i++)
+00374         {
+00375                 _Events[i].write(elmPtr);
+00376         }
+00377 }
+
+

Field Documentation

+

+ + + + +
+ + +
std::vector<CLogicEventMessage> NLLOGIC::CLogicState::_EntryMessages +
+
+ + + + + +
+   + + +

+entry messages +

+ +

+Definition at line 64 of file logic_state.h. +

+Referenced by addSIdMap(), exitState(), read(), trySendEntryMessages(), and write().

+

+ + + + +
+ + +
std::vector<CLogicEvent> NLLOGIC::CLogicState::_Events +
+
+ + + + + +
+   + + +

+logic +

+ +

+Definition at line 70 of file logic_state.h.

+

+ + + + +
+ + +
std::vector<CLogicEventMessage> NLLOGIC::CLogicState::_ExitMessages +
+
+ + + + + +
+   + + +

+exit messages +

+ +

+Definition at line 67 of file logic_state.h. +

+Referenced by addSIdMap(), exitState(), read(), and write().

+

+ + + + +
+ + +
CLogicStateMachine* NLLOGIC::CLogicState::_LogicStateMachine +
+
+ + + + + +
+   + + +

+state machine containing this state +

+ +

+Definition at line 73 of file logic_state.h.

+

+ + + + +
+ + +
std::multimap<NLMISC::CEntityId, NLNET::CMessage> NLLOGIC::CLogicState::_MessagesToSend +
+
+ + + + + +
+   + + +

+messages to send by the service +

+ +

+Definition at line 76 of file logic_state.h. +

+Referenced by exitState(), getMessagesToSend(), trySendEntryMessages(), and trySendEventMessages().

+

+ + + + +
+ + +
std::string NLLOGIC::CLogicState::_StateName +
+
+ + + + + +
+   + + +

+state name +

+ +

+Definition at line 61 of file logic_state.h. +

+Referenced by CLogicState(), getName(), read(), setName(), and write().

+

The documentation for this class was generated from the following files: +
Generated on Tue Mar 16 12:54:18 2004 for NeL by + +doxygen +1.3.6
+ + -- cgit v1.2.1