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

NLAILOGIC::CFirstOrderOperator Class Reference

#include <fo_operator.h> +

+

Inheritance diagram for NLAILOGIC::CFirstOrderOperator: +

+ +NLAILOGIC::IBaseOperator +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

void addPostcondition (CFactPattern *)
 Adds a first order logic postcondition to the operator.

void addPrecondition (CFactPattern *)
 Adds a first order logic precondition to the operator.

std::list< CFact * > * backward (std::list< CFact * > &)
 Returns the result of backarding a list of facts through the operator.

std::list< CFactPattern * > * backward (CFactPattern *)
 Gives the precondition for a CFact in the postconditions.

virtual TQueue canProcessMessage (const IVarName &)
 CFirstOrderOperator (const CFirstOrderOperator &)
 CFirstOrderOperator ()
virtual const NLAIC::IBasicTypeclone () const
sint32 decRef ()
 Decrement the reference of an object.

virtual void failure (IBaseOperator *)
virtual void failure ()
std::list< CFact * > * forward (std::list< CFact * > &)
 Returns the conclusions of the operator for given preconditions facts.

std::list< CFactPattern * > * forward (CFactPattern *)
 Gives the postcondition for a CFact in the preconditions.

virtual void getDebugString (std::string &) const
virtual const std::string getInfo ()
virtual std::string getMethodeMemberDebugString (sint32, sint32) const
virtual IObjetOpgetNeg () const
const std::vector< IBaseAssert * > & getPostCondAsserts () const
const std::vector< IBaseAssert * > & getPrecondAsserts () const
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
const NLAIC::CIdentTypegetType () const
void incRef ()
 Inc a reference. We use this when we have to conserve a pointer memeory for exemple in a list.

virtual void init (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 CFirstOrderOperator &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
 Returns true if the preconditions are validated.

virtual bool isValid (CFactBase *)
 Asks wether the operator's preconditions are validated,.

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

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

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

virtual IObjetOpoperator!= (IObjetOp &) 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 IObjetOpoperator== (IObjetOp &) const
 throw (NLAIE::CExceptionNotImplemented)

virtual bool operator== (CFirstOrderOperator *)
virtual IObjetOpoperator> (IObjetOp &) const
 throw (NLAIE::CExceptionNotImplemented)

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

virtual float priority () const
 Priority of the operator.

std::list< CFact * > * propagate (std::list< CFact * > &)
 Propagates facts through the operator and network of asserts/ operators.

virtual void release ()
 Release allow to release the pointer. The last release when the _Ref is nul delete the object.

virtual const NLAIAGENT::IObjectIA::CProcessResultrun ()
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 setComment (char *)
 Sets teh comment for the operator.

virtual void setGoal (IBaseAssert *)
 Sets the goals the operator tries to achieve.

virtual bool setStaticMember (sint32, IObjectIA *)
bool setStaticMember (const IVarName &compName, IObjectIA *change)
virtual void success (IBaseOperator *)
virtual void success ()
std::list< CFact * > * test (std::list< CFact * > &)
virtual float truthValue () const
 Returns a value in [0,1].

 ~CFirstOrderOperator ()

Static Public Attributes

const NLAIC::CIdentType IdCFirstOrderOperator
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

CFactbuildFromVars (IBaseAssert *, std::vector< sint32 > &, CValueSet *)
sint32 CFirstOrderOperator::getVarPos (IBaseVar *var)
 Returns the pos of a vraiables in the operator's vars table, -1 if not found.

void compileFactPattern (CFactPattern *, std::vector< IBaseAssert * > &, std::vector< sint32 > &)
 Pos of a postcondition pattern's vars in the operator's vars tableTransforms a CFactPattern in an assert and a list of variable positions in the operator.

void getAssertPos (IBaseAssert *, std::vector< IBaseAssert * > &, std::vector< sint32 > &)
void getPosListBackward (sint32, sint32, std::vector< sint32 > &)
void getPosListForward (sint32, sint32, std::vector< sint32 > &)
std::list< CValueSet * > * propagate (std::list< CValueSet * > &, CValueSet *, std::vector< sint32 > &)
 Forward chaining.

CValueSetunifyBackward (std::list< CFact * > &)
CValueSetunifyForward (std::list< CFact * > &)
CValueSetunifyLiaison (const CValueSet *, CValueSet *, std::vector< sint32 > &)
 Tries to unify an instaciation of the operator's variables with a new CFact.


Protected Attributes

char * _Comment
 Description of the operator.

std::vector< IBaseAssert * > _Concs
 Postconditions asserts.

std::vector< IBaseAssert * > _Conds
 Preconditions asserts.

IBaseAssert_Goal
std::vector< std::vector<
+ sint32 > > 
_PosVarsConc
 Pos of a precondition pattern's vars in the operator's vars table.

std::vector< std::vector<
+ sint32 > > 
_PosVarsCond
 Variables of the operator.

std::vector< IBaseVar * > _Vars
+

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::CFirstOrderOperator::CFirstOrderOperator  ) 
+
+ + + + + +
+   + + +

+ +

+Definition at line 35 of file fo_operator.cpp. +

+Referenced by clone(). +

+

00036         {
+00037                 _Comment = NULL;
+00038         }
+
+

+ + + + +
+ + + + + + + + + + +
NLAILOGIC::CFirstOrderOperator::CFirstOrderOperator const CFirstOrderOperator  ) 
+
+ + + + + +
+   + + +

+ +

+Definition at line 40 of file fo_operator.cpp. +

+References NLAILOGIC::IBaseOperator::_Comment, NLAILOGIC::IBaseOperator::_Concs, NLAILOGIC::IBaseOperator::_Conds, _PosVarsConc, and _PosVarsCond. +

+

