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/a03342.html | 6070 ++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 6070 insertions(+) create mode 100644 docs/doxygen/nel/a03342.html (limited to 'docs/doxygen/nel/a03342.html') diff --git a/docs/doxygen/nel/a03342.html b/docs/doxygen/nel/a03342.html new file mode 100644 index 00000000..29738119 --- /dev/null +++ b/docs/doxygen/nel/a03342.html @@ -0,0 +1,6070 @@ + + +NeL: NLAILOGIC::CRule class Reference + + + +
+

NLAILOGIC::CRule Class Reference

#include <rule.h> +

+

Inheritance diagram for NLAILOGIC::CRule: +

+ +NLAILOGIC::CClause +NLAILOGIC::CVarSet +NLAILOGIC::IBaseBoolType +NLAIAGENT::IObjetOp +NLAIAGENT::IObjectIA +NLAIAGENT::IBasicObjectIA +NLAIC::IBasicInterface +NLAIC::IBasicType +NLAIC::IPointerGestion +NLMISC::IStreamable +NLMISC::IClassable + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

IObjectIA base class method;

virtual sint32 getMethodIndexSize () const
virtual TQueue IObjetOp::isMember (const IVarName *, const IVarName *, const IObjectIA &) const
virtual CProcessResult IObjetOp::runMethodeMember (sint32 index, IObjectIA *)

[NOHEADER]

virtual IObjetOpneg ()
 throw (NLAIE::CExceptionNotImplemented)

virtual IObjetOpoperator *= (const IObjetOp &)
 throw (NLAIE::CExceptionNotImplemented)

virtual IObjetOpoperator+= (const IObjetOp &)
 add the operater by anather.

virtual IObjetOpoperator-= (const IObjetOp &)
 throw (NLAIE::CExceptionNotImplemented)

virtual IObjetOpoperator/= (const IObjetOp &)
 throw (NLAIE::CExceptionNotImplemented)


[NOHEADER]

virtual IObjetOpoperator * (const IObjetOp &)
 throw (NLAIE::CExceptionNotImplemented)

virtual IObjetOpoperator+ (const IObjetOp &)
 throw (NLAIE::CExceptionNotImplemented)

virtual IObjetOpoperator- (const IObjetOp &)
 throw (NLAIE::CExceptionNotImplemented)

virtual IObjetOpoperator/ (const IObjetOp &)
 throw (NLAIE::CExceptionNotImplemented)


Public Types

enum  TOpId {
+  op_add, +op_sub, +op_mul, +op_div, +
+  op_eq, +op_inf, +op_sup, +op_inf_eq, +
+  op_sup_eq, +op_not, +op_diff, +op_neg, +
+  op_last +
+ }

Public Member Functions

virtual void addBuffer ()
void addConc (CFactPattern *)
virtual void addCond (CFactPattern *cond)
virtual void addConflicts ()
void addVar (IBaseVar *)
CValueSetasCValueSet ()
void backward (std::list< CValueSet * > *)
CVarSetbackward (CFactPattern *, std::vector< sint32 > &, std::vector< sint32 > &)
CVarSetbackWard (CFactPattern *)
virtual TQueue canProcessMessage (const IVarName &)
std::vector< IBaseAssert * > & CClause::getAssert ()
void CClause::init (NLAIAGENT::IObjectIA *)
virtual const NLAIC::IBasicTypeclone () const
 CRule (const CRule &)
 CRule (std::list< CFactPattern * > &, std::list< CFactPattern * > &)
 CRule ()
sint32 decRef ()
 Decrement the reference of an object.

void forward (CVarSet *)
virtual void getDebugString (std::string &) const
virtual const std::string getInfo ()
std::list< CClause * > * getInputs ()
virtual std::string getMethodeMemberDebugString (sint32, sint32) const
virtual IObjetOpgetNeg () const
void getPosListBackward (sint32, sint32, std::vector< sint32 > &)
void getPosListForward (sint32, sint32, std::vector< sint32 > &)
const sint32getRef () const
 get the refence count.

const IObjectIAgetStaticMember (const IVarName &compName) const
virtual const IObjectIAgetStaticMember (sint32) const
virtual sint32 getStaticMemberIndex (const IVarName &) const
virtual sint32 getStaticMemberSize () const
virtual const NLAIC::CIdentTypegetType () const
std::list< NLAIAGENT::IObjetOp * > * getValues ()
virtual std::vector< IBaseVar * > * getVars ()
void incRef ()
 Inc a reference. We use this when we have to conserve a pointer memeory for exemple in a list.

virtual void init (NLAIAGENT::IObjectIA *)
virtual sint32 isClassInheritedFrom (const IVarName &) const
virtual bool isEqual (const IBasicObjectIA &a) const=0
bool isEqual (const NLAIAGENT::IBasicObjectIA &a) const
virtual bool isEqual (const CVarSet &a) const
virtual bool isLocal ()
 If the result is true the object is loclal else its a representation of an object on the server. By the method return true.

virtual TQueue isMember (const IVarName *, const IVarName *, const IObjectIA &) const
virtual bool isTrue () const
 throw (NLAIE::CExceptionNotImplemented)

bool isUnified ()
virtual void load (NLMISC::IStream &is)
sint32 nbVars ()
virtual const NLAIC::IBasicTypenewInstance () const
virtual IObjetOpoperator * (IObjetOp *a)
 throw (NLAIE::CExceptionNotImplemented)

virtual IObjetOpoperator *= (IObjetOp *a)
 throw (NLAIE::CExceptionNotImplemented)

virtual NLAIAGENT::IObjetOpoperator! () const
 throw (NLAIE::CExceptionNotImplemented)

virtual NLAIAGENT::IObjetOpoperator!= (NLAIAGENT::IObjetOp &a) const
 throw (NLAIE::CExceptionNotImplemented)

virtual IObjetOpoperator+ (IObjetOp *a)
 throw (NLAIE::CExceptionNotImplemented)

virtual IObjetOpoperator+= (IObjetOp *a)
 throw (NLAIE::CExceptionNotImplemented)

virtual IObjetOpoperator- (IObjetOp *a)
 throw (NLAIE::CExceptionNotImplemented)

virtual IObjetOpoperator-= (IObjetOp *a)
 throw (NLAIE::CExceptionNotImplemented)

virtual IObjetOpoperator/ (IObjetOp *a)
 throw (NLAIE::CExceptionNotImplemented)

virtual IObjetOpoperator/= (IObjetOp *a)
 throw (NLAIE::CExceptionNotImplemented)

virtual IObjetOpoperator< (IObjetOp &) const
 throw (NLAIE::CExceptionNotImplemented)

virtual IObjetOpoperator<= (IObjetOp &) const
 throw (NLAIE::CExceptionNotImplemented)

bool operator== (const IBasicObjectIA &classType) const
virtual NLAIAGENT::IObjetOpoperator== (NLAIAGENT::IObjetOp &a) const
 throw (NLAIE::CExceptionNotImplemented)

virtual IObjetOpoperator> (IObjetOp &) const
 throw (NLAIE::CExceptionNotImplemented)

virtual IObjetOpoperator>= (IObjetOp &) const
 throw (NLAIE::CExceptionNotImplemented)

virtual IBaseVaroperator[] (sint32)
virtual void propagate (CFactPattern *)
virtual void propagate (std::list< NLAIAGENT::IObjectIA * > *, std::vector< sint32 > &)
virtual void release ()
 Release allow to release the pointer. The last release when the _Ref is nul delete the object.

void removeVar (IBaseVar *)
virtual const CProcessResult & run ()
virtual CProcessResult runMethodeMember (sint32 index, IObjectIA *)
virtual CProcessResult runMethodeMember (sint32, sint32, IObjectIA *)
virtual const CProcessResult & runStep ()
virtual void save (NLMISC::IStream &os)
virtual CProcessResult sendMessage (const IVarName &, IObjectIA *)
virtual CProcessResult sendMessage (IObjectIA *)
virtual void serial (NLMISC::IStream &f) throw (NLMISC::EStream)
void setCond (CClause &)
virtual bool setStaticMember (sint32, IObjectIA *)
bool setStaticMember (const IVarName &compName, IObjectIA *change)
void showBuffer ()
void showConflicts ()
void showLiaisons ()
sint32 size ()
virtual float truthValue () const
 Returns a value in [0,1].

virtual sint32 undefined ()
virtual CVarSetunify (CValueSet *)
virtual CVarSetunify (CVarSet *)
std::list< CValueSet * > * unifyBack (CFactPattern *)
CValueSetunifyLiaison (const CValueSet *, std::list< NLAIAGENT::IObjectIA * > *, std::vector< sint32 > &)
CValueSetunifyLiaisonBack (CValueSet *, std::list< NLAIAGENT::IObjetOp * > &, std::vector< sint32 > &, bool &)
 ~CRule ()

Static Public Attributes

const NLAIC::CIdentType IdClause
const NLAIC::CIdentType IdRule
const NLAIC::CIdentType IdVarSet
TProcessStatement ProcessBuzzy = processBuzzy
TProcessStatement ProcessEnd = processEnd
TProcessStatement ProcessError = processError
TProcessStatement ProcessIdle = processIdle
TProcessStatement ProcessLocked = processLocked
CProcessResult ProcessNotComplit = IObjectIA::CProcessResult(processNotComplete)
CProcessResult ProcessRun = IObjectIA::CProcessResult()

Protected Member Functions

sint32 findAssert (IBaseAssert *)

Protected Attributes

std::vector< IBaseAssert * > _Asserts
std::list< CValueSet * > _BufLiaisons
std::vector< IBaseBoolType * > _Conds
std::list< CValueSet * > _Conflits
bool _FirstOrderTrue
std::list< CValueSet * > _Liaisons
sint32 _NbValid
std::vector< std::vector<
+ sint32 > > 
_PosVarsCond
std::list< CBoolAssert * > _SimpleConds
std::vector< IBaseVar * > _Vars
sint32 NbInstanciated

Private Member Functions

void getConcPosList (sint32, sint32, std::vector< sint32 > &)

Private Attributes

std::vector< IBaseAssert * > _Concs
std::vector< std::vector<
+ sint32 > > 
_PosVarsConc
+

Member Enumeration Documentation

+

+ + + + +
+ + +
enum NLAIAGENT::IObjetOp::TOpId [inherited] +
+
+ + + + + +
+   + + +

+

Enumeration values:
+ + + + + + + + + + + + + + +
op_add  +
op_sub  +
op_mul  +
op_div  +
op_eq  +
op_inf  +
op_sup  +
op_inf_eq  +
op_sup_eq  +
op_not  +
op_diff  +
op_neg  +
op_last  +
+
+ +

+Definition at line 46 of file agent_operator.h. +

+

00047                 {
+00048                         op_add ,
+00049                         op_sub ,
+00050                         op_mul ,
+00051                         op_div ,
+00052                         op_eq ,
+00053                         op_inf ,
+00054                         op_sup ,
+00055                         op_inf_eq ,
+00056                         op_sup_eq ,
+00057                         op_not ,
+00058                         op_diff ,                       
+00059                         op_neg,
+00060                         op_last
+00061                 };      
+
+


Constructor & Destructor Documentation

+

+ + + + +
+ + + + + + + + + +
NLAILOGIC::CRule::CRule  ) 
+
+ + + + + +
+   + + +

+ +

+Definition at line 29 of file rule.cpp. +

+Referenced by clone(), and newInstance(). +

+

00030         {
+00031         }
+
+

+ + + + +
+ + + + + + + + + + + + + + + + + + + +
NLAILOGIC::CRule::CRule std::list< CFactPattern * > & ,
std::list< CFactPattern * > & 
+
+ + + + + +
+   + + +

+ +

+Definition at line 33 of file rule.cpp. +

+References addConc(). +

+

00033                                                                                    : CClause( conds )
+00034         {
+00035                 std::list<CFactPattern *>::iterator it_c = concs.begin();
+00036                 while ( it_c != concs.end() )
+00037                 {
+00038                         addConc( *it_c );
+00039                         it_c++;
+00040                 }
+00041         }
+
+

+ + + + +
+ + + + + + + + + + +
NLAILOGIC::CRule::CRule const CRule  ) 
+
+ + + + + +
+   + + +

+ +

+Definition at line 43 of file rule.cpp. +

+References _Concs, and _PosVarsConc. +

+

00043                                    : CClause(c)
+00044         {
+00045                 std::vector<IBaseAssert *>::const_iterator it_c = c._Concs.begin();
+00046                 while ( it_c != c._Concs.end() )
+00047                 {
+00048                         _Concs.push_back( *it_c );
+00049                         it_c++;
+00050                 }
+00051 
+00052                 std::vector< std::vector<sint32> >::const_iterator it_li = c._PosVarsConc.begin();
+00053                 while ( it_li != c._PosVarsConc.end() )
+00054                 {
+00055                         std::vector<sint32>::const_iterator it_i = (*it_li).begin();
+00056                         _PosVarsConc.push_back( std::vector<sint32>() );
+00057 
+00058                         while ( it_i != (*it_li).end() )
+00059                         {
+00060                                 _PosVarsConc.back().push_back( *it_i ) ;
+00061                                 it_i++;
+00062                         }
+00063                         it_li++;
+00064                 }
+00065         }
+
+

+ + + + +
+ + + + + + + + + +
NLAILOGIC::CRule::~CRule  ) 
+
+ + + + + +
+   + + +

+ +

+Definition at line 84 of file rule.cpp. +

+

00085         {
+00086         }
+
+


Member Function Documentation

+

+ + + + +
+ + + + + + + + + +
void NLAILOGIC::CClause::addBuffer  )  [virtual, inherited]
+
+ + + + + +
+   + + +

+ +

+Definition at line 328 of file clause.cpp. +

+References NLAILOGIC::CClause::_BufLiaisons, and NLAILOGIC::CClause::_Liaisons. +

+Referenced by NLAILOGIC::CClause::propagate(). +

+

00329         {
+00330                 while ( !_BufLiaisons.empty() )
+00331                 {
+00332                         _Liaisons.push_back( _BufLiaisons.front() );
+00333                         std::string buf;
+00334                         _BufLiaisons.front()->getDebugString( buf );
+00335                         //TRACE ( "Ajout de la liaison du buffer: %s ", buf );
+00336                         _BufLiaisons.pop_front();
+00337                 }
+00338         }
+
+

+ + + + +
+ + + + + + + + + + +
void NLAILOGIC::CRule::addConc CFactPattern  ) 
+
+ + + + + +
+   + + +

+ +

+Definition at line 101 of file rule.cpp. +

+References NLAILOGIC::CClause::findAssert(), NLAILOGIC::CFactPattern::getAssert(), NLAILOGIC::CVarSet::getVars(), and sint32. +

+Referenced by CRule(), and init(). +

+

00102         {
+00103                 _Concs.push_back( conc->getAssert() );
+00104 
+00105                 // Recherche l'assertion
+00106                 sint32 pos_assert= findAssert( conc->getAssert() );
+00107                 if ( pos_assert  < 0 )
+00108                 {
+00109                         _Asserts.push_back( conc->getAssert() );
+00110                         pos_assert = _Asserts.size();
+00111                 }
+00112 
+00113                 // Recherche si variables à ajouter
+00114                 std::vector<sint32> pos_vars;
+00115                 std::vector<IBaseVar *> *vars_conc = conc->getVars();
+00116                 if ( vars_conc )
+00117                 {
+00118                         std::vector<IBaseVar *>::iterator it_conc = vars_conc->begin();
+00119                         while ( it_conc != vars_conc->end() )
+00120                         {
+00121                                 bool found;
+00122                                 if ( _Vars.size() )
+00123                                 {
+00124                                         found = false;
+00125                                         for (sint32 i = 0; i < (sint32)_Vars.size() ; i++ ) 
+00126                                         {
+00127                                                 if ( ( *it_conc )->getName() == _Vars[ i ]->getName() )
+00128                                                 {
+00129                                                         found = true;
+00130                                                         pos_vars.push_back( i );
+00131                                                 }
+00132                                         }
+00133                                 }
+00134                                 else
+00135                                         found = false;
+00136                                 
+00137                                 if ( !found ) 
+00138                                 {
+00139                                         _Vars.push_back( (IBaseVar *)(*it_conc)->clone() );
+00140                                         pos_vars.push_back( _Vars.size() - 1);
+00141                                 }
+00142                                 it_conc++;
+00143                         }
+00144                 }
+00145 
+00146                 // Prévenir l'assertion
+00147                 if ( conc->getAssert() )
+00148                 {
+00149                         ((CFirstOrderAssert *)conc->getAssert())->addInput( this, pos_vars );
+00150                         _PosVarsConc.push_back( pos_vars );
+00151                 }
+00152 
+00153                 for ( sint32 i = 0; i < (sint32) vars_conc->size(); i++ )
+00154                 {
+00155                         (*vars_conc)[i]->release();
+00156                 }
+00157                 delete vars_conc;
+00158         }
+
+

+ + + + +
+ + + + + + + + + + +
void NLAILOGIC::CClause::addCond CFactPattern cond  )  [virtual, inherited]
+
+ + + + + +
+   + + +

+ +

+Definition at line 124 of file clause.cpp. +

+References NLAILOGIC::CClause::_Asserts, NLAILOGIC::CClause::_PosVarsCond, NLAILOGIC::CFactPattern::clone(), NLAILOGIC::CClause::findAssert(), NLAILOGIC::CFactPattern::getAssert(), NLAILOGIC::CVarSet::getVars(), and sint32. +

+Referenced by NLAILOGIC::CClause::CClause(). +

+

