nevrax.org : docs

00001 
+00007 /* Copyright, 2000 Nevrax Ltd.
+00008  *
+00009  * This file is part of NEVRAX NEL.
+00010  * NEVRAX NEL is free software; you can redistribute it and/or modify
+00011  * it under the terms of the GNU General Public License as published by
+00012  * the Free Software Foundation; either version 2, or (at your option)
+00013  * any later version.
+00014 
+00015  * NEVRAX NEL is distributed in the hope that it will be useful, but
+00016  * WITHOUT ANY WARRANTY; without even the implied warranty of
+00017  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+00018  * General Public License for more details.
+00019 
+00020  * You should have received a copy of the GNU General Public License
+00021  * along with NEVRAX NEL; see the file COPYING. If not, write to the
+00022  * Free Software Foundation, Inc., 59 Temple Place - Suite 330, Boston,
+00023  * MA 02111-1307, USA.
+00024  */
+00025 
+00026 
+00027 #include "nel/misc/o_xml.h"
+00028 
+00029 #include "nel/logic/logic_condition.h"
+00030 #include "nel/logic/logic_variable.h"
+00031 #include "nel/logic/logic_state_machine.h"
+00032 
+00033 using namespace NLMISC;
+00034 using namespace std;
+00035 
+00036 namespace NLLOGIC
+00037 {
+00038 
+00039 //-------------------------------------------------
+00040 // setLogicStateMachine :
+00041 //
+00042 //-------------------------------------------------
+00043 void CLogicComparisonBlock::setLogicStateMachine( CLogicStateMachine * logicStateMachine )
+00044 { 
+00045         if( logicStateMachine == 0 )
+00046         {
+00047                 nlwarning("(LOGIC)<CLogicComparisonBlock::setLogicStateMachine> The state machine is null");
+00048         }
+00049         else
+00050         {
+00051                 _LogicStateMachine = logicStateMachine; 
+00052         }
+00053         
+00054 } // setLogicStateMachine //
+00055 
+00056 
+00057 //-------------------------------------------------
+00058 // testLogic :
+00059 //
+00060 //-------------------------------------------------
+00061 bool CLogicComparisonBlock::testLogic()
+00062 {
+00063         CLogicVariable var;
+00064         if( _LogicStateMachine->getVariable( VariableName, var ) == false )
+00065         {
+00066                 nlwarning("(LOGIC)<CLogicComparisonBlock::testLogic> The variable %s is unknown in the state machine",VariableName.c_str());
+00067                 return false;
+00068         }
+00069 
+00070         if( Operator == "<"  )  return ( var.getValue() <  Comparand );
+00071         if( Operator == "<=" )  return ( var.getValue() <= Comparand );
+00072         if( Operator == ">"  )  return ( var.getValue() >  Comparand );
+00073         if( Operator == ">=" )  return ( var.getValue() >= Comparand );
+00074         if( Operator == "==" )  return ( var.getValue() == Comparand );
+00075         if( Operator == "!=" )  return ( var.getValue() != Comparand );
+00076 
+00077         nlwarning("(LOGIC)<CLogicComparisonBlock::testLogic> The comparison block operator %s is unknown",Operator.c_str());
+00078         return false;
+00079 
+00080 } // testLogic //
+00081 
+00082 
+00083 //-------------------------------------------------
+00084 // serial :
+00085 //
+00086 //-------------------------------------------------
+00087 /*void CLogicComparisonBlock::serial( IStream &f )
+00088 {
+00089         f.xmlPush("COMPARISON_BLOCK");
+00090         
+00091         f.serial( VariableName );
+00092         f.serial( Operator );
+00093         f.serial( Comparand );
+00094         
+00095         f.xmlPop();
+00096 
+00097 } // serial //*/
+00098 
+00099 void CLogicComparisonBlock::write (xmlNodePtr node) const
+00100 {
+00101         xmlNodePtr elmPtr = xmlNewChild ( node, NULL, (const xmlChar*)"COMPARISON_BLOCK", NULL);
+00102         xmlSetProp (elmPtr, (const xmlChar*)"VariableName", (const xmlChar*)VariableName.c_str());
+00103         xmlSetProp (elmPtr, (const xmlChar*)"Operator", (const xmlChar*)Operator.c_str());
+00104         xmlSetProp (elmPtr, (const xmlChar*)"Comparand", (const xmlChar*)toString(Comparand).c_str());
+00105 }
+00106 
+00107 void CLogicComparisonBlock::read (xmlNodePtr node)
+00108 {
+00109         xmlCheckNodeName (node, "COMPARISON_BLOCK");
+00110 
+00111         VariableName = getXMLProp (node, "VariableName");
+00112         Operator = getXMLProp (node, "Operator");
+00113         Comparand = atoiInt64(getXMLProp (node, "Comparand").c_str());
+00114 }
+00115 
+00116 
+00117 
+00118 
+00119 
+00120 
+00121 
+00122 //-------------------------------------------------
+00123 // setLogicStateMachine :
+00124 //
+00125 //-------------------------------------------------
+00126 void CLogicConditionLogicBlock::setLogicStateMachine( CLogicStateMachine * logicStateMachine )
+00127 { 
+00128         if( logicStateMachine == 0 )
+00129         {
+00130                 nlwarning("(LOGIC)<CCLogicConditionLogicBlock::setLogicStateMachine> The state machine is null");
+00131         }
+00132         else
+00133         {
+00134                 // set the state machine of this node
+00135                 _LogicStateMachine = logicStateMachine; 
+00136 
+00137                 // set the state machine of the logic block 
+00138                 ComparisonBlock.setLogicStateMachine( logicStateMachine );
+00139         }
+00140 
+00141 } // setLogicStateMachine //
+00142 
+00143 
+00144 //-------------------------------------------------
+00145 // testLogic :
+00146 //
+00147 //-------------------------------------------------
+00148 bool CLogicConditionLogicBlock::testLogic()
+00149 {
+00150         switch( Type )
+00151         {
+00152                 case NOT :
+00153                 {
+00154                         return true;
+00155                 }
+00156                 break;
+00157 
+00158                 case COMPARISON :
+00159                 {
+00160                         return ComparisonBlock.testLogic();
+00161                 }
+00162                 break;
+00163 
+00164                 case SUB_CONDITION :
+00165                 {
+00166                         CLogicCondition condition;
+00167                         if( _LogicStateMachine->getCondition(SubCondition,condition) )
+00168                         {
+00169                                 return condition.testLogic();
+00170                         }
+00171                         else
+00172                         {
+00173                                 nlwarning("(LOGIC)<CLogicConditionLogicBlock::testLogic> The subcondition \"%s\" is unknown in the state machine \"%s\"",
+00174                                         SubCondition.c_str(),_LogicStateMachine->getName().c_str());
+00175                         }
+00176                         
+00177                 }
+00178 
+00179                 default :
+00180                         nlerror("(LOGIC)<CLogicConditionLogicBlock::testLogic> logic block type %d is unknown",Type);
+00181         }
+00182         
+00183         return false;
+00184 
+00185 } // testLogic //
+00186 
+00187 
+00188 
+00189 //-------------------------------------------------
+00190 // fillVarSet :
+00191 //
+00192 //-------------------------------------------------
+00193 void CLogicConditionLogicBlock::fillVarSet( set<string>& condVars )
+00194 {
+00195         if( Type == COMPARISON )
+00196         {
+00197                 condVars.insert( ComparisonBlock.VariableName );
+00198         }
+00199         else
+00200         {
+00201                 if( Type == SUB_CONDITION )
+00202                 {
+00203                         CLogicCondition condition;
+00204                         if( _LogicStateMachine->getCondition(SubCondition,condition) )
+00205                         {
+00206                                 condition.fillVarSet( condVars );
+00207                         }
+00208                 }
+00209         }
+00210 
+00211 } // fillVarSet //
+00212 
+00213 
+00214 //-------------------------------------------------
+00215 // serial :
+00216 //
+00217 //-------------------------------------------------
+00218 /*void CLogicConditionLogicBlock::serial( IStream &f )
+00219 {
+00220         f.xmlPush("CONDITION_LOGIC_BLOCK");
+00221 
+00222         f.serialEnum( Type );
+00223         switch( Type )
+00224         {
+00225                 case NOT : break;
+00226                         
+00227                 case COMPARISON :
+00228                 {
+00229                         f.serial( ComparisonBlock );
+00230                 }
+00231                 break;
+00232 
+00233                 case SUB_CONDITION :
+00234                 {
+00235                         f.serial( SubCondition );
+00236                 }
+00237                 break;
+00238         };
+00239         
+00240         f.xmlPop();
+00241 };*/
+00242 
+00243 void CLogicConditionLogicBlock::write (xmlNodePtr node) const
+00244 {
+00245         xmlNodePtr elmPtr = xmlNewChild ( node, NULL, (const xmlChar*)"CONDITION_LOGIC_NODE", NULL);
+00246         xmlSetProp (elmPtr, (const xmlChar*)"Type", (const xmlChar*)toString(Type).c_str());
+00247         switch( Type )
+00248         {
+00249                 case NOT : break;
+00250                         
+00251                 case COMPARISON :
+00252                 {
+00253                         ComparisonBlock.write(elmPtr);
+00254                 }
+00255                 break;
+00256 
+00257                 case SUB_CONDITION :
+00258                 {
+00259                         xmlSetProp (elmPtr, (const xmlChar*)"SubCondition", (const xmlChar*)SubCondition.c_str());
+00260                 }
+00261                 break;
+00262         };
+00263 }
+00264 
+00265 void CLogicConditionLogicBlock::read (xmlNodePtr node)
+00266 {
+00267         xmlCheckNodeName (node, "CONDITION_LOGIC_NODE");
+00268 
+00269         Type = (TLogicConditionLogicBlockType)atoi(getXMLProp (node, "Type").c_str());
+00270         switch( Type )
+00271         {
+00272                 case NOT : break;
+00273                         
+00274                 case COMPARISON :
+00275                 {
+00276                         ComparisonBlock.read (node);
+00277                 }
+00278                 break;
+00279 
+00280                 case SUB_CONDITION :
+00281                 {
+00282                         SubCondition = getXMLProp (node, "SubCondition");
+00283                 }
+00284                 break;
+00285         };
+00286 }
+00287 
+00288 //-----------------------------------------
+00289 
+00290 
+00291 
+00292 //-------------------------------------------------
+00293 // setLogicStateMachine :
+00294 //
+00295 //-------------------------------------------------
+00296 void CLogicConditionNode::setLogicStateMachine( CLogicStateMachine * logicStateMachine )
+00297 { 
+00298         if( logicStateMachine == 0 )
+00299         {
+00300                 nlwarning("(LOGIC)<CLogicConditionNode::setLogicStateMachine> The state machine is null");
+00301         }
+00302         else
+00303         {
+00304                 // set the state machine of this node
+00305                 _LogicStateMachine = logicStateMachine; 
+00306 
+00307                 // set the state machine of the logic block 
+00308                 LogicBlock.setLogicStateMachine( logicStateMachine );
+00309                 
+00310                 // set the state machine for the sub nodes
+00311                 vector<CLogicConditionNode *>::iterator itNodes;
+00312                 for( itNodes = _Nodes.begin(); itNodes != _Nodes.end(); ++itNodes )
+00313                 {
+00314                         (*itNodes)->setLogicStateMachine( logicStateMachine );
+00315                 }
+00316         }
+00317 
+00318 } // setLogicStateMachine //
+00319 
+00320 
+00321 //-------------------------------------------------
+00322 // addNode :
+00323 //
+00324 //-------------------------------------------------
+00325 void CLogicConditionNode::addNode( CLogicConditionNode * node )
+00326 {
+00327         node->setLogicStateMachine( _LogicStateMachine );
+00328         _Nodes.push_back( node );
+00329 
+00330 } // addToSubNodes //
+00331 
+00332 
+00333 //-------------------------------------------------
+00334 // testLogic :
+00335 //
+00336 //-------------------------------------------------
+00337 bool CLogicConditionNode::testLogic()
+00338 {
+00339         // test the logic block
+00340         if( LogicBlock.testLogic() == false )
+00341         {
+00342                 return false;
+00343         }
+00344 
+00345         // if there's no subtree we assess the subtree is true
+00346         if( _Nodes.size() == 0 )
+00347         {
+00348                 return true;
+00349         }
+00350 
+00351         // test the subtree
+00352         if( LogicBlock.isNotBlock() )
+00353         {
+00354                 // the subtree is false if at least one node is true
+00355                 vector<CLogicConditionNode *>::iterator itNodes;
+00356                 for( itNodes = _Nodes.begin(); itNodes != _Nodes.end(); ++itNodes )
+00357                 {
+00358                         if( (*itNodes)->testLogic() == true )
+00359                         {
+00360                                 return false;
+00361                         }
+00362                 }
+00363 
+00364                 return true;
+00365         }
+00366         else
+00367         {
+00368                 // the subtree is true if at least one node is true
+00369                 vector<CLogicConditionNode *>::iterator itNodes;
+00370                 for( itNodes = _Nodes.begin(); itNodes != _Nodes.end(); ++itNodes )
+00371                 {
+00372                         if( (*itNodes)->testLogic() == true )
+00373                         {
+00374                                 return true;
+00375                         }
+00376                 }
+00377 
+00378                 return false;
+00379         }
+00380 
+00381 } // testLogic //
+00382 
+00383 
+00384 //-------------------------------------------------
+00385 // fillVarSet :
+00386 //
+00387 //-------------------------------------------------
+00388 void CLogicConditionNode::fillVarSet( set<string>& condVars )
+00389 {
+00390         if( Type == LOGIC_NODE )
+00391         {
+00392                 LogicBlock.fillVarSet( condVars );
+00393         }
+00394 
+00395         vector<CLogicConditionNode *>::iterator itNode;
+00396         for( itNode = _Nodes.begin(); itNode != _Nodes.end(); ++itNode )
+00397         {
+00398                 (*itNode)->fillVarSet( condVars );
+00399         }
+00400 
+00401 } // fillVarSet //
+00402 
+00403 
+00404 //-------------------------------------------------
+00405 // serial :
+00406 //
+00407 //-------------------------------------------------
+00408 /*void CLogicConditionNode::serial( IStream &f )
+00409 {
+00410         f.xmlPush("CONDITION_NODE");
+00411         
+00412         f.serialEnum( Type );
+00413         switch( Type )
+00414         {
+00415                 case TERMINATOR : break;
+00416                 case LOGIC_NODE :
+00417                 {
+00418                         f.serial( LogicBlock );
+00419                         if( f.isReading() )
+00420                         {
+00421                                 uint32 sz;
+00422                                 f.serial( sz );
+00423                                 uint i;
+00424                                 for( i = 0; i < sz; i++ )
+00425                                 {
+00426                                         CLogicConditionNode * node = new CLogicConditionNode();
+00427                                         f.serial( *node );
+00428                                         _Nodes.push_back( node );
+00429                                 }
+00430                         }
+00431                         else
+00432                         {
+00433                                 uint32 sz = _Nodes.size();
+00434                                 f.serial( sz );
+00435                                 vector<CLogicConditionNode *>::iterator itNode;
+00436                                 for( itNode = _Nodes.begin(); itNode != _Nodes.end(); ++itNode )
+00437                                 {
+00438                                         f.serial( **itNode );
+00439                                 }
+00440                         }
+00441                 }
+00442                 break;
+00443         };
+00444 
+00445         f.xmlPop();
+00446 
+00447 } // serial //*/
+00448 
+00449 void CLogicConditionNode::write (xmlNodePtr node) const
+00450 {
+00451         xmlNodePtr elmPtr = xmlNewChild ( node, NULL, (const xmlChar*)"CONDITION_NODE", NULL);
+00452         xmlSetProp (elmPtr, (const xmlChar*)"Type", (const xmlChar*)toString(Type).c_str());
+00453 
+00454         switch( Type )
+00455         {
+00456                 case TERMINATOR : break;
+00457                 case LOGIC_NODE :
+00458                 {
+00459                         LogicBlock.write(elmPtr);
+00460                         vector<CLogicConditionNode *>::const_iterator itNode = _Nodes.begin();
+00461                         for( ; itNode != _Nodes.end(); ++itNode )
+00462                         {
+00463                                 (*itNode)->write(elmPtr);
+00464                         }
+00465                 }
+00466                 break;
+00467         };
+00468 }
+00469 
+00470 void CLogicConditionNode::read (xmlNodePtr node)
+00471 {
+00472         xmlCheckNodeName (node, "CONDITION_NODE");
+00473 
+00474         Type = (TConditionNodeType )atoi(getXMLProp (node, "Type").c_str());
+00475         switch( Type )
+00476         {
+00477                 case TERMINATOR : break;
+00478                 case LOGIC_NODE :
+00479                 {
+00480                         LogicBlock.read (node);
+00481 
+00482                         {
+00483                                 // Count the parent
+00484                                 uint nb = CIXml::countChildren (node, "CONDITION_NODE");
+00485                                 uint i = 0;
+00486                                 xmlNodePtr parent = CIXml::getFirstChildNode (node, "CONDITION_NODE");
+00487                                 while (i<nb)
+00488                                 {
+00489                                         CLogicConditionNode *v = new CLogicConditionNode();
+00490                                         v->read(parent);
+00491                                         _Nodes.push_back (v);
+00492 
+00493                                         // Next parent
+00494                                         parent = CIXml::getNextChildNode (parent, "CONDITION_NODE");
+00495                                         i++;
+00496                                 }
+00497                         }
+00498                 }
+00499                 break;
+00500         };
+00501 }
+00502 
+00503 //-------------------------------------------------
+00504 // ~CLogicConditionNode :
+00505 //
+00506 //-------------------------------------------------
+00507 CLogicConditionNode::~CLogicConditionNode()
+00508 {
+00509         vector<CLogicConditionNode *>::iterator itNodes;
+00510         for( itNodes = _Nodes.begin(); itNodes != _Nodes.end(); ++itNodes )
+00511         {
+00512                 delete (*itNodes);
+00513         }
+00514 
+00515 } // ~CLogicConditionNode //
+00516 
+00517 
+00518 
+00519 
+00520 
+00521 
+00522 
+00523 //-------------------------------------------------
+00524 // setLogicStateMachine :
+00525 //
+00526 //-------------------------------------------------
+00527 void CLogicCondition::setLogicStateMachine( CLogicStateMachine * logicStateMachine )
+00528 { 
+00529         if( logicStateMachine == 0 )
+00530         {
+00531                 nlwarning("(LOGIC)<CLogicCondition::setLogicStateMachine> The state machine is null");
+00532         }
+00533         else
+00534         {
+00535                 // init the logic state machine for each node
+00536                 vector<CLogicConditionNode>::iterator itNodes;
+00537                 for( itNodes = Nodes.begin(); itNodes != Nodes.end(); ++itNodes )
+00538                 {
+00539                         (*itNodes).setLogicStateMachine( logicStateMachine );
+00540                 }
+00541         }
+00542 
+00543 } // setLogicStateMachine //
+00544 
+00545 
+00546 //-------------------------------------------------
+00547 // testLogic :
+00548 //
+00549 //-------------------------------------------------
+00550 bool CLogicCondition::testLogic()
+00551 {
+00552         vector<CLogicConditionNode>::iterator itNodes;
+00553         for( itNodes = Nodes.begin(); itNodes != Nodes.end(); ++itNodes )
+00554         {
+00555                 if( (*itNodes).testLogic() == false )
+00556                 {
+00557                         return false;
+00558                 }
+00559         }
+00560 
+00561         return true;
+00562 
+00563 } // testLogic //
+00564 
+00565 
+00566 
+00567 //-------------------------------------------------
+00568 // fillVarSet :
+00569 //
+00570 //-------------------------------------------------
+00571 void CLogicCondition::fillVarSet( set<string>& condVars )
+00572 {
+00573         vector<CLogicConditionNode>::iterator itNode;
+00574         for( itNode = Nodes.begin(); itNode != Nodes.end(); ++itNode )
+00575         {
+00576                 (*itNode).fillVarSet( condVars );
+00577         }
+00578 
+00579 } // fillVarSet //
+00580 
+00581 
+00582 
+00583 //-------------------------------------------------
+00584 // serial :
+00585 //
+00586 //-------------------------------------------------
+00587 /*void CLogicCondition::serial( IStream &f )
+00588 {
+00589         f.xmlPush("CONDITION");
+00590         
+00591         f.serial( _ConditionName );
+00592         f.serialCont( Nodes );
+00593 
+00594         f.xmlPop();
+00595 
+00596 } // serial //*/
+00597 
+00598 void CLogicCondition::write (xmlNodePtr node) const
+00599 {
+00600         xmlNodePtr elmPtr = xmlNewChild ( node, NULL, (const xmlChar*)"CONDITION", NULL);
+00601         xmlSetProp (elmPtr, (const xmlChar*)"Name", (const xmlChar*)_ConditionName.c_str());
+00602 
+00603         uint i;
+00604         for (i = 0; i < Nodes.size(); i++)
+00605         {
+00606                 Nodes[i].write(elmPtr);
+00607         }
+00608 }
+00609 
+00610 void CLogicCondition::read (xmlNodePtr node)
+00611 {
+00612         xmlCheckNodeName (node, "CONDITION");
+00613 
+00614         _ConditionName = getXMLProp (node, "Name");
+00615 
+00616         {
+00617                 // Count the parent
+00618                 uint nb = CIXml::countChildren (node, "CONDITION_NODE");
+00619                 uint i = 0;
+00620                 xmlNodePtr parent = CIXml::getFirstChildNode (node, "CONDITION_NODE");
+00621                 while (i<nb)
+00622                 {
+00623                         CLogicConditionNode v;
+00624                         v.read(parent);
+00625                         Nodes.push_back (v);
+00626 
+00627                         // Next parent
+00628                         parent = CIXml::getNextChildNode (parent, "CONDITION_NODE");
+00629                         i++;
+00630                 }
+00631         }
+00632 }
+00633 
+00634 
+00635 } // NLLOGIC
+
logic_condition.cpp