00041         {
+00042                 if ( c._Comment )
+00043                 {
+00044                         _Comment = new char[ strlen( c._Comment ) ];
+00045                         strcpy( _Comment, c._Comment );
+00046                 }
+00047                 else
+00048                         _Comment = NULL;
+00049 
+00050                 std::vector<IBaseAssert *>::const_iterator it_c = c._Concs.begin();
+00051                 while ( it_c != c._Concs.end() )
+00052                 {
+00053                         _Concs.push_back( *it_c );
+00054                         it_c++;
+00055                 }
+00056 
+00057                 it_c = c._Conds.begin();
+00058                 while ( it_c != c._Conds.end() )
+00059                 {
+00060                         _Conds.push_back( *it_c );
+00061                         it_c++;
+00062                 }
+00063 
+00064                 std::vector< std::vector<sint32> >::const_iterator it_li = c._PosVarsCond.begin();
+00065                 while ( it_li != c._PosVarsCond.end() )
+00066                 {
+00067                         std::vector<sint32>::const_iterator it_i = (*it_li).begin();
+00068                         _PosVarsCond.push_back( std::vector<sint32>() );
+00069 
+00070                         while ( it_i != (*it_li).end() )
+00071                         {
+00072                                 _PosVarsCond.back().push_back( *it_i ) ;
+00073                                 it_i++;
+00074                         }
+00075                         it_li++;
+00076                 }
+00077 
+00078                 it_li = c._PosVarsConc.begin();
+00079                 while ( it_li != c._PosVarsConc.end() )
+00080                 {
+00081                         std::vector<sint32>::const_iterator it_i = (*it_li).begin();
+00082                         _PosVarsConc.push_back( std::vector<sint32>() );
+00083 
+00084                         while ( it_i != (*it_li).end() )
+00085                         {
+00086                                 _PosVarsConc.back().push_back( *it_i ) ;
+00087                                 it_i++;
+00088                         }
+00089                         it_li++;
+00090                 }
+00091         }
+
+

+ + + + +
+ + + + + + + + + +
NLAILOGIC::CFirstOrderOperator::~CFirstOrderOperator  ) 
+
+ + + + + +
+   + + +

+ +

+Definition at line 109 of file fo_operator.cpp. +

+References sint32. +

+

00110         {
+00111                 for ( sint32 i = 0; i < (sint32) _Vars.size() ; i++ )
+00112                         _Vars[ i ]->release();
+00113         }
+
+


Member Function Documentation

+

+ + + + +
+ + + + + + + + + + +
void NLAILOGIC::CFirstOrderOperator::addPostcondition CFactPattern  ) 
+
+ + + + + +
+   + + +

+Adds a first order logic postcondition to the operator. +

+ +

+Definition at line 159 of file fo_operator.cpp. +

+References _PosVarsConc, NLAILOGIC::IBaseAssert::addInput(), compileFactPattern(), and NLAILOGIC::CFactPattern::getAssert(). +

+

00160         {
+00161                 if ( pattern->getAssert() )
+00162                 {
+00163                         std::vector<sint32> pos_Vars;
+00164                         compileFactPattern( pattern, _Conds, pos_Vars);
+00165 
+00166                         pattern->getAssert()->addInput( this );
+00167                         _Concs.push_back( pattern->getAssert() );
+00168                         _PosVarsConc.push_back( pos_Vars );
+00169                 }
+00170         }
+
+

+ + + + +
+ + + + + + + + + + +
void NLAILOGIC::CFirstOrderOperator::addPrecondition CFactPattern  ) 
+
+ + + + + +
+   + + +

+Adds a first order logic precondition to the operator. +

+ +

+Definition at line 145 of file fo_operator.cpp. +

+References compileFactPattern(), and NLAILOGIC::CFactPattern::getAssert(). +

+

00146         {
+00147                 if ( pattern->getAssert() )
+00148                 {
+00149                         std::vector<sint32> pos_Vars;
+00150                         compileFactPattern( pattern, _Conds, pos_Vars);
+00151 
+00152 //                      pattern->getAssert()->addClause( this, pos_Vars );
+00153                         _Conds.push_back( pattern->getAssert() );
+00154                         _PosVarsCond.push_back( pos_Vars );
+00155 
+00156                 }
+00157         }
+
+

+ + + + +
+ + + + + + + + + + +
std::list< CFact * > * NLAILOGIC::CFirstOrderOperator::backward std::list< CFact * > &   )  [virtual]
+
+ + + + + +
+   + + +

+Returns the result of backarding a list of facts through the operator. +

+ +

+Implements NLAILOGIC::IBaseOperator. +

+Definition at line 313 of file fo_operator.cpp. +

+References buffer, buildFromVars(), NLAILOGIC::CFact::getDebugString(), NLAIC::IPointerGestion::release(), sint32, and unifyBackward(). +

+

00314         {
+00315                 CValueSet *unified = unifyBackward( facts );
+00316                 std::list<CFact *> *result = new std::list<CFact *>;
+00317                 for (sint32 i = 0; i < (sint32) _Conds.size(); i++ )
+00318                 {
+00319                         CFact *tmp = buildFromVars( _Conds[i], _PosVarsCond[i], unified );
+00320                         result->push_back( tmp );
+00321 #ifdef NL_DEBUG
+00322                         std::string buffer;
+00323                         tmp->getDebugString(buffer);
+00324 #endif
+00325                 }
+00326                 unified->release();
+00327                 return result;
+00328         }
+
+

+ + + + +
+ + + + + + + + + + +
std::list<CFactPattern *>* NLAILOGIC::CFirstOrderOperator::backward CFactPattern  ) 
+
+ + + + + +
+   + + +

+Gives the precondition for a CFact in the postconditions. +

+ +

+Referenced by test().

+

+ + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + + +
CFact * NLAILOGIC::CFirstOrderOperator::buildFromVars IBaseAssert,
std::vector< sint32 > & ,
CValueSet
[protected]
+
+ + + + + +
+   + + +

+ +

+Definition at line 303 of file fo_operator.cpp. +

+References assert, NLAILOGIC::CValueSet::setValue(), and sint32. +

+Referenced by backward(), forward(), and propagate(). +

+