00125         {
+00126                 _Conds.push_back( (CFactPattern *) cond->clone() );
+00127 
+00128                 // Recherche l'assertion
+00129                 sint32 pos_assert= findAssert( cond->getAssert() );
+00130                 if ( pos_assert  < 0 )
+00131                 {
+00132                         _Asserts.push_back( cond->getAssert() );
+00133                         pos_assert = _Asserts.size();
+00134                 }
+00135 
+00136                 // Recherche si variables à ajouter
+00137                 std::vector<sint32> pos_vars;
+00138                 std::vector<IBaseVar *> *vars_cond = cond->getVars();
+00139                 if ( vars_cond )
+00140                 {
+00141                         std::vector<IBaseVar *>::iterator it_cond = vars_cond->begin();
+00142                         while ( it_cond != vars_cond->end() )
+00143                         {
+00144                                 bool found;
+00145                                 if ( _Vars.size() )
+00146                                 {
+00147                                         found = false;
+00148                                         for (sint32 i = 0; i < (sint32)_Vars.size() ; i++ ) 
+00149                                         {
+00150                                                 if ( ( *it_cond )->getName() == _Vars[ i ]->getName() )
+00151                                                 {
+00152                                                         found = true;
+00153                                                         pos_vars.push_back( i );
+00154                                                 }
+00155                                         }
+00156                                 }
+00157                                 else
+00158                                         found = false;
+00159                                 
+00160                                 if ( !found ) 
+00161                                 {
+00162                                         _Vars.push_back( (IBaseVar *)(*it_cond)->clone() );
+00163                                         pos_vars.push_back( _Vars.size() - 1);
+00164                                 }
+00165                                 it_cond++;
+00166                         }
+00167                 }
+00168 
+00169                 // Prévenir l'assertion
+00170                 if ( cond->getAssert() )
+00171                 {
+00172                         ((CFirstOrderAssert *) cond->getAssert())->addClause( this, pos_vars );
+00173                         _PosVarsCond.push_back( pos_vars );
+00174                 }
+00175 
+00176                 for ( sint32 i = 0; i < (sint32) vars_cond->size(); i++ )
+00177                 {
+00178                         (*vars_cond)[i]->release();
+00179                 }
+00180                 delete vars_cond;
+00181         }
+
+

+ + + + +
+ + + + + + + + + +
void NLAILOGIC::CRule::addConflicts  )  [virtual]
+
+ + + + + +
+   + + +

+ +

+Reimplemented from NLAILOGIC::CClause. +

+Definition at line 165 of file rule.cpp. +

+References NLAILOGIC::CValueSet::getDebugString(), and sint32. +

+

00166         {
+00167                 // Execute la conclusion de la règle
+00168                 std::list<CValueSet *>::iterator it_conf = _Conflits.begin();
+00169                 while ( it_conf != _Conflits.end() )
+00170                 {
+00171                         sint32 pos = 0;
+00172                         std::vector<IBaseAssert *>::iterator it_conc = _Concs.begin();
+00173 #ifdef NL_DEBUG
+00174                         std::vector< std::vector<sint32> >::iterator it_pos = _PosVarsConc.begin();
+00175 #endif
+00176                         while ( it_conc != _Concs.end() )
+00177                         {
+00178                                 // Construire le fait correspondant par rapport à la position des variables
+00179                                 
+00181 #ifdef NL_DEBUG
+00182                                 CValueSet *conflit = new CValueSet( *it_conf , *it_pos );
+00183                                 std::string buf;
+00184                                 std::string buf2;
+00185                                 (*it_conc)->getDebugString( buf );
+00186                                 conflit->getDebugString( buf2 );
+00187 #endif
+00188                                 //TRACE("\nCONCLUSION DE LA REGLE: \n   ASSERTION: %s   VALEURS: %s\n", buf, buf2);
+00190                                 it_conc++;
+00191                         }
+00192                         it_conf++;
+00193                         pos++;
+00194                 }
+00195         }
+
+

+ + + + +
+ + + + + + + + + + +
void NLAILOGIC::CVarSet::addVar IBaseVar  )  [inherited]
+
+ + + + + +
+   + + +

+ +

+Definition at line 144 of file varset.cpp. +

+References NLAIC::IBasicType::clone(). +

+Referenced by NLAISCRIPT::COperatorClass::addFirstOrderCond(), backWard(), NLAISCRIPT::COperatorClass::buildLogicTables(), NLAISCRIPT::COperatorClass::initialiseFactBase(), NLAILOGIC::CVarSet::unify(), and unifyBack(). +

+

00145         {
+00146                 IBaseVar *tmp = (IBaseVar *) var->clone();
+00147                 _Vars.push_back( tmp );
+00148         }
+
+

+ + + + +
+ + + + + + + + + +
CValueSet * NLAILOGIC::CVarSet::asCValueSet  )  [inherited]
+
+ + + + + +
+   + + +

+ +

+Definition at line 290 of file varset.cpp. +

+Referenced by NLAILOGIC::CFirstOrderAssert::addFact(), and unifyBack(). +

+

00291         {
+00292                 CValueSet *result = new CValueSet( _Vars );
+00293                 return result;
+00294         }
+
+

+ + + + +
+ + + + + + + + + + +
void NLAILOGIC::CRule::backward std::list< CValueSet * > *   ) 
+
+ + + + + +
+   + + +

+ +

+Definition at line 387 of file rule.cpp. +

+

00388         {
+00389                 std::vector<IBaseBoolType *>::iterator it_cond = _Conds.begin();
+00390                 while ( it_cond != _Conds.end() )
+00391                 {
+00392                         std::list<CValueSet *>::iterator it_vs = vs->begin();
+00393                         while ( it_vs != vs->end() )
+00394                         {
+00395 //                              ( (CFirstOrderAssert *) *it_cond )->backward( *it_vs );
+00396                                 it_vs++;
+00397                         }
+00398                         it_cond++;
+00399                 }
+00400         }
+
+

+ + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + + +
CVarSet* NLAILOGIC::CRule::backward CFactPattern,
std::vector< sint32 > & ,
std::vector< sint32 > & 
+
+ + + + + +
+   + + +

+

+

+ + + + +
+ + + + + + + + + + +
CVarSet * NLAILOGIC::CRule::backWard CFactPattern  ) 
+
+ + + + + +
+   + + +

+ +

+Definition at line 280 of file rule.cpp. +

+References NLAILOGIC::CVarSet::addVar(), NLAILOGIC::CFactPattern::getAssert(), NLAILOGIC::CVarSet::getVars(), index, and sint32. +

+

00281         {
+00282                 // Vecteur temporaire des variables
+00283                 CVarSet *tmp_vars = new CVarSet;
+00284                 for (sint32 i = 0; i < (sint32) _Vars.size() ; i++)
+00285                         tmp_vars->addVar( _Vars[i] );
+00286 
+00287                 // Trouver l'assertion dans la conclusion
+00288                 std::vector<IBaseAssert *>::iterator it_a = _Concs.begin();
+00289                 std::vector< std::vector<sint32> >::iterator it_p = _PosVarsConc.begin();
+00290                 while ( it_a != _Concs.end() && (*it_a) != fp->getAssert() )
+00291                 {
+00292                         it_a++;
+00293                         it_p++;
+00294                 }
+00295                 if ( it_a == _Concs.end() )
+00296                         return NULL;
+00297 
+00298                 std::vector<sint32> pos_list = *it_p;
+00299                 std::vector<sint32>::iterator it_pos = pos_list.begin();
+00300         
+00301                 // Unification avec la valeur des variables
+00302                 sint32 index = 0;
+00303                 while ( it_pos != pos_list.end() )
+00304                 {
+00305                         if ( (*tmp_vars->getVars())[*it_pos]->getValue() == NULL)
+00306                                 (*tmp_vars)[*it_pos]->setValue( (*fp)[index]->getValue() );
+00307                         else
+00308                         {
+00309                                 return NULL;
+00310                         }
+00311                         it_pos++;
+00312                         index++;
+00313                 }
+00314                 return tmp_vars;
+00315         }
+
+

+ + + + +
+ + + + + + + + + + +
TQueue NLAIAGENT::IObjectIA::canProcessMessage const IVarName  )  [virtual, inherited]
+
+ + + + + +
+   + + +

+The method canProcessMessage(const IVarName &msgName) allow us to know if agent can preocess given by msgName.

+TQueue contain the liste of method (same as a run(msg)) that coud process the msg. +

+Reimplemented in NLAIAGENT::CLocalAgentMail. +

+Definition at line 350 of file baseai.cpp. +

+References NLAIAGENT::TQueue. +

+Referenced by NLAIAGENT::CLocalAgentMail::canProcessMessage(). +

+

00351         {
+00352                 return TQueue();
+00353         }
+
+

+ + + + +
+ + + + + + + + + +
std::vector<IBaseAssert *>& NLAILOGIC::CClause::CClause::getAssert  )  [inherited]
+
+ + + + + +
+   + + +

+

+

+ + + + +
+ + + + + + + + + + +
void NLAILOGIC::CClause::CClause::init NLAIAGENT::IObjectIA  )  [inherited]
+
+ + + + + +
+   + + +

+

+

+ + + + +
+ + + + + + + + + +
const NLAIC::IBasicType * NLAILOGIC::CRule::clone  )  const [virtual]
+
+ + + + + +
+   + + +

+This function allow a pointer copy, that mean that the new class have the sam attributs caracteristics as the owne. +

+Reimplemented from NLAILOGIC::CClause. +

+Definition at line 88 of file rule.cpp. +

+References CRule(). +

+Referenced by init(). +

+

00089         {
+00090                 NLAIC::IBasicInterface *m = new CRule(*this);
+00091                 return m;
+00092         }
+
+

+ + + + +
+ + + + + + + + + +
sint32 NLAIC::IPointerGestion::decRef  )  [inline, inherited]
+
+ + + + + +
+   + + +

+Decrement the reference of an object. +

+ +

+Definition at line 93 of file abstract_interface.h. +

+References NLAIC::IPointerGestion::_Ref, and sint32. +

+Referenced by NLAIC::IPointerGestion::release(), and NLAIAGENT::CAgentTimerHandle::~CAgentTimerHandle(). +

+

00094                 {
+00095                         return --_Ref;
+00096                 }
+
+

+ + + + +
+ + + + + + + + + + +
sint32 NLAILOGIC::CClause::findAssert IBaseAssert  )  [protected, inherited]
+
+ + + + + +
+   + + +

+ +

+Definition at line 110 of file clause.cpp. +

+References NLAILOGIC::CClause::_Asserts, NLAILOGIC::IBaseAssert::getName(), and sint32. +

+Referenced by addConc(), and NLAILOGIC::CClause::addCond(). +

+

00111         {
+00112                 if ( a )
+00113                         for ( sint32 i = 0; i < (sint32)_Asserts.size(); i++ )
+00114                         {
+00115                                 if ( _Asserts[i]->getName() == a->getName() )
+00116                                 {
+00117                                         return i;
+00118                                 }
+00119                         }
+00120 
+00121                 return -1;
+00122         }
+
+

+ + + + +
+ + + + + + + + + + +
void NLAILOGIC::CRule::forward CVarSet  ) 
+
+ + + + + +
+   + + +

+ +

+Definition at line 160 of file rule.cpp. +

+

00161         {
+00162                 
+00163         }
+
+

+ + + + +
+ + + + + + + + + +
virtual std::string NLAIC::IPointerGestion::getClassName  )  [inline, virtual, inherited]
+
+ + + + + +
+   + + +

+ +

+Implements NLMISC::IClassable. +

+Reimplemented in NLAIC::CIdentType. +

+Definition at line 116 of file abstract_interface.h. +

+Referenced by NLAISCRIPT::CAgentClass::isClassInheritedFrom(). +

+

00117                 {
+00118                         return std::string("<unnamed>");
+00119                 }
+
+

+ + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + + +
void NLAILOGIC::CRule::getConcPosList sint32 ,
sint32 ,
std::vector< sint32 > & 
[private]
+
+ + + + + +
+   + + +

+

+

+ + + + +
+ + + + + + + + + + +
void NLAILOGIC::CRule::getDebugString std::string &   )  const [virtual]
+
+ + + + + +
+   + + +

+This is a Debug function, text is an character pointer to receive the debug text output, the debug text containe all think sensible to interset user. +

+Reimplemented from NLAILOGIC::CClause. +

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

+References sint32. +

+

00240         {               
+00241                 txt += "CRule\n - Conditions: ";
+00242                 std::vector<IBaseBoolType *>::const_iterator it_c = _Conds.begin();
+00243                 while ( it_c != _Conds.end() )
+00244                 {
+00245                         std::string buf;
+00246                         ( *it_c )->getDebugString( buf );
+00247                         txt += "    - ";
+00248                         txt += buf;
+00249                         it_c++;
+00250                 }
+00251 
+00252                 txt += "\n - Conclusions: ";
+00253                 
+00254                 std::vector<IBaseAssert *>::const_iterator it_cc = _Concs.begin();
+00255 
+00256                 while ( it_cc != _Concs.end() )
+00257                 {
+00258                         std::string buf;
+00259                         ( *it_cc )->getDebugString( buf );
+00260                         txt += "    - ";
+00261                         txt += buf;
+00262                         it_cc++;
+00263                 }
+00264 
+00265                 txt += "\n - Variables ";
+00266                 for (sint32 i = 0; i < (sint32)_Vars.size(); i++ )
+00267                 {
+00268                         std::string buf;
+00269                         _Vars[ i ]->getDebugString( buf );
+00270                         txt += "    - ";
+00271                         txt += buf;
+00272                 }
+00273         }
+
+

+ + + + +
+ + + + + + + + + +
virtual const std::string NLAIC::IBasicType::getInfo  )  [inline, virtual, inherited]
+
+ + + + + +
+   + + +

+ +

+Definition at line 292 of file abstract_interface.h. +

+References NLAIC::IBasicType::getDebugString(), and s. +

+

00293                 {
+00294                         std::string s;
+00295                         getDebugString(s);
+00296                         return s;
+00297                 }
+
+

+ + + + +
+ + + + + + + + + +
std::list< CClause * > * NLAILOGIC::CClause::getInputs  )  [inherited]
+
+ + + + + +
+   + + +

+ +

+Definition at line 368 of file clause.cpp. +

+

00369         {
+00370                 return new std::list<CClause *>;
+00371         }
+
+

+ + + + +
+ + + + + + + + + + + + + + + + + + + +
std::string NLAIAGENT::IObjectIA::getMethodeMemberDebugString sint32 ,
sint32 
const [virtual, inherited]
+
+ + + + + +
+   + + +

+The methode getMethodeMemberDebugString(sint32 heritance, sint32 index) return a string that define the name and the argument of the method +

+Reimplemented in NLAIAGENT::CAgentScript. +

+Definition at line 311 of file baseai.cpp. +

+References sint32. +

+Referenced by NLAISCRIPT::CCallHeapMethodi::getDebugResult(), NLAISCRIPT::CCallStackMethodi::getDebugResult(), NLAISCRIPT::CCallMethodi::getDebugResult(), NLAISCRIPT::CLibHeapMemberMethod::getDebugResult(), NLAISCRIPT::CLibStackNewMemberMethod::getDebugResult(), NLAISCRIPT::CLibStackMemberMethod::getDebugResult(), NLAISCRIPT::CLibCallMethodi::getDebugResult(), NLAISCRIPT::CLibCallInheritedMethod::getDebugResult(), NLAISCRIPT::CLibCallMethod::getDebugResult(), NLAISCRIPT::CLibMemberMethodi::getDebugResult(), NLAISCRIPT::CLibMemberInheritedMethod::getDebugResult(), and NLAISCRIPT::CLibMemberMethod::getDebugResult(). +

+

00312         {
+00313                 switch(id)
+00314                 {
+00315                 case 0:
+00316                         {
+00317                                 return std::string("IObjectIA::sendMessage(IMessage)");
+00318                         }                       
+00319                         break;
+00320                 case 1:                 
+00321                         break;
+00322                 case 2:                 
+00323                         return std::string("IObjectIA::run()");
+00324                         break;
+00325 
+00326                 case 3:
+00327                         {                               
+00328                                 return std::string("IObjectIA::getStaticMember(Integer)");                              
+00329                         }
+00330                 }
+00331                 return std::string("Mathod_?????(Param_?????)");
+00332         }
+
+

+ + + + +
+ + + + + + + + + +
sint32 NLAIAGENT::IObjetOp::getMethodIndexSize  )  const [virtual, inherited]
+
+ + + + + +
+   + + +

+getMethodIndexSize define the nomber of method define in the class. +

+Reimplemented from NLAIAGENT::IObjectIA. +

+Reimplemented in NLAIAGENT::IVector, NLAIAGENT::INombreDefine, NLAIAGENT::CPairType, NLAIAGENT::IBaseGroupType, NLAIAGENT::CVectorGroupType, NLAIAGENT::IListBasicManager, NLAIAGENT::CMessageScript, NLAIAGENT::IMessageBase, NLAIAGENT::CAgentOperation, NLAIFUZZY::CFuzzyVar, NLAILOGIC::CFact, NLAILOGIC::CGoal, NLAILOGIC::CInternalGoal, and NLAILOGIC::IBaseVar. +

+Definition at line 93 of file agent_operator.cpp. +

+References NLAIAGENT::IObjetOp::op_last, and sint32. +

+

00094         {
+00095                 return IObjectIA::getMethodIndexSize() + op_last;
+00096         }
+
+

+ + + + +
+ + + + + + + + + +
virtual IObjetOp* NLAIAGENT::IObjetOp::getNeg  )  const [inline, virtual, inherited]
+
+ + + + + +
+   + + +

+ +

+Definition at line 165 of file agent_operator.h. +

+References NLAIC::IBasicType::clone(), and NLAIAGENT::IObjetOp::neg(). +

+Referenced by NLAISCRIPT::CNegOpCode::runOpCode(). +

+

00166                 {
+00167                         IObjetOp *o = (IObjetOp *)clone();                      
+00168                         o->neg();
+00169                         return o;
+00170                 }
+
+

+ + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + + +
void NLAILOGIC::CRule::getPosListBackward sint32 ,
sint32 ,
std::vector< sint32 > & 
+
+ + + + + +
+   + + +

+ +

+Definition at line 446 of file rule.cpp. +

+References sint32. +