00304         {
+00305                 CFact *result = new CFact( assert);     // TODO:: pas besoin du nombre dans ce constructeur puisqu'on a l'assert
+00306                 for (sint32 i = 0; i < (sint32) pl.size() ; i++ )
+00307                 {
+00308                         result->setValue( i, (*vars)[ pl[i] ] );
+00309                 }
+00310                 return result;
+00311         }
+
+

+ + + + +
+ + + + + + + + + + +
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         }
+
+

+ + + + +
+ + + + + + + + + + +
sint32 NLAILOGIC::CFirstOrderOperator::CFirstOrderOperator::getVarPos IBaseVar var  )  [protected]
+
+ + + + + +
+   + + +

+Returns the pos of a vraiables in the operator's vars table, -1 if not found. +

+

+

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

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

+Implements NLAIC::IBasicType. +

+Definition at line 486 of file fo_operator.cpp. +

+References CFirstOrderOperator(). +

+

00487         {
+00488                 CFirstOrderOperator *clone = new CFirstOrderOperator( *this );
+00489                 return clone;
+00490         }
+
+

+ + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + + +
void NLAILOGIC::CFirstOrderOperator::compileFactPattern CFactPattern,
std::vector< IBaseAssert * > & ,
std::vector< sint32 > & 
[protected]
+
+ + + + + +
+   + + +

+Pos of a postcondition pattern's vars in the operator's vars tableTransforms a CFactPattern in an assert and a list of variable positions in the operator. +

+ +

+Definition at line 115 of file fo_operator.cpp. +

+References NLAILOGIC::CVarSet::getVars(), and sint32. +

+Referenced by addPostcondition(), and addPrecondition(). +

+

00116         {
+00117                 // Recherche si variables à ajouter
+00118                 std::vector<IBaseVar *> *vars_pattern = fp->getVars();
+00119                 if ( vars_pattern )
+00120                 {
+00121                         std::vector<IBaseVar *>::iterator it_cond = vars_pattern->begin();
+00122                         while ( it_cond != vars_pattern->end() )
+00123                         {
+00124                                 sint32 id_var = getVarPos( *it_cond );
+00125                                 if ( id_var != -1 )
+00126                                 {
+00127                                         pos_Vars.push_back( id_var );
+00128                                 }
+00129                                 else
+00130                                 {
+00131                                         _Vars.push_back( (IBaseVar *)(*it_cond)->clone() );
+00132                                         pos_Vars.push_back( _Vars.size() - 1);
+00133                                 }
+00134                                 it_cond++;
+00135                         }
+00136                 }
+00137 
+00138                 for ( sint32 i = 0; i < (sint32) vars_pattern->size(); i++ )
+00139                 {
+00140                         (*vars_pattern)[i]->release();
+00141                 }
+00142                 delete vars_pattern;
+00143         }
+
+

+ + + + +
+ + + + + + + + + +
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                 }
+
+

+ + + + +
+ + + + + + + + + + +
void NLAILOGIC::CFirstOrderOperator::failure IBaseOperator  )  [virtual]
+
+ + + + + +
+   + + +

+ +

+Implements NLAILOGIC::IBaseOperator. +

+Definition at line 644 of file fo_operator.cpp. +

+

00645         {
+00646         }
+
+

+ + + + +
+ + + + + + + + + +
void NLAILOGIC::CFirstOrderOperator::failure  )  [virtual]
+
+ + + + + +
+   + + +

+ +

+Implements NLAILOGIC::IBaseOperator. +

+Definition at line 636 of file fo_operator.cpp. +

+

00637         {
+00638         }
+
+

+ + + + +
+ + + + + + + + + + +
std::list< CFact * > * NLAILOGIC::CFirstOrderOperator::forward std::list< CFact * > &   )  [virtual]
+
+ + + + + +
+   + + +

+Returns the conclusions of the operator for given preconditions facts. +

+ +

+Implements NLAILOGIC::IBaseOperator. +

+Definition at line 330 of file fo_operator.cpp. +

+References _PosVarsConc, buffer, buildFromVars(), NLAILOGIC::CFact::getDebugString(), NLAILOGIC::CValueSet::getDebugString(), NLAIC::IPointerGestion::release(), sint32, and unifyForward(). +

+

00331         {
+00332                 CValueSet *unified = unifyForward( facts );
+00333 
+00334 #ifdef NL_DEBUG
+00335                 std::string buf;
+00336                 unified->getDebugString( buf );
+00337 #endif
+00338 
+00339                 std::list<CFact *> *result = new std::list<CFact *>;
+00340                 for (sint32 i = 0; i < (sint32) _Concs.size(); i++ )
+00341                 {
+00342                         CFact *tmp = buildFromVars( _Concs[i], _PosVarsConc[i], unified );
+00343                         result->push_back( tmp );
+00344 
+00345 #ifdef NL_DEBUG
+00346                         std::string buffer;
+00347                         tmp->getDebugString(buffer);
+00348 #endif
+00349                 }
+00350                 unified->release();
+00351                 return result;
+00352         }
+
+

+ + + + +
+ + + + + + + + + + +
std::list< CFactPattern * > * NLAILOGIC::CFirstOrderOperator::forward CFactPattern  ) 
+
+ + + + + +
+   + + +

+Gives the postcondition for a CFact in the preconditions. +

+ +

+Definition at line 220 of file fo_operator.cpp. +

+

00221         {
+00222                 return NULL;            
+00223         }
+
+

+ + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + + +
void NLAILOGIC::CFirstOrderOperator::getAssertPos IBaseAssert,
std::vector< IBaseAssert * > & ,
std::vector< sint32 > & 
[protected]
+
+ + + + + +
+   + + +

+ +

+Definition at line 211 of file fo_operator.cpp. +

+References sint32. +

+Referenced by propagate(), unifyBackward(), and unifyForward(). +

+

00212         {
+00213                 for (sint32 i = 0; i < (sint32) l.size() ; i++ )
+00214                 {
+00215                         if ( (*(l[i])) == a )
+00216                                 pos.push_back(i);
+00217                 }
+00218         }
+
+

+ + + + +
+ + + + + + + + + +
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::CFirstOrderOperator::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. +

+Implements NLAIC::IBasicType. +