+

00447         {
+00448                 std::vector<sint32>::iterator it_conc = _PosVarsConc[ no_conc ].begin();
+00449                 while ( it_conc != _PosVarsConc[ no_conc ].end() )
+00450                 {
+00451                         std::vector<sint32>::iterator it_cond = _PosVarsCond[ no_cond ].begin();
+00452                         while ( it_cond != _PosVarsCond[ no_cond ].end() )
+00453                         {
+00454                                 if ( (*it_conc) == (*it_cond) )
+00455                                 {
+00456                                         cond_pos.push_back( *it_cond );
+00457                                 }
+00458                                 it_cond++;
+00459                         }
+00460                         it_conc++;
+00461                 }
+00462         }
+
+

+ + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + + +
void NLAILOGIC::CRule::getPosListForward sint32 ,
sint32 ,
std::vector< sint32 > & 
+
+ + + + + +
+   + + +

+ +

+Definition at line 465 of file rule.cpp. +

+References sint32. +

+

00466         {
+00467                 std::vector<sint32>::iterator it_cond = _PosVarsCond[ no_cond ].begin();
+00468                 while ( it_cond != _PosVarsCond[ no_cond ].end() )
+00469                 {
+00470                         std::vector<sint32>::iterator it_conc = _PosVarsConc[ no_conc ].begin();
+00471                         while ( it_conc != _PosVarsConc[ no_conc ].end() )
+00472                         {
+00473                                 if ( (*it_cond) == (*it_conc) )
+00474                                 {
+00475                                         conc_pos.push_back( *it_conc );
+00476                                 }
+00477                                 it_conc++;
+00478                         }
+00479                         it_cond++;
+00480                 }
+00481         } 
+
+

+ + + + +
+ + + + + + + + + +
const sint32& NLAIC::IPointerGestion::getRef  )  const [inline, inherited]
+
+ + + + + +
+   + + +

+get the refence count. +

+ +

+Definition at line 99 of file abstract_interface.h. +

+References NLAIC::IPointerGestion::_Ref, and sint32. +

+Referenced by NLAIAGENT::CAgentTimerHandle::~CAgentTimerHandle(). +

+

00100                 {
+00101                         return _Ref;
+00102                 }
+
+

+ + + + +
+ + + + + + + + + + +
const IObjectIA* NLAIAGENT::IObjectIA::getStaticMember const IVarName compName  )  const [inline, inherited]
+
+ + + + + +
+   + + +

+to get the pointer of a given components referened by an string. +

+Definition at line 261 of file baseai.h. +

+References NLAIAGENT::IObjectIA::getStaticMember(), and NLAIAGENT::IObjectIA::getStaticMemberIndex(). +

+

00262                 {
+00263                         return getStaticMember(getStaticMemberIndex(compName));
+00264                 }
+
+

+ + + + +
+ + + + + + + + + + +
const IObjectIA * NLAIAGENT::IObjectIA::getStaticMember sint32   )  const [virtual, inherited]
+
+ + + + + +
+   + + +

+to get the pointer of a given components referened by an index. +

+Reimplemented in NLAIAGENT::CLocalAgentMail, NLAIAGENT::CAgentScript, NLAIAGENT::CMessageScript, and NLAISCRIPT::CAgentClass. +

+Definition at line 193 of file baseai.cpp. +

+References sint32. +

+Referenced by NLAISCRIPT::CCompilateur::affectationMember(), NLAIAGENT::CComponentHandle::getComponent(), NLAISCRIPT::CLdbMemberiOpCode::getDebugResult(), NLAISCRIPT::CLdbHeapMemberiOpCode::getDebugResult(), NLAISCRIPT::CLdbStackMemberiOpCode::getDebugResult(), NLAISCRIPT::CCallStackNewMethodi::getDebugResult(), NLAISCRIPT::CCallHeapMethodi::getDebugResult(), NLAISCRIPT::CCallStackMethodi::getDebugResult(), NLAISCRIPT::CCallMethodi::getDebugResult(), NLAISCRIPT::CLibHeapMemberMethod::getDebugResult(), NLAISCRIPT::CLibStackNewMemberMethod::getDebugResult(), NLAISCRIPT::CLibStackMemberMethod::getDebugResult(), NLAISCRIPT::CLibCallMethodi::getDebugResult(), NLAISCRIPT::CLibMemberMethodi::getDebugResult(), NLAISCRIPT::CLoadHeapObject::getObject(), NLAISCRIPT::CLoadStackObject::getObject(), NLAISCRIPT::CLoadSelfObject::getObject(), NLAIAGENT::IObjectIA::getStaticMember(), NLAIAGENT::CLocalAgentMail::getStaticMember(), NLAISCRIPT::CCompilateur::getValidateHierarchyBase(), NLAISCRIPT::CCompilateur::isValidateVarName(), NLAISCRIPT::CCodeBrancheRunDebug::printVariable(), NLAIAGENT::IObjectIA::runMethodeMember(), NLAISCRIPT::CLdbMemberiOpCode::runOpCode(), NLAISCRIPT::CLdbHeapMemberiOpCode::runOpCode(), NLAISCRIPT::CLdbStackMemberiOpCode::runOpCode(), NLAISCRIPT::CCallHeapMethodi::runOpCode(), NLAISCRIPT::CCallStackMethodi::runOpCode(), NLAISCRIPT::CCallStackNewMethodi::runOpCode(), NLAISCRIPT::CCallMethodi::runOpCode(), NLAISCRIPT::CLibHeapMemberMethod::runOpCode(), NLAISCRIPT::CLibStackNewMemberMethod::runOpCode(), NLAISCRIPT::CLibStackMemberMethod::runOpCode(), NLAISCRIPT::CLibCallMethodi::runOpCode(), NLAISCRIPT::CLibMemberMethodi::runOpCode(), NLAISCRIPT::CAffHeapMemberiOpCode::runOpCode(), and NLAISCRIPT::CAffMemberiOpCode::runOpCode(). +

+

00194         {
+00195                 return NULL;
+00196         }
+
+

+ + + + +
+ + + + + + + + + + +
sint32 NLAIAGENT::IObjectIA::getStaticMemberIndex const IVarName  )  const [virtual, inherited]
+
+ + + + + +
+   + + +

+to get the index of a given components name. +

+Reimplemented in NLAIAGENT::CLocalAgentMail, NLAIAGENT::CAgentScript, and NLAIAGENT::CMessageScript. +

+Definition at line 188 of file baseai.cpp. +

+References sint32. +

+Referenced by NLAISCRIPT::CCompilateur::affectation(), NLAIAGENT::CComponentHandle::getComponent(), NLAIAGENT::IObjectIA::getStaticMember(), NLAIAGENT::CLocalAgentMail::getStaticMemberIndex(), NLAISCRIPT::CCompilateur::getValidateHierarchyBase(), NLAISCRIPT::CCompilateur::isValidateVarName(), NLAISCRIPT::CCodeBrancheRunDebug::printVariable(), NLAISCRIPT::CCompilateur::processingVar(), NLAISCRIPT::CConstraintStackComp::run(), and NLAIAGENT::IObjectIA::setStaticMember(). +

+

00189         {
+00190                 return -1;
+00191         }
+
+

+ + + + +
+ + + + + + + + + +
sint32 NLAIAGENT::IObjectIA::getStaticMemberSize  )  const [virtual, inherited]
+
+ + + + + +
+   + + +

+Static member is the component that the agent is create and die with. getStaticMemberSize to get the size of the static member components +

+Reimplemented in NLAIAGENT::CLocalAgentMail, NLAIAGENT::CAgentScript, NLAIAGENT::CMessageScript, NLAISCRIPT::IClassInterpret, and NLAISCRIPT::CAgentClass. +

+Definition at line 180 of file baseai.cpp. +

+References NLAIC::IBasicType::getType(), sint32, and NLAIC::stringGetBuild(). +

+Referenced by NLAIAGENT::CLocalAgentMail::getStaticMemberSize(). +

+

00181         {
+00182                 std::string text;
+00183                 text = NLAIC::stringGetBuild("sint32 IObjectIA::getStaticMemberSize() note implementaited for the '%s' interface",(const char *)getType());
+00184                 throw NLAIE::CExceptionNotImplemented(text.c_str());
+00185                 return 0;       
+00186         }
+
+

+ + + + +
+ + + + + + + + + +
const NLAIC::CIdentType & NLAILOGIC::CRule::getType  )  const [virtual]
+
+ + + + + +
+   + + +

+getType return a unique string how represente the class, it can be the name of the class. This function is used for the sytem regstry class (see the definition of the template class Gen::CRegistry). +

+Reimplemented from NLAILOGIC::CVarSet. +

+Definition at line 234 of file rule.cpp. +

+References IdRule. +

+

00235         {
+00236                 return IdRule;
+00237         }
+
+

+ + + + +
+ + + + + + + + + +
std::list< IObjetOp * > * NLAILOGIC::CVarSet::getValues  )  [inherited]
+
+ + + + + +
+   + + +

+ +

+Definition at line 272 of file varset.cpp. +

+References sint32. +

+Referenced by NLAILOGIC::CFirstOrderAssert::addFact(), NLAILOGIC::CFact::CFact(), and unifyBack(). +

+

00273         {
+00274                 std::list<IObjetOp *> *result = new std::list<IObjetOp *>;
+00275 
+00276                 IObjetOp *tmp_val;
+00277 
+00278                 for ( sint32 i = 0; i < (sint32)_Vars.size(); i++ )
+00279                 {
+00280                         tmp_val = _Vars[ i ];
+00281                         IObjetOp *val;
+00282                         if ( (val = _Vars[ i ]->getValue()) )
+00283                                 result->push_back( val );
+00284                 }
+00285 
+00286                 return result;
+00287         }
+
+

+ + + + +
+ + + + + + + + + +
std::vector< IBaseVar * > * NLAILOGIC::CVarSet::getVars  )  [virtual, inherited]
+
+ + + + + +
+   + + +

+ +

+Definition at line 165 of file varset.cpp. +

+Referenced by addConc(), NLAILOGIC::CClause::addCond(), backWard(), NLAISCRIPT::COperatorClass::compileFactPattern(), NLAILOGIC::CFirstOrderOperator::compileFactPattern(), and init(). +

+

00166         {
+00167                 std::vector<IBaseVar *> *result= new std::vector<IBaseVar *>;
+00168 
+00169                 std::vector<IBaseVar *>::iterator it_var = _Vars.begin();
+00170                 while ( it_var != _Vars.end() )
+00171                 {
+00172                         result->push_back( (IBaseVar *) (*it_var)->clone() );
+00173                         it_var++;
+00174                 }
+00175                 return result;
+00176         }
+
+

+ + + + +
+ + + + + + + + + +
void NLAIC::IPointerGestion::incRef  )  [inline, inherited]
+
+ + + + + +
+   + + +

+Inc a reference. We use this when we have to conserve a pointer memeory for exemple in a list. +

+ +

+Definition at line 80 of file abstract_interface.h. +

+References NLAIC::IPointerGestion::_Ref. +

+Referenced by NLAIAGENT::CSeqFsmScript::activate(), NLAILOGIC::CFactBase::addAssert(), NLAIAGENT::IAgentComposite::addChild(), NLAILOGIC::IBaseAssert::addInput(), NLAILOGIC::CBoolOperator::addPostcondition(), NLAILOGIC::CBoolOperator::addPrecondition(), NLAILOGIC::CInternalGoal::addPredecessor(), NLAILOGIC::CGoal::addPredecessor(), NLAIFUZZY::CFuzzyVar::addSet(), NLAISCRIPT::CCompilateur::affectation(), NLAILOGIC::CFact::asValueSet(), NLAIAGENT::CAgentWatchTimer::attach(), NLAISCRIPT::CCompilateur::buildObject(), NLAISCRIPT::CAgentClass::buildVMethode(), NLAIAGENT::CAgentOperation::CAgentOperation(), NLAIAGENT::CAgentTimerHandle::CAgentTimerHandle(), NLAISCRIPT::CCompilateur::callFunction(), NLAISCRIPT::CClassInterpretFactory::CClassInterpretFactory(), NLAISCRIPT::CCodeBrancheRunDebug::CCodeBrancheRunDebug(), NLAISCRIPT::CCompilateur::CCompilateur(), NLAISCRIPT::CFactorType::CFactorType(), NLAISCRIPT::CFunctionTag::CFunctionTag(), NLAIAGENT::COperatorScript::checkTrigMsg(), NLAIC::CIdentType::CIdentType(), NLAIAGENT::CIdMethod::CIdMethod(), NLAIAGENT::CKeyObject::CKeyObject(), NLAISCRIPT::CFindRunMsg::clone(), NLAISCRIPT::CObjectUnknown::clone(), NLAISCRIPT::CConstraintStackComp::clone(), NLAISCRIPT::CConstraintFindRun::clone(), NLAISCRIPT::CConstraintMethode::clone(), NLAILINK::IOTrace::clone(), NLAISCRIPT::CMethodeName::CMethodeName(), NLAISCRIPT::CAgentClass::CMethodType::CMethodType(), NLAISCRIPT::CObjectUnknown::CObjectUnknown(), NLAIAGENT::CPairType::CPairType(), NLAISCRIPT::CAgentClass::createComponents(), NLAILOGIC::CValueSet::CValueSet(), NLAILOGIC::CVar::CVar(), NLAILOGIC::CValueSet::forward(), NLAIAGENT::IMessageBase::IMessageBase(), NLAIAGENT::CAgentScript::initAgentScript(), NLAISCRIPT::CCompilateur::initMessageManager(), NLAISCRIPT::COperatorClass::isValidFonc(), NLAILOGIC::CValueSet::load(), NLAILOGIC::IBaseOperator::load(), NLAISCRIPT::CAgentClass::load(), NLAISCRIPT::CComponent::load(), NLAISCRIPT::CMethodeName::load(), NLAIAGENT::CVectorGroupType::operator+(), NLAIAGENT::CGroupType::operator+(), NLAISCRIPT::CPramContainer::operator+=(), NLAIAGENT::IMessageBase::operator=(), NLAIAGENT::CKeyObject::operator=(), NLAISCRIPT::CAgentClass::CMethodType::operator=(), NLAISCRIPT::CFunctionTag::operator=(), NLAIAGENT::CIdMethod::operator=(), NLAISCRIPT::CCompilateur::processingVar(), NLAIAGENT::CAgentScript::processMessages(), NLAISCRIPT::CCompilateur::pushParamExpression(), NLAISCRIPT::CConstraintFindRun::run(), NLAIAGENT::IBasicAgent::run(), NLAIAGENT::CAgentScript::runAskGetValue(), NLAIAGENT::IAgent::runChildren(), NLAIAGENT::CMainAgentScript::runExec(), NLAIAGENT::CAgentScript::runInitComponent(), NLAIAGENT::CAgentOperation::runMethodBase(), NLAIAGENT::CAgentWatchTimer::runMethodBase(), NLAIAGENT::CAgentScript::runMethodBase(), NLAIAGENT::CActorScript::runMethodBase(), NLAIAGENT::IMessageBase::runMethodeMember(), NLAIAGENT::IBaseGroupType::runMethodeMember(), NLAIAGENT::IBasicAgent::runMethodeMember(), NLAISCRIPT::CLdbRefOpCode::runOpCode(), NLAISCRIPT::CLdbMemberiOpCode::runOpCode(), NLAISCRIPT::CLdbHeapMemberiOpCode::runOpCode(), NLAISCRIPT::CLdbStackMemberiOpCode::runOpCode(), NLAISCRIPT::CCallStackMethodi::runOpCode(), NLAISCRIPT::CCallStackNewMethodi::runOpCode(), NLAISCRIPT::CLibStackNewMemberMethod::runOpCode(), NLAISCRIPT::CLibStackMemberMethod::runOpCode(), NLAISCRIPT::CAffOpCode::runOpCode(), NLAISCRIPT::CAddParamNameDebug::runOpCode(), NLAISCRIPT::CAffOpCodeDebug::runOpCode(), NLAISCRIPT::CAffHeapMemberiOpCode::runOpCode(), NLAISCRIPT::CAffMemberOpCode::runOpCode(), NLAISCRIPT::CAffMemberiOpCode::runOpCode(), NLAIAGENT::CAgentScript::runTellComponent(), NLAIAGENT::CAgentScript::runTellSetValue(), NLAISCRIPT::CMethodContextDebug::saveContext(), NLAISCRIPT::CMethodContext::saveContext(), NLAIAGENT::CAgentScript::sendBroadCast(), NLAIAGENT::IListManager::sendMessage(), NLAIAGENT::CAgentScript::sendMethodCompoment(), NLAIAGENT::CVolatilMemmory::sendUpdateMessage(), NLAISCRIPT::CFactorType::set(), NLAILOGIC::IBaseOperator::setGoal(), NLAISCRIPT::CCompilateur::setImediateVarNill(), NLAISCRIPT::CCompilateur::setMethodVar(), NLAISCRIPT::CCompilateur::setParamVarName(), NLAISCRIPT::CFunctionTag::setTypeObject(), NLAILOGIC::CVar::setValue(), NLAILOGIC::CValueSet::setValue(), NLAIAGENT::CAgentWatchTimer::tellBroker(), NLAISCRIPT::CCompilateur::typeOfMethod(), NLAILOGIC::CVar::unify(), NLAILOGIC::CValueSet::unify(), and NLAIAGENT::CAgentOperation::update(). +

+

00081                 {
+00082                         _Ref ++;
+00083                 }
+
+

+ + + + +
+ + + + + + + + + + +
void NLAILOGIC::CRule::init NLAIAGENT::IObjectIA  )  [virtual]
+
+ + + + + +
+   + + +

+Init method alows to init the attribut of an object. the maparmetre is in more time a list of IObjectIA. +

+Reimplemented from NLAIAGENT::IObjectIA. +

+Definition at line 197 of file rule.cpp. +

+References addConc(), clone(), NLAIAGENT::IBaseGroupType::getIterator(), NLAILOGIC::CVarSet::getVars(), NLAIAGENT::CConstIteratorContener::isInEnd(), params, NLAIC::IPointerGestion::release(), and sint32. +

+

00198         {
+00199 /*              if ( params->size() != 3 )
+00200                 {
+00201                         // TODO throw Exc::....
+00202                 }*/
+00203 
+00204                 // Conditions
+00205                 CClause *cond = (CClause *) ((IBaseGroupType *)params)->popFront();
+00206                 std::vector<IBaseVar *> *vars = cond->getVars();
+00207 
+00208                 int i;
+00209 
+00210                 for ( i = 0; i < (sint32)vars->size() ; i++ )
+00211                 {
+00212                         _Vars.push_back( (IBaseVar *) (* vars)[ i ]->clone() );
+00213                 }
+00214                 
+00215                 for ( i = 0; i < (sint32) vars->size() ; i++ )
+00216                         (*vars)[i]->release();
+00217                 delete vars;
+00218                 cond->release();
+00219 
+00220                 // Conclusions
+00221                 IBaseGroupType *concs = (IBaseGroupType *) ((IBaseGroupType *)params)->popFront();
+00222                 CIteratorContener it_fp = concs->getIterator();
+00223                 while ( !it_fp.isInEnd() )
+00224                 {
+00225                         CFactPattern *tmp = (CFactPattern *) ( it_fp ++)->clone();
+00226                         addConc( tmp);
+00227                         tmp->release();
+00228                         //it_fp++;
+00229                 }
+00230 
+00231                 concs->release();
+00232         }
+
+

+ + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + + +
virtual TQueue NLAIAGENT::IObjetOp::IObjetOp::isMember const IVarName,
const IVarName,
const IObjectIA
const [virtual, inherited]
+
+ + + + + +
+   + + +

+

+

+ + + + +
+ + + + + + + + + + + + + + + + + + + +
virtual CProcessResult NLAIAGENT::IObjetOp::IObjetOp::runMethodeMember sint32  index,
IObjectIA
[virtual, inherited]
+
+ + + + + +
+   + + +

+

+

+ + + + +
+ + + + + + + + + + +
sint32 NLAIAGENT::IObjectIA::isClassInheritedFrom const IVarName  )  const [virtual, inherited]
+
+ + + + + +
+   + + +

+isClassInheritedFrom(className) allow us to known if this class have a base class with the name className.

+If true the method return the range of the base class, this range is an arbitrary reference id define by the programmer or bay the scrypt. the false return is define by -1. +

+Reimplemented in NLAIAGENT::IVector, NLAIAGENT::CLocalAgentMail, NLAIAGENT::INombreDefine, NLAIAGENT::IBaseGroupType, and NLAIAGENT::CMessageScript. +

+Definition at line 246 of file baseai.cpp. +

+References sint32. +

+Referenced by NLAISCRIPT::CCompilateur::getValidateHierarchyBase(), NLAIAGENT::CLocalAgentMail::isClassInheritedFrom(), NLAIAGENT::CActorScript::Launch(), NLAIAGENT::CFsmScript::setTopLevel(), and NLAIAGENT::CActorScript::setTopLevel(). +

+

00247         {
+00248                 return -1;
+00249         }       
+
+

+ + + + +
+ + + + + + + + + + +
virtual bool NLAIAGENT::IBasicObjectIA::isEqual const IBasicObjectIA a  )  const [pure virtual, inherited]
+
+ + + + + +
+   + + +

+The bool operator == (const IBasicObjectIA &a) const member method call this function when class 'classType' have the same type of this class, programme have to assume the equality between the memebers of this class and the memeber of the class 'classType'. +

+Implemented in NLAIAGENT::CActor, NLAIAGENT::CActorScript, NLAIAGENT::IAgent, NLAIAGENT::IVector, NLAIAGENT::IAgentInput, NLAIAGENT::CLocalAgentMail, NLAIAGENT::INombre< tNombre >, NLAIAGENT::CStringType, NLAIAGENT::CPairType, NLAIAGENT::CGroupType, NLAIAGENT::CVectorGroupType, NLAIAGENT::CProxyAgentMail, NLAIAGENT::CAgentScript, NLAIAGENT::IListBasicManager, NLAIAGENT::IListManager, NLAIAGENT::CLocalMailBox, NLAIAGENT::CMessageScript, NLAIAGENT::IMessageBase, NLAIAGENT::CObjectIdent, NLAIAGENT::CObjectType, NLAIAGENT::CAgentOperation, NLAIAGENT::CHashTimerManager, NLAIAGENT::CVolatilMemmory, NLAIAGENT::CFsmScript, NLAIAGENT::CSeqFsmScript, NLAIAGENT::COperatorScript, NLAIAGENT::INombre< double >, NLAIAGENT::INombre< uint16 >, NLAIAGENT::INombre< float >, NLAIAGENT::INombre< sint8 >, NLAIAGENT::INombre< uint64 >, NLAIAGENT::INombre< sint16 >, NLAIAGENT::INombre< uint8 >, NLAIAGENT::INombre< uint32 >, and NLAIAGENT::INombre< sint32 >. +

+Referenced by NLAIAGENT::CAgentOperation::isEqual(), NLAIAGENT::IMessageBase::isEqual(), NLAIAGENT::IListBasicManager::isEqual(), NLAIAGENT::CLocalAgentMail::isEqual(), NLAIAGENT::IAgentInput::isEqual(), and NLAIAGENT::IBasicObjectIA::operator==().

+

+ + + + +
+ + + + + + + + + + +
bool NLAILOGIC::CVarSet::isEqual const NLAIAGENT::IBasicObjectIA a  )  const [inherited]
+
+ + + + + +
+   + + +

+ +

+Reimplemented in NLAILOGIC::CFactPattern. +

+Definition at line 131 of file varset.cpp. +

+References sint32. +

+

00132         {
+00133 /*              if ( ! ( _Assert == ((CVarSet &)a)._Assert ) )
+00134                         return false;
+00135 */
+00136                 for (sint32 i = 0; i < (sint32)_Vars.size() ; i++ )
+00137                 {       
+00138                         if (! ( ( *_Vars[ i ] ) == ( *((CVarSet &) a)._Vars[i]) ))
+00139                                 return false;
+00140                 }
+00141                 return true;
+00142         }
+
+

+ + + + +
+ + + + + + + + + + +
bool NLAILOGIC::CVarSet::isEqual const CVarSet a  )  const [virtual, inherited]
+
+ + + + + +
+   + + +

+ +

+Definition at line 126 of file varset.cpp. +

+Referenced by NLAILOGIC::CVarSet::operator!=(). +

+

00127         {
+00128                 return false;
+00129         }
+
+

+ + + + +
+ + + + + + + + + +
bool NLAIAGENT::IObjectIA::isLocal  )  [virtual, inherited]
+
+ + + + + +
+   + + +

+If the result is true the object is loclal else its a representation of an object on the server. By the method return true. +

+ +

+Definition at line 356 of file baseai.cpp. +

+

00357         {
+00358                 return true;
+00359         }
+
+

+ + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + + +
TQueue NLAIAGENT::IObjectIA::isMember const IVarName,
const IVarName,
const IObjectIA
const [virtual, inherited]
+
+ + + + + +
+   + + +

+The method isMember(nameSubClass,methodName,param) return the best method correspondent to the search. remember we use the overloadind method.

+NameSubClass: if this pointer is not NULL then NameSubClass is the name of the base class were the method are defined.

+methodName: is the name of the class.

+param: is an IObjectIA where it defined the parametre of the method. lot of method use a IObjectIA vector object with an NLAIC::CIdentType as the the template argm. +

+Reimplemented in NLAIAGENT::IBasicAgent, NLAIAGENT::IVector, NLAIAGENT::CLocalAgentMail, NLAIAGENT::INombreDefine, NLAIAGENT::CPairType, NLAIAGENT::IBaseGroupType, NLAIAGENT::CVectorGroupType, NLAIAGENT::CProxyAgentMail, NLAIAGENT::CAgentTimerHandle, NLAIAGENT::IListBasicManager, NLAIAGENT::CMessageScript, and NLAIAGENT::IMessageBase. +

+Definition at line 206 of file baseai.cpp. +

+References _CONSTRUCTOR_, _RUN_, _SEND_, param, r, NLAIAGENT::IObjectIA::run(), and NLAIAGENT::TQueue. +

+Referenced by NLAIAGENT::CAgentWatchTimer::addAttrib(), NLAISCRIPT::CCompilateur::findMethode(), NLAISCRIPT::CAgentClass::isMember(), NLAIAGENT::CLocalAgentMail::isMember(), and NLAISCRIPT::CFindRunMsg::runOpCode(). +

+

00207         {               
+00208                 static CStringVarName send(_SEND_);
+00209                 static CStringVarName constructor(_CONSTRUCTOR_);
+00210                 static CStringVarName run(_RUN_);
+00211                 static CStringVarName statM("GetStaticMember");
+00212 
+00213                 if(*methodName == send)
+00214                 {
+00215                         TQueue r;                       
+00216                         CObjectType *c = new CObjectType(new NLAIC::CIdentType(NLAIC::CIdentType::VoidType));
+00217                         r.push(CIdMethod(0,0.0,NULL,c));
+00218                         return r;
+00219                 }
+00220                 else
+00221                 if(*methodName == constructor && !((const NLAISCRIPT::CParam &)param).size())
+00222                 {
+00223                         TQueue r;
+00224                         CObjectType *c = new CObjectType(new NLAIC::CIdentType(NLAIC::CIdentType::VoidType));
+00225                         r.push(CIdMethod(1,0.0,NULL,c));
+00226                         return r;
+00227                 }
+00228                 else
+00229                 if(*methodName == run && !((const NLAISCRIPT::CParam &)param).size())
+00230                 {
+00231                         TQueue r;
+00232                         CObjectType *c = new CObjectType(new NLAIC::CIdentType(NLAIC::CIdentType::VoidType));
+00233                         r.push(CIdMethod(2,0.0,NULL,c));
+00234                         return r;                       
+00235                 }
+00236                 if(*methodName == statM && ((const NLAISCRIPT::CParam &)param).size())
+00237                 {
+00238                         TQueue r;
+00239                         CObjectType *c = new CObjectType(new NLAIC::CIdentType(*IAgent::IdAgent));
+00240                         r.push(CIdMethod(3,0.0,NULL,c));
+00241                         return r;                       
+00242                 }
+00243                 return TQueue();
+00244         }
+
+

+ + + + +
+ + + + + + + + + +
bool NLAILOGIC::CClause::isTrue  )  const [virtual, inherited]
+
+ + + + + +
+   + + +

+throw (NLAIE::CExceptionNotImplemented) +

+ +

+Reimplemented from NLAILOGIC::CVarSet. +

+Definition at line 275 of file clause.cpp. +

+References NLAILOGIC::CClause::_NbValid. +

+Referenced by NLAILOGIC::CClause::operator!(), NLAILOGIC::CClause::operator!=(), and NLAILOGIC::CClause::operator==(). +

+

00276         {
+00277                 return ( _NbValid > 0 );
+00278         }
+
+

+ + + + +
+ + + + + + + + + +
bool NLAILOGIC::CVarSet::isUnified  )  [inherited]
+
+ + + + + +
+   + + +

+ +

+Definition at line 267 of file varset.cpp. +

+References NLAILOGIC::CVarSet::NbInstanciated. +

+

00268         {
+00269                 return ( NbInstanciated == 0 );
+00270         }
+
+

+ + + + +
+ + + + + + + + + + +
void NLAILOGIC::CVarSet::load NLMISC::IStream is  )  [virtual, inherited]
+
+ + + + + +
+   + + +

+Load the class from a stream. +

+Implements NLAIC::IBasicInterface. +

+Definition at line 84 of file varset.cpp. +

+References NLMISC::IStream::serial(), and sint32. +

+

00085         {
+00086                 IObjectIA::load(is);
+00087                 sint32 nb_vars;
+00088                 is.serial( nb_vars );
+00089 
+00090                 for (sint32 i = 0; i < nb_vars; i++ )
+00091                 {
+00092                         NLAIC::CIdentTypeAlloc id;
+00093                         is.serial( id );
+00094                         IBaseVar *tmp_var = (IBaseVar *)id.allocClass();
+00095                         _Vars.push_back( tmp_var );
+00096                 }
+00097         }
+
+

+ + + + +
+ + + + + + + + + +
sint32 NLAILOGIC::CClause::nbVars  )  [inherited]
+
+ + + + + +
+   + + +

+ +

+Definition at line 373 of file clause.cpp. +

+References sint32. +

+Referenced by NLAILOGIC::CValueSet::forward(). +

+

00374         {
+00375                 return _Vars.size();
+00376         }
+
+

+ + + + +
+ + + + + + + + + +
virtual IObjetOp& NLAIAGENT::IObjetOp::neg  )  [inline, virtual, inherited]
+
+ + + + + +
+   + + +

+throw (NLAIE::CExceptionNotImplemented) +

+ +

+Reimplemented in NLAIAGENT::DigitalType, NLAIAGENT::BorneDigitalType, NLAIAGENT::DDigitalType, NLAIAGENT::BorneDDigitalType, NLAIAGENT::IntegerType, NLAIAGENT::ShortIntegerType, NLAIAGENT::CharType, NLAIAGENT::UInt8Type, NLAIAGENT::UInt16Type, NLAIAGENT::UInt32Type, NLAIAGENT::UInt64Type, NLAIAGENT::INombre< tNombre >, NLAIAGENT::CGroupType, NLAIAGENT::CVectorGroupType, NLAIAGENT::CAgentOperation, NLAISCRIPT::CVarPStack, NLAISCRIPT::CVarPStackParam, NLAIAGENT::INombre< double >, NLAIAGENT::INombre< uint16 >, NLAIAGENT::INombre< float >, NLAIAGENT::INombre< sint8 >, NLAIAGENT::INombre< uint64 >, NLAIAGENT::INombre< sint16 >, NLAIAGENT::INombre< uint8 >, NLAIAGENT::INombre< uint32 >, and NLAIAGENT::INombre< sint32 >. +

+Definition at line 101 of file agent_operator.h. +

+References NLAIC::IBasicType::getType(), and NLAIC::stringGetBuild(). +

+Referenced by NLAIAGENT::IObjetOp::getNeg(), NLAISCRIPT::CVarPStackParam::neg(), NLAISCRIPT::CVarPStack::neg(), and NLAIAGENT::CAgentOperation::neg(). +

+

00102                 {
+00103                         std::string text;
+00104                         text = NLAIC::stringGetBuild("opertor <IObjectIA &neg()> note implemented for the '%s' interface",(const char *)getType());
+00105                         throw NLAIE::CExceptionNotImplemented(text.c_str());
+00106                         return *this;
+00107                 }               
+
+

+ + + + +
+ + + + + + + + + +
const NLAIC::IBasicType * NLAILOGIC::CRule::newInstance  )  const [virtual]
+
+ + + + + +
+   + + +

+This function allow a new instance, that mean that the class is a class factory. +

+Reimplemented from NLAILOGIC::CClause. +

+Definition at line 94 of file rule.cpp. +

+References CRule(). +

+

00095         {
+00096                 CRule *instance = new CRule();
+00097                 return instance;
+00098         }
+
+

+ + + + +
+ + + + + + + + + + +
virtual IObjetOp* NLAIAGENT::IObjetOp::operator * IObjetOp a  )  [inline, virtual, inherited]
+
+ + + + + +
+   + + +

+throw (NLAIE::CExceptionNotImplemented) +

+ +

+Definition at line 202 of file agent_operator.h. +

+

00203                 {
+00204                         return *this * *a;
+00205 
+00206                 }
+
+

+ + + + +
+ + + + + + + + + + +
virtual IObjetOp* NLAIAGENT::IObjetOp::operator * const IObjetOp  )  [inline, virtual, inherited]
+
+ + + + + +
+   + + +

+throw (NLAIE::CExceptionNotImplemented) +

+ +

+Reimplemented in NLAIAGENT::INombre< tNombre >, NLAIAGENT::INombre< double >, NLAIAGENT::INombre< uint16 >, NLAIAGENT::INombre< float >, NLAIAGENT::INombre< sint8 >, NLAIAGENT::INombre< uint64 >, NLAIAGENT::INombre< sint16 >, NLAIAGENT::INombre< uint8 >, NLAIAGENT::INombre< uint32 >, and NLAIAGENT::INombre< sint32 >. +

+Definition at line 147 of file agent_operator.h. +

+References NLAIC::IBasicType::getType(), and NLAIC::stringGetBuild(). +

+

00148                 {
+00149                         std::string text;
+00150                         text = NLAIC::stringGetBuild("opertor <virtual IObjetOp *operator * (const IObjetOp &a)  const> note implemented for the '%s' interface",(const char *)getType());
+00151                         throw NLAIE::CExceptionNotImplemented(text.c_str());
+00152                         return (IObjetOp *)this;
+00153                 }
+
+

+ + + + +
+ + + + + + + + + + +
virtual IObjetOp& NLAIAGENT::IObjetOp::operator *= IObjetOp a  )  [inline, virtual, inherited]
+
+ + + + + +
+   + + +

+throw (NLAIE::CExceptionNotImplemented) +

+ +

+Definition at line 182 of file agent_operator.h. +

+

00183                 {
+00184                         return *this *= *a;
+00185 
+00186                 }
+
+

+ + + + +
+ + + + + + + + + + +
virtual IObjetOp& NLAIAGENT::IObjetOp::operator *= const IObjetOp  )  [inline, virtual, inherited]
+
+ + + + + +
+   + + +

+throw (NLAIE::CExceptionNotImplemented) +

+ +