+Definition at line 506 of file fo_operator.cpp. +

+References _PosVarsConc, and sint32. +

+

00507         {
+00508                 txt += "Operator:\n   -Preconditions:\n";
+00509                 if ( _Comment )
+00510                 {
+00511                         txt += _Comment;
+00512                         txt += "\n";
+00513                 }
+00514 
+00515                 std::vector<IBaseAssert *>::const_iterator it_a = _Conds.begin();
+00516                 std::vector<std::vector<sint32> >::const_iterator it_p = _PosVarsCond.begin();
+00517                 while ( it_a != _Conds.end() )
+00518                 {
+00519                         std::string buf;
+00520                         (*it_a)->getDebugString(buf);
+00521                         txt += "    ( ";
+00522                         txt += buf;
+00523                         for (sint32 i = 0; i < (sint32) (*it_p).size(); i++ )
+00524                         {
+00525                                 txt += _Vars[ (*it_p)[i] ]->getName().getString();
+00526                                 txt += " ";
+00527                         }
+00528                         txt += ")\n";
+00529 
+00530                         it_a++;
+00531                         it_p++;
+00532                 }
+00533 
+00534                 txt += "  -Postconditions:\n";
+00535                 it_a = _Concs.begin();
+00536                 it_p = _PosVarsConc.begin();
+00537                 while ( it_a != _Concs.end() )
+00538                 {
+00539                         std::string buf;
+00540                         (*it_a)->getDebugString(buf);
+00541                         txt += "    ( ";
+00542                         txt += buf;
+00543                         for (sint32 i = 0; i < (sint32) (*it_p).size(); i++ )
+00544                         {
+00545                                 txt += _Vars[ (*it_p)[i] ]->getName().getString();
+00546                                 txt += " ";
+00547                         }
+00548                         txt += ")\n";
+00549 
+00550                         it_a++;
+00551                         it_p++;
+00552                 }
+00553         }
+
+

+ + + + +
+ + + + + + + + + +
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::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::CFirstOrderOperator::getPosListBackward sint32 ,
sint32 ,
std::vector< sint32 > & 
[protected]
+
+ + + + + +
+   + + +

+ +

+Definition at line 174 of file fo_operator.cpp. +

+References _PosVarsConc, and sint32. +

+

00175         {
+00176                 std::vector<sint32>::iterator it_conc = _PosVarsConc[ no_conc ].begin();
+00177                 while ( it_conc != _PosVarsConc[ no_conc ].end() )
+00178                 {
+00179                         std::vector<sint32>::iterator it_cond = _PosVarsCond[ no_cond ].begin();
+00180                         while ( it_cond != _PosVarsCond[ no_cond ].end() )
+00181                         {
+00182                                 if ( (*it_conc) == (*it_cond) )
+00183                                 {
+00184                                         cond_pos.push_back( *it_cond );
+00185                                 }
+00186                                 it_cond++;
+00187                         }
+00188                         it_conc++;
+00189                 }
+00190         }
+
+

+ + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + + +
void NLAILOGIC::CFirstOrderOperator::getPosListForward sint32 ,
sint32 ,
std::vector< sint32 > & 
[protected]
+
+ + + + + +
+   + + +

+ +

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

+References _PosVarsConc, and sint32. +

+

00194         {
+00195                 std::vector<sint32>::iterator it_cond = _PosVarsCond[ no_cond ].begin();
+00196                 while ( it_cond != _PosVarsCond[ no_cond ].end() )
+00197                 {
+00198                         std::vector<sint32>::iterator it_conc = _PosVarsConc[ no_conc ].begin();
+00199                         while ( it_conc != _PosVarsConc[ no_conc ].end() )
+00200                         {
+00201                                 if ( (*it_cond) == (*it_conc) )
+00202                                 {
+00203                                         conc_pos.push_back( *it_conc );
+00204                                 }
+00205                                 it_conc++;
+00206                         }
+00207                         it_cond++;
+00208                 }
+00209         } 
+
+

+ + + + +
+ + + + + + + + + +
const std::vector< IBaseAssert * > & NLAILOGIC::IBaseOperator::getPostCondAsserts  )  const [inherited]
+
+ + + + + +
+   + + +

+ +

+Definition at line 97 of file operator.cpp. +

+

00098         {
+00099                 return _Concs;
+00100         }
+
+

+ + + + +
+ + + + + + + + + +
const std::vector< IBaseAssert * > & NLAILOGIC::IBaseOperator::getPrecondAsserts  )  const [inherited]
+
+ + + + + +
+   + + +

+ +

+Definition at line 92 of file operator.cpp. +

+

00093         {
+00094                 return _Conds;
+00095         }
+
+

+ + + + +
+ + + + + + + + + +
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::CFirstOrderOperator::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). +

+Implements NLAIC::IBasicType. +

+Definition at line 575 of file fo_operator.cpp. +

+References IdCFirstOrderOperator. +

+

00576         {
+00577                 return IdCFirstOrderOperator;
+00578         }
+
+

+ + + + +
+ + + + + + + + + +
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 NLAIAGENT::IObjectIA::init IObjectIA  )  [virtual, inherited]
+
+ + + + + +
+   + + +

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

+Reimplemented in NLAIFUZZY::CSimpleFuzzyCond, NLAIFUZZY::CFuzzyRule, NLAIFUZZY::CFuzzyRuleSet, NLAIFUZZY::CFuzzyInterval, NLAIFUZZY::CRightFuzzySet, NLAIFUZZY::CTriangleFuzzySet, NLAIFUZZY::CTrapezeFuzzySet, NLAIFUZZY::CLeftFuzzySet, NLAIFUZZY::CFuzzyVar, NLAILOGIC::CFirstOrderAssert, NLAILOGIC::CRule, and NLAILOGIC::CFactPattern. +

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

+Referenced by NLAIFUZZY::IFuzzySet::runMethodeMember(), and NLAISCRIPT::CLdbNewOpCode::runOpCode(). +

+

00117         {
+00118                 
+00119         }
+
+

+ + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + + +
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::CFirstOrderOperator::isEqual const NLAIAGENT::IBasicObjectIA a  )  const
+
+ + + + + +
+   + + +

+ +

+Definition at line 565 of file fo_operator.cpp. +

+

00566         {
+00567                 return false;           
+00568         }
+
+

+ + + + +
+ + + + + + + + + + +
bool NLAILOGIC::CFirstOrderOperator::isEqual const CFirstOrderOperator a  )  const [virtual]
+
+ + + + + +
+   + + +

+ +

+Definition at line 555 of file fo_operator.cpp. +

+

00556         {
+00557                 return false;
+00558         }
+
+

+ + + + +
+ + + + + + + + + +
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::CFirstOrderOperator::isTrue  )  const [virtual]
+
+ + + + + +
+   + + +

+Returns true if the preconditions are validated. +

+ +

+Implements NLAIAGENT::IObjetOp. +

+Definition at line 570 of file fo_operator.cpp. +

+

00571         {
+00572                 return false;
+00573         }
+
+

+ + + + +
+ + + + + + + + + + +
bool NLAILOGIC::CFirstOrderOperator::isValid CFactBase  )  [virtual]
+
+ + + + + +
+   + + +

+Asks wether the operator's preconditions are validated,. +

+ +

+Implements NLAILOGIC::IBaseOperator. +

+Definition at line 591 of file fo_operator.cpp. +

+References buffer, NLAILOGIC::CFactBase::getAssertFacts(), propagate(), res, and sint32. +

+

00592         {               
+00593                 std::list<CFact *> *facts = new std::list<CFact *>;
+00594                 for (sint32 i = 0; i < (sint32) _Conds.size(); i++ )
+00595                 {
+00596                         std::list<CFact *> *fa = fb->getAssertFacts( _Conds[i] );
+00597                         while ( fa->size() )
+00598                         {
+00599                                 facts->push_back( fa->front() );
+00600                                 fa->pop_front();
+00601                         }
+00602                         delete fa;
+00603                 }
+00604                 std::list<CFact *> *res = propagate( *facts );
+00605                 bool is_valid = !res->empty();
+00606                 while ( res->size() )
+00607                 {
+00608 #ifdef NL_DEBUG
+00609                         std::string buffer;
+00610                         res->front()->getDebugString( buffer );
+00611 #endif
+00612                         res->front()->release();
+00613                         res->pop_front();
+00614                 }
+00615                 delete res;
+00616 
+00617                 while ( facts->size() )
+00618                 {
+00619                         facts->front()->release();
+00620                         facts->pop_front();     
+00621                 }
+00622                 delete facts;
+00623 
+00624                 return is_valid;
+00625         }
+
+

+ + + + +
+ + + + + + + + + + +
void NLAILOGIC::CFirstOrderOperator::load NLMISC::IStream is  )  [virtual]
+
+ + + + + +
+   + + +

+Load the class from a stream. +

+Reimplemented from NLAILOGIC::IBaseOperator. +

+Definition at line 502 of file fo_operator.cpp. +

+

00503         {
+00504         }
+
+

+ + + + +
+ + + + + + + + + +
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::CFirstOrderOperator::newInstance  )  const [virtual]
+
+ + + + + +
+   + + +

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

+Implements NLAIC::IBasicType. +

+Definition at line 492 of file fo_operator.cpp. +

+

00493         {
+00494                 CFirstOrderOperator *instance = new CFirstOrderOperator;
+00495                 return instance;
+00496         }
+
+

+ + + + +
+ + + + + + + + + + +
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                 }
+
+

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

+throw (NLAIE::CExceptionNotImplemented) +

+ +

+Reimplemented in NLAIAGENT::INombre< tNombre >, NLAIAGENT::IBaseGroupType, NLAIAGENT::IListBasicManager, NLAIFUZZY::FuzzyType, NLAILOGIC::CBoolType, NLAILOGIC::CClause, NLAILOGIC::CValueSet, NLAILOGIC::CVarSet, 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 245 of file agent_operator.h. +

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

+

00246                 {
+00247                         std::string text;
+00248                         text = NLAIC::stringGetBuild("opertor <virtual IObjetOp *operator ! ()  const> note implemented for the '%s' interface",(const char *)getType());
+00249                         throw NLAIE::CExceptionNotImplemented(text.c_str());
+00250                         return (IObjetOp *)this;
+00251                 }
+
+

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

+throw (NLAIE::CExceptionNotImplemented) +

+ +

+Reimplemented in NLAIAGENT::IVector, NLAIAGENT::INombre< tNombre >, NLAIAGENT::CStringType, NLAIFUZZY::FuzzyType, NLAILOGIC::CBoolType, NLAILOGIC::CClause, NLAILOGIC::CVarSet, 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 252 of file agent_operator.h. +

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

+

00253                 {
+00254                         std::string text;
+00255                         text = NLAIC::stringGetBuild("opertor <virtual IObjetOp *operator != (const IObjetOp &a)  const> note implemented for the '%s' interface",(const char *)getType());
+00256                         throw NLAIE::CExceptionNotImplemented(text.c_str());
+00257                         return (IObjetOp *)this;
+00258                 }               
+
+

+ + + + +
+ + + + + + + + + + +
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         }               
+
+

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

+throw (NLAIE::CExceptionNotImplemented) +

+ +

+Reimplemented in NLAIAGENT::IVector, NLAIAGENT::INombre< tNombre >, NLAIAGENT::CStringType, NLAIFUZZY::CFuzzyRule, NLAIFUZZY::FuzzyType, NLAIFUZZY::CFuzzyVar, NLAILOGIC::CBoolType, NLAILOGIC::CClause, NLAILOGIC::CVar, 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 260 of file agent_operator.h. +

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

+

00261                 {
+00262                         std::string text;
+00263                         text = NLAIC::stringGetBuild("opertor <virtual IObjetOp *operator == (const IObjetOp &a)  const> note implemented for the '%s' interface",(const char *)getType());
+00264                         throw NLAIE::CExceptionNotImplemented(text.c_str());
+00265                         return (IObjetOp *)this;
+00266                 }
+
+