+Reimplemented in NLAIAGENT::INombre< tNombre >, NLAIAGENT::CAgentOperation, NLAIAGENT::INombre< double >, NLAIAGENT::INombre< uint16 >, NLAIAGENT::INombre< float >, NLAIAGENT::INombre< sint8 >, NLAIAGENT::INombre< uint64 >, NLAIAGENT::INombre< sint16 >, NLAIAGENT::INombre< uint8 >, NLAIAGENT::INombre< uint32 >, and NLAIAGENT::INombre< sint32 >. +

+Definition at line 110 of file agent_operator.h. +

+References NLAIC::IBasicType::getType(), and NLAIC::stringGetBuild(). +

+

00111                 {
+00112                         std::string text;
+00113                         text = NLAIC::stringGetBuild("opertor <IObjectIA &operator *= (const IObjectIA &a)> note implemented for the '%s' interface",(const char *)getType());
+00114                         throw NLAIE::CExceptionNotImplemented(text.c_str());
+00115                         return *this;
+00116                 }
+
+

+ + + + +
+ + + + + + + + + +
IObjetOp * NLAILOGIC::CClause::operator!  )  const [virtual, inherited]
+
+ + + + + +
+   + + +

+throw (NLAIE::CExceptionNotImplemented) +

+ +

+Reimplemented from NLAILOGIC::CVarSet. +

+Definition at line 264 of file clause.cpp. +

+References NLAILOGIC::CClause::isTrue(). +

+

00265         {
+00266 
+00267                 return new CBoolType( !isTrue() );
+00268         }
+
+

+ + + + +
+ + + + + + + + + + +
IObjetOp * NLAILOGIC::CClause::operator!= NLAIAGENT::IObjetOp a  )  const [virtual, inherited]
+
+ + + + + +
+   + + +

+throw (NLAIE::CExceptionNotImplemented) +

+ +

+Reimplemented from NLAILOGIC::CVarSet. +

+Definition at line 270 of file clause.cpp. +

+References NLAIAGENT::IObjetOp::isTrue(), and NLAILOGIC::CClause::isTrue(). +

+

00271         {
+00272                 return new CBoolType( isTrue() != a.isTrue() );
+00273         }
+
+

+ + + + +
+ + + + + + + + + + +
virtual IObjetOp* NLAIAGENT::IObjetOp::operator+ IObjetOp a  )  [inline, virtual, inherited]
+
+ + + + + +
+   + + +

+throw (NLAIE::CExceptionNotImplemented) +

+ +

+Reimplemented in NLAIAGENT::CGroupType, and NLAIAGENT::CVectorGroupType. +

+Definition at line 193 of file agent_operator.h. +

+

00194                 {
+00195                         return *this + *a;
+00196                 }
+
+

+ + + + +
+ + + + + + + + + + +
virtual IObjetOp* NLAIAGENT::IObjetOp::operator+ const IObjetOp  )  [inline, virtual, inherited]
+
+ + + + + +
+   + + +

+throw (NLAIE::CExceptionNotImplemented) +

+ +

+Reimplemented in NLAIAGENT::IVector, NLAIAGENT::INombre< tNombre >, NLAIAGENT::CGroupType, NLAIAGENT::CVectorGroupType, NLAIAGENT::INombre< double >, NLAIAGENT::INombre< uint16 >, NLAIAGENT::INombre< float >, NLAIAGENT::INombre< sint8 >, NLAIAGENT::INombre< uint64 >, NLAIAGENT::INombre< sint16 >, NLAIAGENT::INombre< uint8 >, NLAIAGENT::INombre< uint32 >, and NLAIAGENT::INombre< sint32 >. +

+Definition at line 131 of file agent_operator.h. +

+References NLAIC::IBasicType::getType(), and NLAIC::stringGetBuild(). +

+

00132                 {
+00133                         std::string text;
+00134                         text = NLAIC::stringGetBuild("opertor <virtual IObjetOp *operator + (const IObjetOp &a)  const> note implemented for the '%s' interface",(const char *)getType());
+00135                         throw NLAIE::CExceptionNotImplemented(text.c_str());
+00136                         return (IObjetOp *)this;
+00137                 }
+
+

+ + + + +
+ + + + + + + + + + +
virtual IObjetOp& NLAIAGENT::IObjetOp::operator+= IObjetOp a  )  [inline, virtual, inherited]
+
+ + + + + +
+   + + +

+throw (NLAIE::CExceptionNotImplemented) +

+ +

+Reimplemented in NLAIAGENT::IBaseGroupType. +

+Definition at line 173 of file agent_operator.h. +

+

00174                 {
+00175                         return *this += *a;
+00176                 }
+
+

+ + + + +
+ + + + + + + + + + +
virtual IObjetOp& NLAIAGENT::IObjetOp::operator+= const IObjetOp  )  [inline, virtual, inherited]
+
+ + + + + +
+   + + +

+add the operater by anather. +

+We do'nt make a pure virtual for this methods because we didn't wont to make development too many long, we prefer to put an exception to warn developer when this method is'nt define in the derivation class. +

+Reimplemented in NLAIAGENT::IVector, NLAIAGENT::INombre< tNombre >, NLAIAGENT::CStringType, NLAIAGENT::IBaseGroupType, NLAIAGENT::IListBasicManager, NLAIAGENT::CAgentOperation, NLAIAGENT::INombre< double >, NLAIAGENT::INombre< uint16 >, NLAIAGENT::INombre< float >, NLAIAGENT::INombre< sint8 >, NLAIAGENT::INombre< uint64 >, NLAIAGENT::INombre< sint16 >, NLAIAGENT::INombre< uint8 >, NLAIAGENT::INombre< uint32 >, and NLAIAGENT::INombre< sint32 >. +

+Definition at line 83 of file agent_operator.h. +

+References NLAIC::IBasicType::getType(), and NLAIC::stringGetBuild(). +

+

00084                 {                       
+00085                         std::string text;
+00086                         text = NLAIC::stringGetBuild("opertor <IObjectIA &operator += (const IObjectIA &a)> note implemented for the '%s' interface",(const char *)getType());
+00087                         throw NLAIE::CExceptionNotImplemented(text.c_str());
+00088                         return *this;
+00089                 }
+
+

+ + + + +
+ + + + + + + + + + +
virtual IObjetOp* NLAIAGENT::IObjetOp::operator- IObjetOp a  )  [inline, virtual, inherited]
+
+ + + + + +
+   + + +

+throw (NLAIE::CExceptionNotImplemented) +

+ +

+Reimplemented in NLAIAGENT::CGroupType, and NLAIAGENT::CVectorGroupType. +

+Definition at line 197 of file agent_operator.h. +

+

00198                 {
+00199                         return *this - *a;
+00200 
+00201                 }
+
+

+ + + + +
+ + + + + + + + + + +
virtual IObjetOp* NLAIAGENT::IObjetOp::operator- const IObjetOp  )  [inline, virtual, inherited]
+
+ + + + + +
+   + + +

+throw (NLAIE::CExceptionNotImplemented) +

+ +

+Reimplemented in NLAIAGENT::IVector, NLAIAGENT::INombre< tNombre >, NLAIAGENT::CGroupType, NLAIAGENT::CVectorGroupType, NLAIAGENT::INombre< double >, NLAIAGENT::INombre< uint16 >, NLAIAGENT::INombre< float >, NLAIAGENT::INombre< sint8 >, NLAIAGENT::INombre< uint64 >, NLAIAGENT::INombre< sint16 >, NLAIAGENT::INombre< uint8 >, NLAIAGENT::INombre< uint32 >, and NLAIAGENT::INombre< sint32 >. +

+Definition at line 139 of file agent_operator.h. +

+References NLAIC::IBasicType::getType(), and NLAIC::stringGetBuild(). +

+

00140                 {
+00141                         std::string text;
+00142                         text = NLAIC::stringGetBuild("opertor <virtual IObjetOp *operator - (const IObjetOp &a)  const> note implemented for the '%s' interface",(const char *)getType());
+00143                         throw NLAIE::CExceptionNotImplemented(text.c_str());
+00144                         return (IObjetOp *)this;
+00145                 }
+
+

+ + + + +
+ + + + + + + + + + +
virtual IObjetOp& NLAIAGENT::IObjetOp::operator-= IObjetOp a  )  [inline, virtual, inherited]
+
+ + + + + +
+   + + +

+throw (NLAIE::CExceptionNotImplemented) +

+ +

+Reimplemented in NLAIAGENT::IBaseGroupType. +

+Definition at line 177 of file agent_operator.h. +

+

00178                 {
+00179                         return *this -= *a;
+00180 
+00181                 }
+
+

+ + + + +
+ + + + + + + + + + +
virtual IObjetOp& NLAIAGENT::IObjetOp::operator-= const IObjetOp  )  [inline, virtual, inherited]
+
+ + + + + +
+   + + +

+throw (NLAIE::CExceptionNotImplemented) +

+ +

+Reimplemented in NLAIAGENT::IVector, NLAIAGENT::INombre< tNombre >, NLAIAGENT::CStringType, NLAIAGENT::IBaseGroupType, NLAIAGENT::IListBasicManager, NLAIAGENT::CAgentOperation, NLAIAGENT::INombre< double >, NLAIAGENT::INombre< uint16 >, NLAIAGENT::INombre< float >, NLAIAGENT::INombre< sint8 >, NLAIAGENT::INombre< uint64 >, NLAIAGENT::INombre< sint16 >, NLAIAGENT::INombre< uint8 >, NLAIAGENT::INombre< uint32 >, and NLAIAGENT::INombre< sint32 >. +

+Definition at line 92 of file agent_operator.h. +

+References NLAIC::IBasicType::getType(), and NLAIC::stringGetBuild(). +

+

00093                 {
+00094                         std::string text;
+00095                         text = NLAIC::stringGetBuild("opertor <IObjectIA &operator -= (const IObjectIA &a)> note implemented for the '%s' interface",(const char *)getType());
+00096                         throw NLAIE::CExceptionNotImplemented(text.c_str());
+00097                         return *this;
+00098                 }
+
+

+ + + + +
+ + + + + + + + + + +
virtual IObjetOp* NLAIAGENT::IObjetOp::operator/ IObjetOp a  )  [inline, virtual, inherited]
+
+ + + + + +
+   + + +

+throw (NLAIE::CExceptionNotImplemented) +

+ +

+Definition at line 207 of file agent_operator.h. +

+

00208                 {
+00209                         return *this / *a;
+00210 
+00211                 }
+
+

+ + + + +
+ + + + + + + + + + +
virtual IObjetOp* NLAIAGENT::IObjetOp::operator/ const IObjetOp  )  [inline, virtual, inherited]
+
+ + + + + +
+   + + +

+throw (NLAIE::CExceptionNotImplemented) +

+ +

+Reimplemented in NLAIAGENT::INombre< tNombre >, NLAIAGENT::INombre< double >, NLAIAGENT::INombre< uint16 >, NLAIAGENT::INombre< float >, NLAIAGENT::INombre< sint8 >, NLAIAGENT::INombre< uint64 >, NLAIAGENT::INombre< sint16 >, NLAIAGENT::INombre< uint8 >, NLAIAGENT::INombre< uint32 >, and NLAIAGENT::INombre< sint32 >. +

+Definition at line 155 of file agent_operator.h. +

+References NLAIC::IBasicType::getType(), and NLAIC::stringGetBuild(). +

+

00156                 {
+00157                         std::string text;
+00158                         text = NLAIC::stringGetBuild("opertor <virtual IObjetOp *operator / (const IObjetOp &a)  const> note implemented for the '%s' interface",(const char *)getType());
+00159                         throw NLAIE::CExceptionNotImplemented(text.c_str());
+00160                         return (IObjetOp *)this;
+00161                 }
+
+

+ + + + +
+ + + + + + + + + + +
virtual IObjetOp& NLAIAGENT::IObjetOp::operator/= IObjetOp a  )  [inline, virtual, inherited]
+
+ + + + + +
+   + + +

+throw (NLAIE::CExceptionNotImplemented) +

+ +

+Definition at line 187 of file agent_operator.h. +

+

00188                 {
+00189                         return *this /= *a;
+00190 
+00191                 }
+
+

+ + + + +
+ + + + + + + + + + +
virtual IObjetOp& NLAIAGENT::IObjetOp::operator/= const IObjetOp  )  [inline, virtual, inherited]
+
+ + + + + +
+   + + +

+throw (NLAIE::CExceptionNotImplemented) +

+ +

+Reimplemented in NLAIAGENT::INombre< tNombre >, NLAIAGENT::CAgentOperation, NLAIAGENT::INombre< double >, NLAIAGENT::INombre< uint16 >, NLAIAGENT::INombre< float >, NLAIAGENT::INombre< sint8 >, NLAIAGENT::INombre< uint64 >, NLAIAGENT::INombre< sint16 >, NLAIAGENT::INombre< uint8 >, NLAIAGENT::INombre< uint32 >, and NLAIAGENT::INombre< sint32 >. +

+Definition at line 119 of file agent_operator.h. +

+References NLAIC::IBasicType::getType(), and NLAIC::stringGetBuild(). +

+

00120                 {
+00121                         std::string text;
+00122                         text = NLAIC::stringGetBuild("opertor <IObjectIA &operator /= (const IObjectIA &a)> note implemented for the '%s' interface",(const char *)getType());
+00123                         throw NLAIE::CExceptionNotImplemented(text.c_str());
+00124                         return *this;
+00125                 }       
+
+

+ + + + +
+ + + + + + + + + + +
virtual IObjetOp* NLAIAGENT::IObjetOp::operator< IObjetOp  )  const [inline, virtual, inherited]
+
+ + + + + +
+   + + +

+throw (NLAIE::CExceptionNotImplemented) +

+ +

+Reimplemented in NLAIAGENT::INombre< tNombre >, NLAIAGENT::CStringType, NLAIFUZZY::FuzzyType, NLAILOGIC::CBoolType, NLAISCRIPT::CVarPStack, NLAISCRIPT::CVarPStackParam, NLAIAGENT::INombre< double >, NLAIAGENT::INombre< uint16 >, NLAIAGENT::INombre< float >, NLAIAGENT::INombre< sint8 >, NLAIAGENT::INombre< uint64 >, NLAIAGENT::INombre< sint16 >, NLAIAGENT::INombre< uint8 >, NLAIAGENT::INombre< uint32 >, and NLAIAGENT::INombre< sint32 >. +

+Definition at line 213 of file agent_operator.h. +

+References NLAIC::IBasicType::getType(), and NLAIC::stringGetBuild(). +

+

00214                 {
+00215                         std::string text;
+00216                         text = NLAIC::stringGetBuild("opertor <virtual IObjetOp *operator < (const IObjetOp &a)  const> note implemented for the '%s' interface",(const char *)getType());
+00217                         throw NLAIE::CExceptionNotImplemented(text.c_str());
+00218                         return (IObjetOp *)this;
+00219                 }
+
+

+ + + + +
+ + + + + + + + + + +
virtual IObjetOp* NLAIAGENT::IObjetOp::operator<= IObjetOp  )  const [inline, virtual, inherited]
+
+ + + + + +
+   + + +

+throw (NLAIE::CExceptionNotImplemented) +

+ +

+Reimplemented in NLAIAGENT::INombre< tNombre >, NLAIAGENT::CStringType, NLAIFUZZY::FuzzyType, NLAILOGIC::CBoolType, NLAISCRIPT::CVarPStack, NLAISCRIPT::CVarPStackParam, NLAIAGENT::INombre< double >, NLAIAGENT::INombre< uint16 >, NLAIAGENT::INombre< float >, NLAIAGENT::INombre< sint8 >, NLAIAGENT::INombre< uint64 >, NLAIAGENT::INombre< sint16 >, NLAIAGENT::INombre< uint8 >, NLAIAGENT::INombre< uint32 >, and NLAIAGENT::INombre< sint32 >. +

+Definition at line 229 of file agent_operator.h. +

+References NLAIC::IBasicType::getType(), and NLAIC::stringGetBuild(). +

+

00230                 {
+00231                         std::string text;
+00232                         text = NLAIC::stringGetBuild("opertor <virtual IObjetOp *operator <= (const IObjetOp &a)  const> note implemented for the '%s' interface",(const char *)getType());
+00233                         throw NLAIE::CExceptionNotImplemented(text.c_str());
+00234                         return (IObjetOp *)this;
+00235                 }
+
+

+ + + + +
+ + + + + + + + + + +
bool NLAIAGENT::IBasicObjectIA::operator== const IBasicObjectIA classType  )  const [inherited]
+
+ + + + + +
+   + + +

+Lot of algo use this function to determine the equality between 2 class, in particular the extraction from stl list. the == operator call the bool isEqual(const IBasicObjectIA &a) const member method to determine the equality between tow class. +

+Definition at line 134 of file baseai.cpp. +

+References NLAIC::IBasicType::getType(), and NLAIAGENT::IBasicObjectIA::isEqual(). +

+

00135         {                                               
+00136                 if(a.getType() == getType() ) return isEqual(a);                        
+00137                 return false;
+00138         }               
+
+

+ + + + +
+ + + + + + + + + + +
IObjetOp * NLAILOGIC::CClause::operator== NLAIAGENT::IObjetOp a  )  const [virtual, inherited]
+
+ + + + + +
+   + + +

+throw (NLAIE::CExceptionNotImplemented) +

+ +

+Reimplemented from NLAIAGENT::IObjetOp. +

+Definition at line 288 of file clause.cpp. +

+References NLAIAGENT::IObjetOp::isTrue(), and NLAILOGIC::CClause::isTrue(). +

+

00289         {
+00290                 return new CBoolType( isTrue() == a.isTrue() );
+00291         }
+
+

+ + + + +
+ + + + + + + + + + +
virtual IObjetOp* NLAIAGENT::IObjetOp::operator> IObjetOp  )  const [inline, virtual, inherited]
+
+ + + + + +
+   + + +

+throw (NLAIE::CExceptionNotImplemented) +

+ +

+Reimplemented in NLAIAGENT::INombre< tNombre >, NLAIAGENT::CStringType, NLAIFUZZY::FuzzyType, NLAILOGIC::CBoolType, NLAISCRIPT::CVarPStack, NLAISCRIPT::CVarPStackParam, NLAIAGENT::INombre< double >, NLAIAGENT::INombre< uint16 >, NLAIAGENT::INombre< float >, NLAIAGENT::INombre< sint8 >, NLAIAGENT::INombre< uint64 >, NLAIAGENT::INombre< sint16 >, NLAIAGENT::INombre< uint8 >, NLAIAGENT::INombre< uint32 >, and NLAIAGENT::INombre< sint32 >. +

+Definition at line 221 of file agent_operator.h. +

+References NLAIC::IBasicType::getType(), and NLAIC::stringGetBuild(). +

+

00222                 {
+00223                         std::string text;
+00224                         text = NLAIC::stringGetBuild("opertor <virtual IObjetOp *operator > (const IObjetOp &a)  const> note implemented for the '%s' interface",(const char *)getType());
+00225                         throw NLAIE::CExceptionNotImplemented(text.c_str());
+00226                         return (IObjetOp *)this;
+00227                 }
+
+

+ + + + +
+ + + + + + + + + + +
virtual IObjetOp* NLAIAGENT::IObjetOp::operator>= IObjetOp  )  const [inline, virtual, inherited]
+
+ + + + + +
+   + + +

+throw (NLAIE::CExceptionNotImplemented) +

+ +

+Reimplemented in NLAIAGENT::INombre< tNombre >, NLAIAGENT::CStringType, NLAIFUZZY::FuzzyType, NLAILOGIC::CBoolType, NLAISCRIPT::CVarPStack, NLAISCRIPT::CVarPStackParam, NLAIAGENT::INombre< double >, NLAIAGENT::INombre< uint16 >, NLAIAGENT::INombre< float >, NLAIAGENT::INombre< sint8 >, NLAIAGENT::INombre< uint64 >, NLAIAGENT::INombre< sint16 >, NLAIAGENT::INombre< uint8 >, NLAIAGENT::INombre< uint32 >, and NLAIAGENT::INombre< sint32 >. +

+Definition at line 237 of file agent_operator.h. +

+References NLAIC::IBasicType::getType(), and NLAIC::stringGetBuild(). +

+

00238                 {
+00239                         std::string text;
+00240                         text = NLAIC::stringGetBuild("opertor <virtual IObjetOp *operator >= (const IObjetOp &a)  const> note implemented for the '%s' interface",(const char *)getType());
+00241                         throw NLAIE::CExceptionNotImplemented(text.c_str());
+00242                         return (IObjetOp *)this;
+00243                 }
+
+

+ + + + +
+ + + + + + + + + + +
IBaseVar * NLAILOGIC::CVarSet::operator[] sint32   )  [virtual, inherited]
+
+ + + + + +
+   + + +

+ +

+Definition at line 305 of file varset.cpp. +

+References sint32. +

+

00306         {
+00307                 return _Vars[i];
+00308         }
+
+

+ + + + +
+ + + + + + + + + + +
void NLAILOGIC::CClause::propagate CFactPattern  )  [virtual, inherited]
+
+ + + + + +
+   + + +

+ +

+Definition at line 195 of file clause.cpp. +

+

00196         {
+00197                 // Pour chaque liaison...
+00198 /*              std::list< CValueSet *>::iterator it_l = _Liaisons.begin();
+00199                 
+00200                 while ( it_l != _Liaisons.end() )
+00201                 {
+00202                         CValueSet *result;
+00203                         if ( result = fp->unify( *it_l ) )
+00204                         {
+00205                                 if ( result->undefined() == 0 )
+00206                                         _Conflits.push_back( result );
+00207                                 else 
+00208                                         _BufLiaisons.push_back( result );
+00209                         }
+00210                         it_l++;
+00211                 }*/
+00212         }
+
+

+ + + + +
+ + + + + + + + + + + + + + + + + + + +
void NLAILOGIC::CClause::propagate std::list< NLAIAGENT::IObjectIA * > * ,
std::vector< sint32 > & 
[virtual, inherited]
+
+ + + + + +
+   + + +

+ +

+Definition at line 214 of file clause.cpp. +

+References NLAILOGIC::CClause::_BufLiaisons, NLAILOGIC::CClause::_Conflits, NLAILOGIC::CClause::_Liaisons, NLAILOGIC::CClause::_NbValid, NLAILOGIC::CClause::addBuffer(), NLAILOGIC::CClause::addConflicts(), NLAILOGIC::CValueSet::undefined(), and NLAILOGIC::CClause::unifyLiaison(). +

+

00215         {
+00216                 // Pour chaque liaison...
+00217                 std::list< CValueSet *>::iterator it_l = _Liaisons.begin();
+00218                 
+00219                 while ( it_l != _Liaisons.end() )
+00220                 {
+00221 //                      char buf[512];
+00222                         CValueSet *l = *it_l;
+00223 /*                      l->getDebugString( buf );
+00224                         TRACE( "Pour liaison: %s \n", buf );*/
+00225                         CValueSet *result = unifyLiaison( l, vals, pos_vals );
+00226                         if ( result )
+00227                         {
+00228 
+00229 /*                              char buf[512];
+00230                                 result->getDebugString( buf );
+00231                                 TRACE( "Unification: %s \n", buf );*/
+00232 
+00233                                 if ( result->undefined() == 0 )
+00234                                 {
+00235                                         _Conflits.push_back( result );
+00236                                         _NbValid++;
+00237                                 }
+00238 
+00239                                 else 
+00240                                         _BufLiaisons.push_back( result );
+00241                         }
+00242                         it_l++;
+00243                 }
+00244 
+00245                 addBuffer();
+00246                 addConflicts();
+00247 
+00248         }       
+
+

+ + + + +
+ + + + + + + + + + +
virtual void NLAIC::IPointerGestion::release void   )  [inline, virtual, inherited]
+
+ + + + + +
+   + + +

+Release allow to release the pointer. The last release when the _Ref is nul delete the object. +

+ +

+Definition at line 86 of file abstract_interface.h. +

+References NLAIC::IPointerGestion::decRef(). +

+Referenced by NLAIAGENT::CSeqFsmScript::activate(), NLAISCRIPT::CAgentClass::addBrancheCode(), NLAISCRIPT::CConstraintDebug::addIndex(), NLAISCRIPT::CCompilateur::affectation(), NLAISCRIPT::CCompilateur::affectationMember(), NLAISCRIPT::COperatorClass::backward(), NLAILOGIC::CFirstOrderOperator::backward(), NLAILOGIC::CFirstOrderAssert::backward(), NLAISCRIPT::CCompilateur::buildObject(), NLAILINK::buildScript(), NLAISCRIPT::CCompilateur::callFunction(), NLAIC::CIdentType::CIdentType(), NLAISCRIPT::CCompilateur::clean(), NLAISCRIPT::CParam::clear(), NLAIAGENT::CVectorGroupType::clear(), NLAIAGENT::CGroupType::clear(), NLAIAGENT::CVolatilMemmory::CVolatilMemmory(), NLAISCRIPT::CFactorType::del(), NLAIAGENT::IAgentComposite::deleteListe(), NLAIPYSERVER::endPythonInterface(), NLAIAGENT::CVectorGroupType::erase(), NLAIAGENT::CGroupType::erase(), NLAIAGENT::CVectorGroupType::eraseAll(), NLAIAGENT::CGroupType::eraseAll(), NLAISCRIPT::CCompilateur::errorMethodConstraint(), NLAISCRIPT::CCompilateur::errorTypeConstraint(), NLAISCRIPT::CCompilateur::findMethode(), NLAISCRIPT::COperatorClass::forward(), NLAILOGIC::CFirstOrderOperator::forward(), NLAIAGENT::CComponentHandle::getComponent(), NLAIAGENT::COperatorScript::getDebugString(), NLAIAGENT::CAgentScript::getDebugString(), NLAILOGIC::IBaseOperator::IBaseOperator(), NLAISCRIPT::CCompilateur::ifInterrogation(), NLAISCRIPT::CCompilateur::ifInterrogationEnd(), NLAILOGIC::CFactPattern::init(), init(), NLAIFUZZY::CTrapezeFuzzySet::init(), NLAIFUZZY::CLeftFuzzySet::init(), NLAIFUZZY::CTriangleFuzzySet::init(), NLAIFUZZY::CRightFuzzySet::init(), NLAIFUZZY::CFuzzyInterval::init(), NLAIFUZZY::CFuzzyRule::init(), NLAIFUZZY::CSimpleFuzzyCond::init(), NLAISCRIPT::CCompilateur::interrogationEnd(), NLAISCRIPT::COperatorClass::isValidFonc(), NLAIAGENT::IAgent::Kill(), NLAILOGIC::CVar::load(), NLAILOGIC::CValueSet::load(), NLAISCRIPT::CLdbOpCode::load(), NLAISCRIPT::CLibCallMethodi::load(), NLAISCRIPT::CLibCallInheritedMethod::load(), NLAISCRIPT::CLibCallMethod::load(), NLAISCRIPT::CLdbNewOpCode::load(), NLAISCRIPT::CAddParamNameDebug::load(), NLAISCRIPT::CFindRunMsg::load(), NLAIAGENT::IListBasicManager::load(), NLAIAGENT::CVectorGroupType::load(), NLAIAGENT::CGroupType::load(), NLAIAGENT::CAgentScript::load(), NLAIAGENT::CStringType::load(), NLAIAGENT::CLocalAgentMail::load(), NLAISCRIPT::CMethodContextDebug::loadContext(), NLAISCRIPT::CCompilateur::onEndClass(), NLAIAGENT::CLocalMailBox::onKill(), NLAIAGENT::IAgent::onKill(), NLAIAGENT::CLocalAgentMail::onKill(), NLAIAGENT::CVectorGroupType::operator-(), NLAIAGENT::CGroupType::operator-(), NLAIAGENT::CKeyObject::operator=(), NLAISCRIPT::CFunctionTag::operator=(), NLAIAGENT::CIdMethod::operator=(), NLAISCRIPT::CCompilateur::PrivateError(), NLAISCRIPT::CCompilateur::processingVar(), NLAIAGENT::CAgentScript::processMessages(), NLAIAGENT::IRefrence::refLoadStream(), NLAISCRIPT::CCompilateur::registerMethod(), NLAIAGENT::IAgentComposite::removeChild(), NLAILOGIC::CFirstOrderAssert::removeFact(), NLAISCRIPT::CConstraintStackComp::run(), NLAISCRIPT::CConstraintFindRun::run(), NLAISCRIPT::CConstraintMethode::run(), NLAIAGENT::IBasicAgent::run(), NLAIAGENT::CAgentScript::runInitComponent(), NLAIAGENT::CVolatilMemmory::runMessage(), NLAIAGENT::CAgentOperation::runMethodBase(), NLAISCRIPT::CCompilateur::runMethodConstraint(), NLAILOGIC::CInternalGoal::runMethodeMember(), NLAILOGIC::CGoal::runMethodeMember(), NLAILOGIC::CFact::runMethodeMember(), NLAIAGENT::IObjectIA::runMethodeMember(), NLAISCRIPT::CLdbStackMemberiOpCode::runOpCode(), NLAISCRIPT::CCallStackMethodi::runOpCode(), NLAISCRIPT::CLibHeapMemberMethod::runOpCode(), NLAISCRIPT::CAffOpCode::runOpCode(), NLAISCRIPT::CJFalseOpCode::runOpCode(), NLAISCRIPT::CAffOpCodeDebug::runOpCode(), NLAISCRIPT::CDiffOpCode::runOpCode(), NLAISCRIPT::CInfEqOpCode::runOpCode(), NLAISCRIPT::CSupEqOpCode::runOpCode(), NLAISCRIPT::CEqOpCode::runOpCode(), NLAISCRIPT::CInfOpCode::runOpCode(), NLAISCRIPT::CSupOpCode::runOpCode(), NLAISCRIPT::CMulOpCode::runOpCode(), NLAISCRIPT::CDivOpCode::runOpCode(), NLAISCRIPT::CSubOpCode::runOpCode(), NLAISCRIPT::CAddOpCode::runOpCode(), NLAISCRIPT::CNegOpCode::runOpCode(), NLAIAGENT::CAgentScript::runTellParentNotify(), NLAISCRIPT::CCompilateur::runTypeConstraint(), NLAIAGENT::CHashTimerManager::sendMessage(), NLAIAGENT::CVolatilMemmory::sendMessage(), NLAIAGENT::CLocalMailBox::sendMessage(), NLAIAGENT::IListManager::sendMessage(), NLAIAGENT::CAgentTimerHandle::sendMessage(), NLAIAGENT::CAgentScript::sendMessage(), NLAIAGENT::CAgentScript::sendMethod(), NLAISCRIPT::COperandSimple::serial(), NLAISCRIPT::CObjectUnknown::setBaseType(), NLAISCRIPT::CCompilateur::setChaineVar(), NLAISCRIPT::CClassInterpretFactory::setClass(), NLAIC::CSelfClassFactory::setClass(), NLAISCRIPT::IClassInterpret::setClassName(), NLAISCRIPT::CObjectUnknown::setClassType(), NLAIAGENT::IMessageBase::setContinuation(), NLAILOGIC::IBaseOperator::setGoal(), NLAISCRIPT::COperatorClass::setGoal(), NLAISCRIPT::CCompilateur::setImediateVar(), NLAISCRIPT::CCompilateur::setImediateVarNill(), NLAISCRIPT::CParam::setInfo(), NLAISCRIPT::CAgentClass::setInheritanceName(), NLAISCRIPT::CCompilateur::setListVar(), NLAIAGENT::IMessageBase::setMessageGroup(), NLAISCRIPT::CCompilateur::setMethodVar(), NLAILOGIC::IBaseVar::setName(), NLAIAGENT::CAgentOperation::setName(), NLAISCRIPT::CMethodeName::setName(), NLAIAGENT::IRefrence::setNumRef(), NLAISCRIPT::CConstraintFindRun::setOpCode(), NLAISCRIPT::CConstraintMethode::setOpCode(), NLAISCRIPT::CCompilateur::setPerformative(), NLAILOGIC::CInternalGoal::setProperty(), NLAIAGENT::IMessageBase::setReceiver(), NLAIAGENT::IMessageBase::setSender(), NLAILOGIC::CValueSet::setSize(), NLAISCRIPT::CCompilateur::setStackVar(), NLAIAGENT::CMessageScript::setStaticMember(), NLAIAGENT::CAgentScript::setStaticMember(), NLAISCRIPT::IClassInterpret::setType(), NLAISCRIPT::CFunctionTag::setTypeObject(), NLAISCRIPT::CMethodeName::setTypeOfMethode(), NLAILOGIC::CVar::setValue(), NLAIAGENT::CAgentOperation::setValue(), NLAIAGENT::IAgentInput::setValue(), NLAILOGIC::CValueSet::unify(), NLAISCRIPT::COperatorClass::unifyBackward(), NLAILOGIC::CFirstOrderOperator::unifyBackward(), NLAISCRIPT::COperatorClass::unifyForward(), NLAILOGIC::CFirstOrderOperator::unifyForward(), unifyLiaisonBack(), NLAISCRIPT::CAddParamNameDebug::~CAddParamNameDebug(), NLAISCRIPT::CAgentClass::~CAgentClass(), NLAIAGENT::CAgentOperation::~CAgentOperation(), NLAIAGENT::CAgentScript::~CAgentScript(), NLAIAGENT::CAgentTimerHandle::~CAgentTimerHandle(), NLAIAGENT::CAgentWatchTimer::~CAgentWatchTimer(), NLAISCRIPT::CClassInterpretFactory::~CClassInterpretFactory(), NLAISCRIPT::CCodeBrancheRunDebug::~CCodeBrancheRunDebug(), NLAISCRIPT::CCompilateur::~CCompilateur(), NLAIAGENT::CComponentHandle::~CComponentHandle(), NLAISCRIPT::CConstraintChkMethodeType::~CConstraintChkMethodeType(), NLAISCRIPT::CConstraintMethode::~CConstraintMethode(), NLAISCRIPT::CConstraintStackComp::~CConstraintStackComp(), NLAILOGIC::CFact::~CFact(), NLAISCRIPT::CFindRunMsg::~CFindRunMsg(), NLAILOGIC::CFirstOrderAssert::~CFirstOrderAssert(), NLAISCRIPT::CFunctionTag::~CFunctionTag(), NLAIC::CIdentType::~CIdentType(), NLAIAGENT::CIdMethod::~CIdMethod(), NLAILOGIC::CInternalGoal::~CInternalGoal(), NLAIAGENT::CKeyObject::~CKeyObject(), NLAISCRIPT::CLdbNewOpCode::~CLdbNewOpCode(), NLAISCRIPT::CLdbOpCode::~CLdbOpCode(), NLAISCRIPT::CLibCallInheritedMethod::~CLibCallInheritedMethod(), NLAISCRIPT::CLibCallMethod::~CLibCallMethod(), NLAISCRIPT::CLibCallMethodi::~CLibCallMethodi(), NLAIAGENT::CLocalMailBox::~CLocalMailBox(), NLAIAGENT::CMainAgentScript::~CMainAgentScript(), NLAISCRIPT::CLibTest::CMethodCall::~CMethodCall(), NLAIAGENT::CAgentScript::CMethodCall::~CMethodCall(), NLAISCRIPT::CMethodeName::~CMethodeName(), NLAISCRIPT::CAgentClass::CMethodType::~CMethodType(), NLAISCRIPT::CObjectUnknown::~CObjectUnknown(), NLAISCRIPT::COperandSimple::~COperandSimple(), NLAISCRIPT::COperandUnknown::~COperandUnknown(), NLAISCRIPT::COperationType::~COperationType(), NLAISCRIPT::COperationTypeGD::~COperationTypeGD(), NLAISCRIPT::COperatorClass::~COperatorClass(), NLAIAGENT::CPairType::~CPairType(), NLAIC::CSelfClassFactory::~CSelfClassFactory(), NLAIAGENT::CStringType::~CStringType(), NLAILOGIC::CValueSet::~CValueSet(), NLAILOGIC::CVar::~CVar(), NLAIAGENT::CVolatilMemmory::~CVolatilMemmory(), NLAIAGENT::IAgentInput::~IAgentInput(), NLAILOGIC::IBaseAssert::~IBaseAssert(), NLAILOGIC::IBaseOperator::~IBaseOperator(), NLAILOGIC::IBaseVar::~IBaseVar(), NLAIAGENT::IBasicAgent::~IBasicAgent(), NLAISCRIPT::IBlock::~IBlock(), NLAISCRIPT::IClassInterpret::~IClassInterpret(), NLAILOGIC::IGoal::~IGoal(), NLAIAGENT::IListBasicManager::~IListBasicManager(), NLAIAGENT::IMessageBase::~IMessageBase(), NLAIAGENT::IRefrence::~IRefrence(), and NLAICHARACTER::IZone::~IZone(). +