+ + + + +
+ + + + + + + + + + +
bool NLAILOGIC::CFirstOrderOperator::operator== CFirstOrderOperator  )  [virtual]
+
+ + + + + +
+   + + +

+ +

+Definition at line 580 of file fo_operator.cpp. +

+

00581         {
+00582                 return false;
+00583         }
+
+

+ + + + +
+ + + + + + + + + + +
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                 }
+
+

+ + + + +
+ + + + + + + + + +
float NLAILOGIC::CFirstOrderOperator::priority  )  const [virtual]
+
+ + + + + +
+   + + +

+Priority of the operator. +

+ +

+Implements NLAILOGIC::IBaseOperator. +

+Definition at line 627 of file fo_operator.cpp. +

+

00628         {
+00629                 return 0.0;
+00630         }
+
+

+ + + + +
+ + + + + + + + + + +
std::list< CFact * > * NLAILOGIC::CFirstOrderOperator::propagate std::list< CFact * > &   )  [virtual]
+
+ + + + + +
+   + + +

+Propagates facts through the operator and network of asserts/ operators. +

+ +

+Implements NLAILOGIC::IBaseOperator. +

+Definition at line 355 of file fo_operator.cpp. +

+References _PosVarsConc, buildFromVars(), getAssertPos(), propagate(), r, and sint32. +

+

00356         {
+00357                 std::list<CFact *> *conflicts = new std::list<CFact *>;
+00358                 std::list< CValueSet *> liaisons;
+00359                 CValueSet *empty = new CValueSet( _Vars.size() );
+00360                 liaisons.push_back( empty );
+00361 
+00362                 std::list<CFact *>::iterator it_f = facts.begin();
+00363                 while ( it_f != facts.end() )
+00364                 {
+00365                         std::vector<sint32> pos_asserts;
+00366                         getAssertPos( (*it_f)->getAssert() , _Conds, pos_asserts);
+00367                         for (sint32 i = 0; i < (sint32) pos_asserts.size(); i++ )
+00368                         {
+00369                                 std::list<CValueSet *> *links = propagate( liaisons, *it_f, _PosVarsCond[ pos_asserts[i] ] );
+00370                                 if ( links )
+00371                                 {
+00372                                         while ( links->size() )
+00373                                         {
+00374                                                 for (sint32 i = 0; i < (sint32) _Concs.size(); i++ )
+00375                                                 {
+00376                                                         CFact *r = buildFromVars( _Concs[i], _PosVarsConc[i], links->front() );
+00377 #ifdef NL_DEBUG
+00378                                                         std::string buf;
+00379                                                         r->getDebugString( buf );
+00380 #endif
+00381                                                         // Tests if the fact is already in the conflicts list
+00382                                                         bool found = false;
+00383                                                         std::list<CFact *>::iterator it_c = conflicts->begin();
+00384                                                         while ( ! found && it_c != conflicts->end() )
+00385                                                         {
+00386                                                                 found = (**it_c) == *r;
+00387                                                                 it_c++;
+00388                                                         }
+00389                                                         if ( !found )
+00390                                                         {
+00391 #ifdef NL_DEBUG
+00392                                                                 std::string buf;
+00393                                                                 r->getDebugString( buf );
+00394 #endif
+00395                                                                 conflicts->push_back( r );
+00396                                                         }
+00397                                                 }
+00398                                                 links->front()->release();
+00399                                                 links->pop_front();
+00400                                         }
+00401                                         delete links;
+00402                                 }
+00403                         }
+00404                         it_f++;
+00405                 }
+00406 
+00407                 while ( liaisons.size() )
+00408                 {
+00409                         liaisons.front()->release();
+00410                         liaisons.pop_front();
+00411                 }
+00412 
+00413                 return conflicts;
+00414         }
+
+

+ + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + + +
std::list< CValueSet * > * NLAILOGIC::CFirstOrderOperator::propagate std::list< CValueSet * > & ,
CValueSet,
std::vector< sint32 > & 
[protected]
+
+ + + + + +
+   + + +

+Forward chaining. +

+ +

+Definition at line 429 of file fo_operator.cpp. +

+References NLAILOGIC::CValueSet::getDebugString(), NLAILOGIC::CValueSet::undefined(), and unifyLiaison(). +

+Referenced by isValid(), and propagate(). +

+

00430         {
+00431                 std::list<CValueSet *> *conflits = new std::list<CValueSet *>;
+00432                 std::list<CValueSet *> buf_liaisons;
+00433                 // Pour chaque liaison...
+00434                 std::list< CValueSet *>::iterator it_l = liaisons.begin();
+00435                 
+00436                 while ( it_l != liaisons.end() )
+00437                 {
+00438 
+00439                         CValueSet *l = *it_l;
+00440 #ifdef NL_DEBUG
+00441                         std::string buf;
+00442                         l->getDebugString( buf );
+00443 #endif
+00444 
+00445                         CValueSet *result = unifyLiaison( l, fact, pos_vals );
+00446                         if ( result )
+00447                         {
+00448 #ifdef NL_DEBUG
+00449                                 std::string buf;
+00450                                 result->getDebugString( buf );
+00451 #endif
+00452 
+00453                                 if ( result->undefined() == 0 )
+00454                                 {
+00455                                         conflits->push_back( result );
+00456                                 }
+00457                                 else 
+00458                                         buf_liaisons.push_back( result );
+00459                         }
+00460                         it_l++;
+00461                 }
+00462 
+00463                 while ( buf_liaisons.size() )
+00464                 {
+00465                         liaisons.push_back( buf_liaisons.front() );
+00466                         buf_liaisons.pop_front();
+00467                 }
+00468 
+00469                 return conflits;
+00470         }       
+
+