+

00087                 {
+00088                         if(decRef() == 0) 
+00089                                         delete this;
+00090                 }
+
+

+ + + + +
+ + + + + + + + + + +
void NLAILOGIC::CVarSet::removeVar IBaseVar  )  [inherited]
+
+ + + + + +
+   + + +

+ +

+Definition at line 150 of file varset.cpp. +

+

00151         {
+00152                 std::vector<IBaseVar *>::iterator it_var = _Vars.begin();
+00153                 while ( it_var != _Vars.end() )
+00154                 {
+00155                         if ( var == *it_var )
+00156                         {
+00157                                 ( *it_var )->release();
+00158                                 _Vars.erase( it_var );
+00159                                 return;
+00160                         }
+00161                         it_var++;
+00162                 }
+00163         }
+
+

+ + + + +
+ + + + + + + + + +
const IObjectIA::CProcessResult & NLAILOGIC::CVarSet::run  )  [virtual, inherited]
+
+ + + + + +
+   + + +

+Some where Run method define the process of the agen. +

+Implements NLAILOGIC::IBaseBoolType. +

+Definition at line 121 of file varset.cpp. +

+

00122         {
+00123                  return IObjectIA::ProcessRun;
+00124         }
+
+

+ + + + +
+ + + + + + + + + + + + + + + + + + + +
IObjectIA::CProcessResult NLAIAGENT::IObjectIA::runMethodeMember sint32  index,
IObjectIA
[virtual, inherited]
+
+ + + + + +
+   + + +

+The methode runMethodeMember(sint32 index,IObjectIA *param) allow us to run a own member method.

+index: is the method id return by the isMember(const IVarName *,const IVarName *,const IObjectIA &) const method. param: is the parametre for the method. +

+Reimplemented in NLAIAGENT::CActor, NLAIAGENT::IBasicAgent, NLAIAGENT::IVector, NLAIAGENT::CLocalAgentMail, NLAIAGENT::INombre< tNombre >, NLAIAGENT::CPairType, NLAIAGENT::IBaseGroupType, NLAIAGENT::CVectorGroupType, NLAIAGENT::CProxyAgentMail, NLAIAGENT::CAgentScript, NLAIAGENT::CLibTimerManager, NLAIAGENT::CAgentWatchTimer, NLAIAGENT::CAgentTimerHandle, NLAILOGIC::CGoalStack, NLAIAGENT::IListBasicManager, NLAIAGENT::CMessageScript, NLAIAGENT::IMessageBase, NLAIAGENT::CSuccessMsg, NLAIAGENT::CFailureMsg, NLAIAGENT::CFactMsg, NLAIAGENT::CGetValueMsg, NLAIAGENT::CGoalMsg, NLAIAGENT::CCancelGoalMsg, NLAIAGENT::CSetValueMsg, NLAIFUZZY::IFuzzySet, NLAIFUZZY::CFuzzyVar, NLAILOGIC::CFact, NLAILOGIC::CGoal, NLAILOGIC::CInternalGoal, NLAILOGIC::CGoalStack, NLAILOGIC::IBaseVar, NLAISCRIPT::CCallPrint, NLAISCRIPT::CLibTest, NLAIAGENT::INombre< double >, NLAIAGENT::INombre< uint16 >, NLAIAGENT::INombre< float >, NLAIAGENT::INombre< sint8 >, NLAIAGENT::INombre< uint64 >, NLAIAGENT::INombre< sint16 >, NLAIAGENT::INombre< uint8 >, NLAIAGENT::INombre< uint32 >, and NLAIAGENT::INombre< sint32 >. +

+Definition at line 266 of file baseai.cpp. +

+References NLAIAGENT::IDigital< sint32 >::getNumber(), NLAIAGENT::IObjectIA::getStaticMember(), NLAIAGENT::CStringType::getStr(), param, NLAIAGENT::IListBasicManager::pop(), r, NLAIC::IPointerGestion::release(), NLAIAGENT::IObjectIA::run(), NLAIAGENT::IObjectIA::sendMessage(), NLAIAGENT::IMessageBase::setPerformatif(), NLAIAGENT::IMessageBase::setReceiver(), sint, and sint32. +

+

00267         {
+00268                 
+00269                 switch(id)
+00270                 {
+00271                 case 0:
+00272                         {
+00273                                 IMessageBase *msg;
+00274 
+00275                                 IPerformative *p;
+00276                                 msg = (IMessageBase *)((IBaseGroupType *)a)->pop();
+00277                                 //this->incRef();
+00278                                 msg->setReceiver(this);
+00279                                 p = (IPerformative *)((IBaseGroupType *)a)->pop();
+00280                                 msg->setPerformatif((IMessageBase::TPerformatif)(sint)p->getNumber());
+00281                                 p->release();
+00282                                 if(((IBaseGroupType *)a)->size())
+00283                                 {                                       
+00284                                         CStringType *name = (CStringType *)((IBaseGroupType *)a)->pop();
+00285                                         IObjectIA::CProcessResult r = sendMessage(name->getStr(),msg);
+00286                                         name->release();
+00287                                         return r;
+00288                                         
+00289                                 }                               
+00290                                 return sendMessage(msg);
+00291                         }                       
+00292                         break;
+00293                 case 1:                 
+00294                         break;
+00295                 case 2:
+00296                         return run();
+00297                         break;
+00298 
+00299                 case 3:
+00300                         {
+00301                                 CProcessResult r;
+00302                                 NLAIAGENT::IBaseGroupType *param = (NLAIAGENT::IBaseGroupType *)a;
+00303                                 r.Result =      (IObjectIA *)getStaticMember((sint)((NLAIAGENT::INombreDefine *)param->get())->getNumber());
+00304                                 r.Result->incRef();
+00305                                 return r;
+00306                         }
+00307                 }
+00308                 return CProcessResult();
+00309         }
+
+

+ + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + + +
IObjectIA::CProcessResult NLAIAGENT::IObjectIA::runMethodeMember sint32 ,
sint32 ,
IObjectIA
[virtual, inherited]
+
+ + + + + +
+   + + +

+The methode runMethodeMember(sint32 heritance, sint32 index, IObjectIA *param) allow us to run a member method.

+heritance: is the id returned by the methodisClassInheritedFrom(const IVarName &). index: is the method id return by the isMember(const IVarName *,const IVarName *,const IObjectIA &) const method. param: is the parametre for the method. +

+Reimplemented in NLAIAGENT::IBasicAgent, NLAIAGENT::IVector, NLAIAGENT::CLocalAgentMail, NLAIAGENT::INombre< tNombre >, NLAIAGENT::CPairType, NLAIAGENT::IBaseGroupType, NLAIAGENT::CVectorGroupType, NLAIAGENT::CProxyAgentMail, NLAIAGENT::CAgentScript, NLAIAGENT::CAgentTimerHandle, NLAILOGIC::CGoalStack, NLAIAGENT::IListBasicManager, NLAIAGENT::CMessageScript, NLAIAGENT::IMessageBase, NLAIAGENT::CSuccessMsg, NLAIAGENT::CFailureMsg, NLAIAGENT::CFactMsg, NLAIAGENT::CGetValueMsg, NLAIAGENT::CGoalMsg, NLAIAGENT::CCancelGoalMsg, NLAIAGENT::CSetValueMsg, NLAIFUZZY::CFuzzyVar, NLAILOGIC::CFact, NLAILOGIC::CGoal, NLAILOGIC::CInternalGoal, NLAILOGIC::CGoalStack, NLAISCRIPT::CCallPrint, NLAISCRIPT::CLibTest, NLAIAGENT::INombre< double >, NLAIAGENT::INombre< uint16 >, NLAIAGENT::INombre< float >, NLAIAGENT::INombre< sint8 >, NLAIAGENT::INombre< uint64 >, NLAIAGENT::INombre< sint16 >, NLAIAGENT::INombre< uint8 >, NLAIAGENT::INombre< uint32 >, and NLAIAGENT::INombre< sint32 >. +

+Definition at line 257 of file baseai.cpp. +

+References sint32. +

+Referenced by NLAISCRIPT::CLibHeapMemberMethod::runOpCode(), NLAISCRIPT::CLibStackNewMemberMethod::runOpCode(), NLAISCRIPT::CLibStackMemberMethod::runOpCode(), NLAISCRIPT::CLibCallMethodi::runOpCode(), NLAISCRIPT::CLibCallInheritedMethod::runOpCode(), NLAISCRIPT::CLibCallMethod::runOpCode(), and NLAISCRIPT::CLibMemberMethodi::runOpCode(). +

+

00258         {
+00259                 /*char text[2048*8];
+00260                 sprintf(text,"method  runMethodeMember(sint32 h, sint32 id,const IObjectIA &) not implemented for the '%s' interface",(const char *)getType());
+00261                 throw NLAIE::CExceptionNotImplemented(text);
+00262                 return CProcessResult();*/
+00263                 return IObjectIA::runMethodeMember(id,a);
+00264         }
+
+

+ + + + +
+ + + + + + + + + +
const IObjectIA::CProcessResult & NLAIAGENT::IObjectIA::runStep  )  [virtual, inherited]
+
+ + + + + +
+   + + +

+Some where Run method define the process of the agen. +

+Reimplemented in NLAIAGENT::IAgent, and NLAIAGENT::CAgentScript. +

+Definition at line 163 of file baseai.cpp. +

+References NLAIC::IBasicType::getType(), and NLAIC::stringGetBuild(). +

+Referenced by NLAIAGENT::IAgent::runChildrenStepByStep(). +

+

00164         {
+00165                 std::string text;
+00166                 text = NLAIC::stringGetBuild("const CProcessResult &IObjectIA::runStep() note implementaited for the '%s' interface",(const char *)getType());
+00167                 throw NLAIE::CExceptionNotImplemented(text.c_str());
+00168                 return IObjectIA::ProcessNotComplit;
+00169         }
+
+

+ + + + +
+ + + + + + + + + + +
void NLAILOGIC::CVarSet::save NLMISC::IStream os  )  [virtual, inherited]
+
+ + + + + +
+   + + +

+Save the class in a stream. +

+Implements NLAIC::IBasicInterface. +

+Definition at line 71 of file varset.cpp. +

+References NLAILOGIC::CVarSet::getType(), NLMISC::IStream::serial(), sint32, and size. +

+

00072         {                       
+00073                 IObjectIA::save(os);
+00074                 sint32 size = _Vars.size();
+00075                 os.serial( size );
+00076                 
+00077                 for (sint32 i = 0; i < (sint32)_Vars.size() ; i++ )
+00078                 {
+00079                         os.serial( (NLAIC::CIdentType &) _Vars[ i ]->getType() );
+00080                         _Vars[ i ]->save( os );
+00081                 }
+00082         }
+
+

+ + + + +
+ + + + + + + + + + + + + + + + + + + +
IObjectIA::CProcessResult NLAIAGENT::IObjectIA::sendMessage const IVarName,
IObjectIA
[virtual, inherited]
+
+ + + + + +
+   + + +

+This method allow to send a message to an compoment given by an string IVarName. +

+Reimplemented in NLAIAGENT::CProxyAgentMail, NLAIAGENT::CAgentScript, and NLAIAGENT::IMessageBase. +

+Definition at line 334 of file baseai.cpp. +

+References NLAIAGENT::IVarName::getString(), NLAIC::IBasicType::getType(), and NLAIC::stringGetBuild(). +

+

00335         {
+00336                 std::string text;
+00337                 text = NLAIC::stringGetBuild("method 'sendMessage(%s,const IObjectIA &)' '%s' interface",name.getString(), (const char *)getType());
+00338                 throw NLAIE::CExceptionNotImplemented(text.c_str());
+00339                 return CProcessResult();
+00340         }
+
+

+ + + + +
+ + + + + + + + + + +
IObjectIA::CProcessResult NLAIAGENT::IObjectIA::sendMessage IObjectIA  )  [virtual, inherited]
+
+ + + + + +
+   + + +

+The method sendMessage(const IObjectIA &msg) allow us to achive a message defined in msg. +

+Reimplemented in NLAIAGENT::CActorScript, NLAIAGENT::CLocalAgentMail, NLAIAGENT::CProxyAgentMail, NLAIAGENT::CAgentScript, NLAIAGENT::CAgentTimerHandle, NLAIAGENT::IConnectIA, NLAIAGENT::IListManager, NLAIAGENT::CMainAgentScript, and NLAIAGENT::IMessageBase. +

+Definition at line 342 of file baseai.cpp. +

+References NLAIC::IBasicType::getType(), and NLAIC::stringGetBuild(). +

+Referenced by NLAIAGENT::IObjectIA::runMethodeMember(), NLAIAGENT::CAgentScript::sendBroadCast(), NLAIAGENT::IMessageBase::sendMessage(), NLAIAGENT::IListManager::sendMessage(), and NLAIAGENT::CAgentScript::sendMessage(). +

+

00343         {
+00344                 std::string text;
+00345                 text = NLAIC::stringGetBuild("method 'sendMessage(const IObjectIA &)' '%s' interface", (const char *)getType());
+00346                 throw NLAIE::CExceptionNotImplemented(text.c_str());
+00347                 return CProcessResult();
+00348         }
+
+

+ + + + +
+ + + + + + + + + + +
virtual void NLAIC::IBasicInterface::serial NLMISC::IStream f  )  throw (NLMISC::EStream) [inline, virtual, inherited]
+
+ + + + + +
+   + + +

+ +

+Reimplemented from NLAIC::IPointerGestion. +

+Definition at line 328 of file abstract_interface.h. +

+References NLAIC::IBasicInterface::load(), and NLAIC::IBasicInterface::save(). +

+

00329                 {
+00330                         if ( f.isReading() )
+00331                                 load( f );
+00332                         else
+00333                                 save( f );
+00334                 }
+
+

+ + + + +
+ + + + + + + + + + +
void NLAILOGIC::CRule::setCond CClause  ) 
+
+ + + + + +
+   + + +

+ +

+Definition at line 67 of file rule.cpp. +

+

00068         {
+00069 /*              std::list< std::vector<sint32> >::const_iterator it_li = c._pos_vars.begin();
+00070                 while ( it_li != c._pos_vars.end() )
+00071                 {
+00072                         std::vector<sint32>::const_iterator it_i = (*it_li).begin();
+00073                         _pos_vars.push_back( std::vector<sint32>() );
+00074 
+00075                         while ( it_i != (*it_li).end() )
+00076                         {
+00077                                 _pos_vars.back().push_back( *it_i ) ;
+00078                                 it_i++;
+00079                         }
+00080                         it_li++;
+00081                 }*/
+00082         }
+
+

+ + + + +
+ + + + + + + + + + + + + + + + + + + +
bool NLAIAGENT::IObjectIA::setStaticMember sint32 ,
IObjectIA
[virtual, inherited]
+
+ + + + + +
+   + + +

+to cahnge a given components given by a string. +

+Reimplemented in NLAIAGENT::CLocalAgentMail, NLAIAGENT::CAgentScript, NLAIAGENT::CMessageScript, and NLAISCRIPT::CAgentClass. +

+Definition at line 198 of file baseai.cpp. +

+References NLAIC::IBasicType::getType(), sint32, and NLAIC::stringGetBuild(). +

+

00199         {
+00200                 std::string text;
+00201                 text = NLAIC::stringGetBuild("Function void IObjectIA::setStaticMember(sint32,IObjectIA *) note implementaited for the '%s' interface",(const char *)getType());
+00202                 throw NLAIE::CExceptionNotImplemented(text.c_str());
+00203                 return false;
+00204         }
+
+

+ + + + +
+ + + + + + + + + + + + + + + + + + + +
bool NLAIAGENT::IObjectIA::setStaticMember const IVarName compName,
IObjectIA change
[inline, inherited]
+
+ + + + + +
+   + + +

+to cahnge a given components given by an index. +

+Definition at line 268 of file baseai.h. +

+References NLAIAGENT::IObjectIA::getStaticMemberIndex(). +

+Referenced by NLAISCRIPT::CAffHeapMemberiOpCode::runOpCode(), NLAISCRIPT::CAffMemberiOpCode::runOpCode(), and NLAIAGENT::CLocalAgentMail::setStaticMember(). +

+

00269                 {
+00270                         return setStaticMember(getStaticMemberIndex(compName),change);
+00271                 }
+
+

+ + + + +
+ + + + + + + + + +
void NLAILOGIC::CClause::showBuffer  )  [inherited]
+
+ + + + + +
+   + + +

+ +

+Definition at line 304 of file clause.cpp. +

+References NLAILOGIC::CClause::_BufLiaisons. +

+

00305         {
+00306                 std::list<CValueSet *>::iterator it_vs = _BufLiaisons.begin();
+00307                 while ( it_vs != _BufLiaisons.end() )
+00308                 {
+00309                         std::string buf;
+00310                         ( *it_vs )->getDebugString( buf );                      
+00311                         it_vs++;
+00312                 }
+00313         }
+
+

+ + + + +
+ + + + + + + + + +
void NLAILOGIC::CClause::showConflicts  )  [inherited]
+
+ + + + + +
+   + + +

+ +

+Definition at line 293 of file clause.cpp. +

+References NLAILOGIC::CClause::_Conflits. +

+

00294         {
+00295                 std::list<CValueSet *>::iterator it_vs = _Conflits.begin();
+00296                 while ( it_vs != _Conflits.end() )
+00297                 {
+00298                         std::string buf;
+00299                         ( *it_vs )->getDebugString( buf );
+00300                         it_vs++;
+00301                 }
+00302         }
+
+

+ + + + +
+ + + + + + + + + +
void NLAILOGIC::CClause::showLiaisons  )  [inherited]
+
+ + + + + +
+   + + +

+ +

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

+References NLAILOGIC::CClause::_Liaisons. +

+

00316         {
+00317                 std::list<CValueSet *>::iterator it_vs = _Liaisons.begin();
+00318                 while ( it_vs != _Liaisons.end() )
+00319                 {
+00320                         std::string buf;
+00321                         ( *it_vs )->getDebugString( buf );                      
+00322                         it_vs++;
+00323                 }
+00324         }
+
+

+ + + + +
+ + + + + + + + + +
sint32 NLAILOGIC::CVarSet::size  )  [inherited]
+
+ + + + + +
+   + + +

+ +

+Definition at line 240 of file varset.cpp. +

+References sint32. +

+

00241         {
+00242                 return _Vars.size();
+00243         }
+
+

+ + + + +
+ + + + + + + + + +
float NLAILOGIC::CClause::truthValue  )  const [virtual, inherited]
+
+ + + + + +
+   + + +

+Returns a value in [0,1]. +

+ +

+Reimplemented from NLAILOGIC::CVarSet. +

+Definition at line 280 of file clause.cpp. +

+References NLAILOGIC::CClause::_NbValid. +

+

00281         {
+00282                 if ( _NbValid > 0 )
+00283                         return 1.0;
+00284                 else
+00285                         return 0.0;
+00286         }
+
+

+ + + + +
+ + + + + + + + + +
sint32 NLAILOGIC::CVarSet::undefined  )  [virtual, inherited]
+
+ + + + + +
+   + + +

+ +

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

+References sint32. +

+

00297         {
+00298                 sint32 nb_undef = _Vars.size();
+00299                 for ( sint32 i = 0; i < (sint32) _Vars.size(); i++ )
+00300                         if ( _Vars[i]->getValue() != NULL )
+00301                                 nb_undef--;
+00302                 return nb_undef;
+00303         }
+
+

+ + + + +
+ + + + + + + + + + +
CVarSet * NLAILOGIC::CVarSet::unify CValueSet  )  [virtual, inherited]
+
+ + + + + +
+   + + +

+ +

+Definition at line 205 of file varset.cpp. +

+References sint32, and NLAILOGIC::CValueSet::size(). +

+

00206         {
+00207                 if ( fp->size() != (sint32)_Vars.size() )
+00208                         return NULL;
+00209 
+00210 /*              vector<IBaseVar *> *tmp_Vars = new vector<IObjetOp *>;
+00211                 vector<IBaseVar *>::iterator it_vt = _Vars.begin();
+00212 
+00213                 CVarSet *unified = new CVarSet(NULL);
+00214                                 
+00215                 while ( it_vt != _Vars.end() )
+00216                 {
+00217                         IBaseVar *tmp_var = (IBaseVar *) (*it_vt)->clone();
+00218                         if ( tmp_var->unify( *it_vu , true ) )
+00219                                 unified->addVar( tmp_var );
+00220                         else 
+00221                         {
+00222                                 delete tmp_var;
+00223                                 delete unified;
+00224                                 return NULL;
+00225                         }
+00226                         it_vt++;
+00227                         it_vu++;
+00228                 }
+00229                 return unified;
+00230                 */
+00231                 return NULL;
+00232         }
+
+

+ + + + +
+ + + + + + + + + + +
CVarSet * NLAILOGIC::CClause::unify CVarSet  )  [virtual, inherited]
+
+ + + + + +
+   + + +

+ +

+Reimplemented from NLAILOGIC::CVarSet. +

+Definition at line 351 of file clause.cpp. +

+

00352         {
+00353                 // TODO:
+00354 /*
+00355                 std::list<CValueSet *>::iterator it_l = _Liaisons.begin();
+00356                 while ( it_cond != _Conds.end() )
+00357                 {
+00358                         CVarSet *tmp = ( *it_cond )->unify( fact );
+00359                         
+00360                         if ( !tmp )
+00361                                 return;
+00362                         it_cond++;
+00363                 }
+00364                 */
+00365                 return NULL;
+00366         }
+
+

+ + + + +
+ + + + + + + + + + +
std::list< CValueSet * > * NLAILOGIC::CRule::unifyBack CFactPattern  ) 
+
+ + + + + +
+   + + +

+ +

+Definition at line 318 of file rule.cpp. +

+References NLAILOGIC::CVarSet::addVar(), NLAILOGIC::CVarSet::asCValueSet(), NLAILOGIC::CFactPattern::getAssert(), NLAILOGIC::CValueSet::getDebugString(), NLAILOGIC::CVarSet::getValues(), NLAILOGIC::CValueSet::setValue(), sint32, and unifyLiaisonBack(). +

+

00319         {
+00320                 std::list<CValueSet *> *unified_list = new std::list<CValueSet *>;
+00321                 
+00322                 // Vecteur temporaire des variables
+00323                 CVarSet *tmp_vars = new CVarSet;
+00324                 for (sint32 i = 0; i < (sint32) _Vars.size() ; i++)
+00325                         tmp_vars->addVar( _Vars[i] );
+00326 
+00327                 // Trouver l'assertion dans la conclusion
+00328                 std::vector<IBaseAssert *>::iterator it_a = _Concs.begin();
+00329                 std::vector< std::vector<sint32> >::iterator it_p = _PosVarsConc.begin();
+00330                 while ( it_a != _Concs.end() && (*it_a) != fp->getAssert() )
+00331                 {
+00332                         it_a++;
+00333                         it_p++;
+00334                 }
+00335                 if ( it_a == _Concs.end() )
+00336                         return NULL;
+00337 
+00338                 // Créé la liste des valeurs 
+00339                 std::list<IObjetOp *> *vals = fp->getValues();
+00340 
+00341                 // Pour chaque liaison...
+00342                 std::list< CValueSet *>::iterator it_l = _Liaisons.begin();
+00343                 
+00344                 while ( it_l != _Liaisons.end() )
+00345                 {
+00346                         CValueSet *l = *it_l;
+00347                         bool complete;
+00348                         CValueSet *result = unifyLiaisonBack( l, *vals, *it_p, complete );
+00349                         if ( result )
+00350                         {
+00351                                 if ( complete )
+00352                                 {
+00353                                         // Ceux là on les rajoute direct dans la liste
+00354                                         //char test[1024 * 2];
+00355                                         //result->getDebugString( test );
+00356                                         CValueSet *n = fp->asCValueSet();
+00357                                         sint32 pos_r = 0;
+00358                                         std::vector<sint32>::iterator it_i = (*it_p).begin();
+00359                                         while ( it_i != (*it_p).end() )
+00360                                         {
+00361 #ifdef NL_DEBUG
+00362                                                 std::string buf;
+00363                                                 (*result)[ *it_i ]->getDebugString(buf);
+00364 #endif
+00365 
+00366                                                 n->setValue( pos_r, (*result)[ *it_i ] );
+00367                                                 it_i++;
+00368                                                 pos_r++;
+00369                                         }
+00370                                         unified_list->push_back( n );
+00371                                 }
+00372 #ifdef NL_DEBUG
+00373                                 else 
+00374                                 {
+00375                                         // Ceux là on continue à les propager en arrière!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+00376 
+00377                                         std::string test;
+00378                                         result->getDebugString( test );
+00379                                 }
+00380 #endif
+00381                         }
+00382                         it_l++;
+00383                 }
+00384                 return unified_list;
+00385         }
+
+

+ + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + + +
CValueSet * NLAILOGIC::CClause::unifyLiaison const CValueSet,
std::list< NLAIAGENT::IObjectIA * > * ,
std::vector< sint32 > & 
[inherited]
+
+ + + + + +
+   + + +

+ +

+Definition at line 251 of file clause.cpp. +

+References NLAILOGIC::CValueSet::unify(). +

+Referenced by NLAILOGIC::CClause::propagate(). +

+

00252         {
+00253                 CValueSet *result;
+00254 
+00255                 if ( (result = fp->unify( vals, pos_vals )) )
+00256                         return result;
+00257                 else
+00258                 {
+00259                         delete result;
+00260                         return NULL;
+00261                 }
+00262         }
+
+

+ + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
CValueSet * NLAILOGIC::CRule::unifyLiaisonBack CValueSet,
std::list< NLAIAGENT::IObjetOp * > & ,
std::vector< sint32 > & ,
bool & 
+
+ + + + + +
+   + + +

+ +

+Definition at line 402 of file rule.cpp. +

+References NLAILOGIC::CValueSet::getDebugString(), NLAIC::IPointerGestion::release(), and sint32. +

+Referenced by unifyBack(). +

+

00403         {
+00404                 sint32 nb_undefined = pos.size();
+00405                 CValueSet *unified = new CValueSet( *liaison );
+00406                 std::vector<sint32>::iterator it_pos = pos.begin();
+00407                 std::list<IObjetOp *>::iterator it_v = vals.begin();
+00408                 while ( it_pos != pos.end() )
+00409                 {
+00410                         IObjectIA *l_val = (*unified)[*it_pos];
+00411                         IObjectIA *r_val = *it_v;
+00412                         if ( !l_val )
+00413                         {
+00414 /*                              if ( r_val )
+00415                                 {
+00416                                         unified->setValue( p , r_val );
+00417                                         nb_undefined--;
+00418                                 }*/
+00419                         }
+00420                         else
+00421                         {
+00422                                 if ( r_val && ( l_val != r_val ) )
+00423                                 {
+00424                                         unified->release();
+00425                                         return NULL;
+00426                                 }
+00427                                 else 
+00428                                         if ( r_val ) 
+00429                                                 nb_undefined--;
+00430                         }
+00431                         it_pos++;
+00432                         it_v++;
+00433                 }
+00434                 defined = ( nb_undefined == 0 );
+00435 
+00436 #ifdef NL_DEBUG
+00437                 std::string buf;
+00438                 unified->getDebugString(buf);
+00439 #endif
+00440 
+00441 
+00442                 return unified;
+00443         }
+
+


Field Documentation

+

+ + + + +
+ + +
std::vector<IBaseAssert *> NLAILOGIC::CClause::_Asserts [protected, inherited] +
+
+ + + + + +
+   + + +

+ +

+Definition at line 48 of file clause.h. +

+Referenced by NLAILOGIC::CClause::addCond(), and NLAILOGIC::CClause::findAssert().

+

+ + + + +
+ + +
std::list< CValueSet *> NLAILOGIC::CClause::_BufLiaisons [protected, inherited] +
+
+ + + + + +
+   + + +

+ +

+Definition at line 43 of file clause.h. +

+Referenced by NLAILOGIC::CClause::addBuffer(), NLAILOGIC::CClause::propagate(), NLAILOGIC::CClause::showBuffer(), and NLAILOGIC::CClause::~CClause().

+

+ + + + +
+ + +
std::vector<IBaseAssert *> NLAILOGIC::CRule::_Concs [private] +
+
+ + + + + +
+   + + +

+ +

+Definition at line 45 of file rule.h. +

+Referenced by CRule().

+

+ + + + +
+ + +
std::vector<IBaseBoolType *> NLAILOGIC::CClause::_Conds [protected, inherited] +
+
+ + + + + +
+   + + +

+ +

+Definition at line 40 of file clause.h. +

+Referenced by NLAILOGIC::CClause::CClause().

+

+ + + + +
+ + +
std::list< CValueSet *> NLAILOGIC::CClause::_Conflits [protected, inherited] +
+
+ + + + + +
+   + + +

+ +

+Definition at line 44 of file clause.h. +

+Referenced by NLAILOGIC::CClause::propagate(), NLAILOGIC::CClause::showConflicts(), and NLAILOGIC::CClause::~CClause().

+

+ + + + +
+ + +
bool NLAILOGIC::CClause::_FirstOrderTrue [protected, inherited] +
+
+ + + + + +
+   + + +

+ +

+Definition at line 50 of file clause.h.

+

+ + + + +
+ + +
std::list< CValueSet *> NLAILOGIC::CClause::_Liaisons [protected, inherited] +
+
+ + + + + +
+   + + +

+ +

+Definition at line 42 of file clause.h. +

+Referenced by NLAILOGIC::CClause::addBuffer(), NLAILOGIC::CClause::CClause(), NLAILOGIC::CClause::propagate(), NLAILOGIC::CClause::showLiaisons(), and NLAILOGIC::CClause::~CClause().

+

+ + + + +
+ + +
sint32 NLAILOGIC::CClause::_NbValid [protected, inherited] +
+
+ + + + + +
+   + + +

+ +

+Definition at line 45 of file clause.h. +

+Referenced by NLAILOGIC::CClause::CClause(), NLAILOGIC::CClause::isTrue(), NLAILOGIC::CClause::propagate(), and NLAILOGIC::CClause::truthValue().

+

+ + + + +
+ + +
std::vector< std::vector<sint32> > NLAILOGIC::CRule::_PosVarsConc [private] +
+
+ + + + + +
+   + + +

+ +

+Definition at line 46 of file rule.h. +

+Referenced by CRule().

+

+ + + + +
+ + +
std::vector< std::vector<sint32> > NLAILOGIC::CClause::_PosVarsCond [protected, inherited] +
+
+ + + + + +
+   + + +

+ +

+Definition at line 41 of file clause.h. +

+Referenced by NLAILOGIC::CClause::addCond(), and NLAILOGIC::CClause::CClause().

+

+ + + + +
+ + +
std::list<CBoolAssert *> NLAILOGIC::CClause::_SimpleConds [protected, inherited] +
+
+ + + + + +
+   + + +

+ +

+Definition at line 39 of file clause.h.

+

+ + + + +
+ + +
std::vector<IBaseVar *> NLAILOGIC::CVarSet::_Vars [protected, inherited] +
+
+ + + + + +
+   + + +

+ +

+Definition at line 39 of file varset.h. +

+Referenced by NLAILOGIC::CVarSet::CVarSet(), and NLAILOGIC::CVarSet::unify().

+

+ + + + +
+ + +
const NLAIC::CIdentType CClause::IdClause [static, inherited] +
+
+ + + + + +
+   + + +

+Initial value:

 NLAIC::CIdentType( "Clause", NLAIC::CSelfClassFactory(CClause()), 
+                NLAIC::CTypeOfObject::tLogic,
+                NLAIC::CTypeOfOperator::opAdd )
+
+

+Definition at line 437 of file static_def_init.cpp.

+

+ + + + +
+ + +
const NLAIC::CIdentType CRule::IdRule [static] +
+
+ + + + + +
+   + + +

+Initial value:

 NLAIC::CIdentType( "Rule", NLAIC::CSelfClassFactory(CRule()), 
+                NLAIC::CTypeOfObject::tLogic,
+                NLAIC::CTypeOfOperator::opAdd )
+
+

+Definition at line 441 of file static_def_init.cpp. +

+Referenced by getType().

+

+ + + + +
+ + +
const NLAIC::CIdentType CVarSet::IdVarSet [static, inherited] +
+
+ + + + + +
+   + + +

+ +

+Referenced by NLAILOGIC::CVarSet::getType().

+

+ + + + +
+ + +
sint32 NLAILOGIC::CVarSet::NbInstanciated [protected, inherited] +
+
+ + + + + +
+   + + +

+ +

+Definition at line 40 of file varset.h. +

+Referenced by NLAILOGIC::CVarSet::CVarSet(), NLAILOGIC::CVarSet::isUnified(), and NLAILOGIC::CVarSet::operator!().

+

+ + + + +
+ + +
TProcessStatement NLAIAGENT::IObjectIA::ProcessBuzzy = processBuzzy [static, inherited] +
+
+ + + + + +
+   + + +

+Define the an buzzy state for an agent all time in this state. +

+Definition at line 147 of file baseai.cpp.

+

+ + + + +
+ + +
TProcessStatement NLAIAGENT::IObjectIA::ProcessEnd = processEnd [static, inherited] +
+
+ + + + + +
+   + + +

+Define the an end state for an agent all time in this state. +

+Definition at line 148 of file baseai.cpp.

+

+ + + + +
+ + +
TProcessStatement NLAIAGENT::IObjectIA::ProcessError = processError [static, inherited] +
+
+ + + + + +
+   + + +

+Define the an error state for an agent all time in this state. +

+Definition at line 149 of file baseai.cpp.

+

+ + + + +
+ + +
TProcessStatement NLAIAGENT::IObjectIA::ProcessIdle = processIdle [static, inherited] +
+
+ + + + + +
+   + + +

+Define the an idle state for an agent all time in this state. +

+Definition at line 145 of file baseai.cpp.

+

+ + + + +
+ + +
TProcessStatement NLAIAGENT::IObjectIA::ProcessLocked = processLocked [static, inherited] +
+
+ + + + + +
+   + + +

+Define the an locked state for an agent all time in this state. +

+Definition at line 146 of file baseai.cpp.

+

+ + + + +
+ + +
IObjectIA::CProcessResult NLAIAGENT::IObjectIA::ProcessNotComplit = IObjectIA::CProcessResult(processNotComplete) [static, inherited] +
+
+ + + + + +
+   + + +

+ +

+Definition at line 144 of file baseai.cpp.

+

+ + + + +
+ + +
IObjectIA::CProcessResult NLAIAGENT::IObjectIA::ProcessRun = IObjectIA::CProcessResult() [static, inherited] +
+
+ + + + + +
+   + + +

+ +

+Definition at line 143 of file baseai.cpp.

+


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