+ + + + +
+ + + + + + + + + + +
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(), 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(), forward(), NLAIAGENT::CComponentHandle::getComponent(), NLAIAGENT::COperatorScript::getDebugString(), NLAIAGENT::CAgentScript::getDebugString(), NLAILOGIC::IBaseOperator::IBaseOperator(), NLAISCRIPT::CCompilateur::ifInterrogation(), NLAISCRIPT::CCompilateur::ifInterrogationEnd(), NLAILOGIC::CFactPattern::init(), NLAILOGIC::CRule::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(), unifyBackward(), NLAISCRIPT::COperatorClass::unifyForward(), unifyForward(), NLAILOGIC::CRule::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                 }
+
+

+ + + + +
+ + + + + + + + + +
const IObjectIA::CProcessResult & NLAILOGIC::CFirstOrderOperator::run  )  [virtual]
+
+ + + + + +
+   + + +

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

+Implements NLAILOGIC::IBaseBoolType. +

+Definition at line 560 of file fo_operator.cpp. +

+

00561         {               
+00562                 return IObjectIA::ProcessRun;
+00563         }
+
+

+ + + + +
+ + + + + + + + + + + + + + + + + + + +
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::CFirstOrderOperator::save NLMISC::IStream os  )  [virtual]
+
+ + + + + +
+   + + +

+Save the class in a stream. +

+Reimplemented from NLAILOGIC::IBaseOperator. +

+Definition at line 498 of file fo_operator.cpp. +

+

00499         {
+00500         }
+
+

+ + + + +
+ + + + + + + + + + + + + + + + + + + +
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::IBaseOperator::setComment char *   )  [inherited]
+
+ + + + + +
+   + + +

+Sets teh comment for the operator. +

+ +

+Definition at line 78 of file operator.cpp. +

+

00079         {
+00080                 if ( _Comment )
+00081                         delete[] _Comment;
+00082 
+00083                 if ( c ) 
+00084                 {
+00085                         _Comment = new char[ strlen( c ) ];
+00086                         strcpy( _Comment, c );
+00087                 }
+00088                 else
+00089                         _Comment = NULL;
+00090         }
+
+

+ + + + +
+ + + + + + + + + + +
void NLAILOGIC::IBaseOperator::setGoal IBaseAssert  )  [virtual, inherited]
+
+ + + + + +
+   + + +

+Sets the goals the operator tries to achieve. +

+ +

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

+References NLAIC::IPointerGestion::incRef(), and NLAIC::IPointerGestion::release(). +

+

00151         {
+00152                 if ( _Goal )
+00153                         _Goal->release();
+00154 
+00155                 _Goal = goal;
+00156 
+00157                 if ( goal != NULL )
+00158                         _Goal->incRef();
+00159         }
+
+

+ + + + +
+ + + + + + + + + + + + + + + + + + + +
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::CFirstOrderOperator::success IBaseOperator  )  [virtual]
+
+ + + + + +
+   + + +

+Dependencies failure and success notification These functions are called by other operators or goals who failed or succeeded +

+Implements NLAILOGIC::IBaseOperator. +

+Definition at line 640 of file fo_operator.cpp. +

+

00641         {
+00642         }
+
+

+ + + + +
+ + + + + + + + + +
void NLAILOGIC::CFirstOrderOperator::success  )  [virtual]
+
+ + + + + +
+   + + +

+Own success and failure functions These function telle other operators and goals that might be waiting for the execution of this one. +

+Implements NLAILOGIC::IBaseOperator. +

+Definition at line 632 of file fo_operator.cpp. +

+

00633         {
+00634         }
+
+

+ + + + +
+ + + + + + + + + + +
std::list< CFact * > * NLAILOGIC::CFirstOrderOperator::test std::list< CFact * > &   )  [virtual]
+
+ + + + + +
+   + + +

+ +

+Reimplemented from NLAILOGIC::IBaseOperator. +

+Definition at line 472 of file fo_operator.cpp. +

+References backward(). +

+

00473         {
+00474                 std::list<CFact *> *preconds = backward( facts );
+00475 
+00476                 std::list<CFact *>::iterator it_f = preconds->begin();
+00477                 while ( it_f != preconds->end() )
+00478                 {
+00479                         ( (CFirstOrderAssert *)(*it_f)->getAssert() )->backward( *it_f );
+00480                         it_f++;
+00481                 }
+00482                 return NULL;
+00483         }
+
+

+ + + + +
+ + + + + + + + + +
float NLAILOGIC::CFirstOrderOperator::truthValue  )  const [virtual]
+
+ + + + + +
+   + + +

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

+ +

+Implements NLAILOGIC::IBaseBoolType. +

+Definition at line 585 of file fo_operator.cpp. +

+

00586         {
+00587                 return 0.0;
+00588         }
+
+

+ + + + +
+ + + + + + + + + + +
CValueSet * NLAILOGIC::CFirstOrderOperator::unifyBackward std::list< CFact * > &   )  [protected]
+
+ + + + + +
+   + + +

+ +

+Definition at line 225 of file fo_operator.cpp. +

+References _PosVarsConc, getAssertPos(), NLAIC::IPointerGestion::release(), and sint32. +

+Referenced by backward(). +

+

00226         {
+00227                 CValueSet *unified = new CValueSet( _Vars.size() );
+00228                 std::list<CFact *>::iterator it_f = facts.begin();
+00229                 while ( it_f != facts.end() )
+00230                 {
+00231                         std::vector<sint32> pos_assert;
+00232                         getAssertPos( (*it_f)->getAssert(), _Concs, pos_assert );
+00233                         for (sint32 pos = 0; pos < (sint32) pos_assert.size(); pos++)
+00234                         {
+00235                                 for ( sint32 ivar = 0; ivar < (sint32) _PosVarsConc[ pos_assert[pos] ].size(); ivar++ )
+00236                                 {
+00237                                         sint32 l_pos = _PosVarsConc[ pos_assert[pos] ][ivar];
+00238 
+00239                                         IObjectIA *l_val = (*unified)[ l_pos ]; 
+00240                                         IObjectIA *r_val = (**it_f)[ ivar ];
+00241 
+00242                                         if ( !l_val )
+00243                                         {
+00244                                                 if ( r_val )
+00245                                                 {
+00246                                                         unified->setValue( l_pos, r_val );
+00247                                                 }
+00248                                         }
+00249                                         else
+00250                                         {
+00251                                                 if ( r_val && ( l_val != r_val ) )
+00252                                                 {
+00253                                                         unified->release();
+00254                                                         return NULL;
+00255                                                 }
+00256                                         }
+00257                                 }
+00258                         }
+00259                         it_f++;
+00260                 }
+00261                 return unified;
+00262         }
+
+

+ + + + +
+ + + + + + + + + + +
CValueSet * NLAILOGIC::CFirstOrderOperator::unifyForward std::list< CFact * > &   )  [protected]
+
+ + + + + +
+   + + +

+ +

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

+References getAssertPos(), NLAIC::IPointerGestion::release(), and sint32. +

+Referenced by forward(). +

+

00265         {
+00266                 CValueSet *unified = new CValueSet( _Vars.size() );
+00267                 std::list<CFact *>::iterator it_f = facts.begin();
+00268                 while ( it_f != facts.end() )
+00269                 {
+00270                         std::vector<sint32> pos_assert;
+00271                         getAssertPos( (*it_f)->getAssert(), _Conds, pos_assert );
+00272                         for (sint32 pos = 0; pos < (sint32) pos_assert.size(); pos++)
+00273                         {
+00274                                 for ( sint32 ivar = 0; ivar < (sint32) _PosVarsCond[ pos_assert[pos] ].size(); ivar++ )
+00275                                 {
+00276                                         sint32 l_pos = _PosVarsCond[ pos_assert[pos] ][ivar];
+00277 
+00278                                         IObjectIA *l_val = (*unified)[ l_pos ]; 
+00279                                         IObjectIA *r_val = (**it_f)[ ivar ];
+00280 
+00281                                         if ( !l_val )
+00282                                         {
+00283                                                 if ( r_val )
+00284                                                 {
+00285                                                         unified->setValue( l_pos, r_val );
+00286                                                 }
+00287                                         }
+00288                                         else
+00289                                         {
+00290                                                 if ( r_val && ( l_val != r_val ) )
+00291                                                 {
+00292                                                         unified->release();
+00293                                                         return NULL;
+00294                                                 }
+00295                                         }
+00296                                 }
+00297                         }
+00298                         it_f++;
+00299                 }
+00300                 return unified;
+00301         }
+
+

+ + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + + +
CValueSet * NLAILOGIC::CFirstOrderOperator::unifyLiaison const CValueSet,
CValueSet,
std::vector< sint32 > & 
[protected]
+
+ + + + + +
+   + + +

+Tries to unify an instaciation of the operator's variables with a new CFact. +

+ +

+Definition at line 416 of file fo_operator.cpp. +

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

+Referenced by propagate(). +

+

00417         {
+00418                 CValueSet *result;
+00419 
+00420                 if ( (result = fp->unify( vals, pos_vals )) )
+00421                         return result;
+00422                 else
+00423                 {
+00424                         delete result;
+00425                         return NULL;
+00426                 }
+00427         }
+
+


Field Documentation

+

+ + + + +
+ + +
char* NLAILOGIC::IBaseOperator::_Comment [protected, inherited] +
+
+ + + + + +
+   + + +

+Description of the operator. +

+ +

+Reimplemented in NLAILOGIC::CBoolOperator. +

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

+Referenced by CFirstOrderOperator(), and NLAILOGIC::IBaseOperator::IBaseOperator().

+

+ + + + +
+ + +
std::vector<IBaseAssert *> NLAILOGIC::IBaseOperator::_Concs [protected, inherited] +
+
+ + + + + +
+   + + +

+Postconditions asserts. +

+ +

+Definition at line 54 of file operator.h. +

+Referenced by CFirstOrderOperator(), and NLAILOGIC::IBaseOperator::IBaseOperator().

+

+ + + + +
+ + +
std::vector<IBaseAssert *> NLAILOGIC::IBaseOperator::_Conds [protected, inherited] +
+
+ + + + + +
+   + + +

+Preconditions asserts. +

+ +

+Definition at line 52 of file operator.h. +

+Referenced by CFirstOrderOperator(), and NLAILOGIC::IBaseOperator::IBaseOperator().

+

+ + + + +
+ + +
IBaseAssert* NLAILOGIC::IBaseOperator::_Goal [protected, inherited] +
+
+ + + + + +
+   + + +

+ +

+Definition at line 50 of file operator.h. +

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

+

+ + + + +
+ + +
std::vector< std::vector<sint32> > NLAILOGIC::CFirstOrderOperator::_PosVarsConc [protected] +
+
+ + + + + +
+   + + +

+Pos of a precondition pattern's vars in the operator's vars table. +

+ +

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

+Referenced by addPostcondition(), CFirstOrderOperator(), forward(), getDebugString(), getPosListBackward(), getPosListForward(), propagate(), and unifyBackward().

+

+ + + + +
+ + +
std::vector< std::vector<sint32> > NLAILOGIC::CFirstOrderOperator::_PosVarsCond [protected] +
+
+ + + + + +
+   + + +

+Variables of the operator. +

+ +

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

+Referenced by CFirstOrderOperator().

+

+ + + + +
+ + +
std::vector<IBaseVar *> NLAILOGIC::CFirstOrderOperator::_Vars [protected] +
+
+ + + + + +
+   + + +

+ +

+Definition at line 44 of file fo_operator.h.

+

+ + + + +
+ + +
const NLAIC::CIdentType CFirstOrderOperator::IdCFirstOrderOperator [static] +
+
+ + + + + +
+   + + +

+Initial value:

 NLAIC::CIdentType( "FirstOrderOperator", NLAIC::CSelfClassFactory(CFirstOrderOperator()), 
+                NLAIC::CTypeOfObject::tLogic,
+                NLAIC::CTypeOfOperator::opAdd )
+
+

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

+Referenced by getType().

+

+ + + + +
+ + +
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:48:13 2004 for NeL by + +doxygen +1.3.6
+ + -- cgit v1.2.1