From 0ea5fc66924303d1bf73ba283a383e2aadee02f2 Mon Sep 17 00:00:00 2001 From: neodarz Date: Sat, 11 Aug 2018 20:21:34 +0200 Subject: Initial commit --- docs/doxygen/nel/a03342.html | 6070 ++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 6070 insertions(+) create mode 100644 docs/doxygen/nel/a03342.html (limited to 'docs/doxygen/nel/a03342.html') diff --git a/docs/doxygen/nel/a03342.html b/docs/doxygen/nel/a03342.html new file mode 100644 index 00000000..29738119 --- /dev/null +++ b/docs/doxygen/nel/a03342.html @@ -0,0 +1,6070 @@ + + +NeL: NLAILOGIC::CRule class Reference + + + +

NLAILOGIC::CRule Class Reference

#include <rule.h> +

Inheritance diagram for NLAILOGIC::CRule: +

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +


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 IObjetOp &	neg ()
	throw (NLAIE::CExceptionNotImplemented)
virtual IObjetOp &	operator *= (const IObjetOp &)
	throw (NLAIE::CExceptionNotImplemented)
virtual IObjetOp &	operator+= (const IObjetOp &)
	add the operater by anather.
virtual IObjetOp &	operator-= (const IObjetOp &)
	throw (NLAIE::CExceptionNotImplemented)
virtual IObjetOp &	operator/= (const IObjetOp &)
	throw (NLAIE::CExceptionNotImplemented)
[NOHEADER]
virtual IObjetOp *	operator * (const IObjetOp &)
	throw (NLAIE::CExceptionNotImplemented)
virtual IObjetOp *	operator+ (const IObjetOp &)
	throw (NLAIE::CExceptionNotImplemented)
virtual IObjetOp *	operator- (const IObjetOp &)
	throw (NLAIE::CExceptionNotImplemented)
virtual IObjetOp *	operator/ (const IObjetOp &)
	throw (NLAIE::CExceptionNotImplemented)
Public Types
enum	TOpId { + op_add, +op_sub, +op_mul, +op_div, + + op_eq, +op_inf, +op_sup, +op_inf_eq, + + op_sup_eq, +op_not, +op_diff, +op_neg, + + op_last + + }
Public Member Functions
virtual void	addBuffer ()
void	addConc (CFactPattern *)
virtual void	addCond (CFactPattern *cond)
virtual void	addConflicts ()
void	addVar (IBaseVar *)
CValueSet *	asCValueSet ()
void	backward (std::list< CValueSet * > *)
CVarSet *	backward (CFactPattern *, std::vector< sint32 > &, std::vector< sint32 > &)
CVarSet *	backWard (CFactPattern *)
virtual TQueue	canProcessMessage (const IVarName &)
std::vector< IBaseAssert * > &	CClause::getAssert ()
void	CClause::init (NLAIAGENT::IObjectIA *)
virtual const NLAIC::IBasicType *	clone () const
	CRule (const CRule &)
	CRule (std::list< CFactPattern * > &, std::list< CFactPattern * > &)
	CRule ()
sint32	decRef ()
	Decrement the reference of an object.
void	forward (CVarSet *)
virtual void	getDebugString (std::string &) const
virtual const std::string	getInfo ()
std::list< CClause * > *	getInputs ()
virtual std::string	getMethodeMemberDebugString (sint32, sint32) const
virtual IObjetOp *	getNeg () const
void	getPosListBackward (sint32, sint32, std::vector< sint32 > &)
void	getPosListForward (sint32, sint32, std::vector< sint32 > &)
const sint32 &	getRef () const
	get the refence count.
const IObjectIA *	getStaticMember (const IVarName &compName) const
virtual const IObjectIA *	getStaticMember (sint32) const
virtual sint32	getStaticMemberIndex (const IVarName &) const
virtual sint32	getStaticMemberSize () const
virtual const NLAIC::CIdentType &	getType () const
std::list< NLAIAGENT::IObjetOp * > *	getValues ()
virtual std::vector< IBaseVar * > *	getVars ()
void	incRef ()
	Inc a reference. We use this when we have to conserve a pointer memeory for exemple in a list.
virtual void	init (NLAIAGENT::IObjectIA *)
virtual sint32	isClassInheritedFrom (const IVarName &) const
virtual bool	isEqual (const IBasicObjectIA &a) const=0
bool	isEqual (const NLAIAGENT::IBasicObjectIA &a) const
virtual bool	isEqual (const CVarSet &a) const
virtual bool	isLocal ()
	If the result is true the object is loclal else its a representation of an object on the server. By the method return true.
virtual TQueue	isMember (const IVarName , const IVarName , const IObjectIA &) const
virtual bool	isTrue () const
	throw (NLAIE::CExceptionNotImplemented)
bool	isUnified ()
virtual void	load (NLMISC::IStream &is)
sint32	nbVars ()
virtual const NLAIC::IBasicType *	newInstance () const
virtual IObjetOp *	operator * (IObjetOp *a)
	throw (NLAIE::CExceptionNotImplemented)
virtual IObjetOp &	operator = (IObjetOp a)
	throw (NLAIE::CExceptionNotImplemented)
virtual NLAIAGENT::IObjetOp *	operator! () const
	throw (NLAIE::CExceptionNotImplemented)
virtual NLAIAGENT::IObjetOp *	operator!= (NLAIAGENT::IObjetOp &a) const
	throw (NLAIE::CExceptionNotImplemented)
virtual IObjetOp *	operator+ (IObjetOp *a)
	throw (NLAIE::CExceptionNotImplemented)
virtual IObjetOp &	operator+= (IObjetOp *a)
	throw (NLAIE::CExceptionNotImplemented)
virtual IObjetOp *	operator- (IObjetOp *a)
	throw (NLAIE::CExceptionNotImplemented)
virtual IObjetOp &	operator-= (IObjetOp *a)
	throw (NLAIE::CExceptionNotImplemented)
virtual IObjetOp *	operator/ (IObjetOp *a)
	throw (NLAIE::CExceptionNotImplemented)
virtual IObjetOp &	operator/= (IObjetOp *a)
	throw (NLAIE::CExceptionNotImplemented)
virtual IObjetOp *	operator< (IObjetOp &) const
	throw (NLAIE::CExceptionNotImplemented)
virtual IObjetOp *	operator<= (IObjetOp &) const
	throw (NLAIE::CExceptionNotImplemented)
bool	operator== (const IBasicObjectIA &classType) const
virtual NLAIAGENT::IObjetOp *	operator== (NLAIAGENT::IObjetOp &a) const
	throw (NLAIE::CExceptionNotImplemented)
virtual IObjetOp *	operator> (IObjetOp &) const
	throw (NLAIE::CExceptionNotImplemented)
virtual IObjetOp *	operator>= (IObjetOp &) const
	throw (NLAIE::CExceptionNotImplemented)
virtual IBaseVar *	operator[] (sint32)
virtual void	propagate (CFactPattern *)
virtual void	propagate (std::list< NLAIAGENT::IObjectIA * > *, std::vector< sint32 > &)
virtual void	release ()
	Release allow to release the pointer. The last release when the _Ref is nul delete the object.
void	removeVar (IBaseVar *)
virtual const CProcessResult &	run ()
virtual CProcessResult	runMethodeMember (sint32 index, IObjectIA *)
virtual CProcessResult	runMethodeMember (sint32, sint32, IObjectIA *)
virtual const CProcessResult &	runStep ()
virtual void	save (NLMISC::IStream &os)
virtual CProcessResult	sendMessage (const IVarName &, IObjectIA *)
virtual CProcessResult	sendMessage (IObjectIA *)
virtual void	serial (NLMISC::IStream &f) throw (NLMISC::EStream)
void	setCond (CClause &)
virtual bool	setStaticMember (sint32, IObjectIA *)
bool	setStaticMember (const IVarName &compName, IObjectIA *change)
void	showBuffer ()
void	showConflicts ()
void	showLiaisons ()
sint32	size ()
virtual float	truthValue () const
	Returns a value in [0,1].
virtual sint32	undefined ()
virtual CVarSet *	unify (CValueSet *)
virtual CVarSet *	unify (CVarSet *)
std::list< CValueSet * > *	unifyBack (CFactPattern *)
CValueSet *	unifyLiaison (const CValueSet , std::list< NLAIAGENT::IObjectIA > *, std::vector< sint32 > &)
CValueSet *	unifyLiaisonBack (CValueSet , std::list< NLAIAGENT::IObjetOp > &, std::vector< sint32 > &, bool &)
	~CRule ()
Static Public Attributes
const NLAIC::CIdentType	IdClause
const NLAIC::CIdentType	IdRule
const NLAIC::CIdentType	IdVarSet
TProcessStatement	ProcessBuzzy = processBuzzy
TProcessStatement	ProcessEnd = processEnd
TProcessStatement	ProcessError = processError
TProcessStatement	ProcessIdle = processIdle
TProcessStatement	ProcessLocked = processLocked
CProcessResult	ProcessNotComplit = IObjectIA::CProcessResult(processNotComplete)
CProcessResult	ProcessRun = IObjectIA::CProcessResult()
Protected Member Functions
sint32	findAssert (IBaseAssert *)
Protected Attributes
std::vector< IBaseAssert * >	_Asserts
std::list< CValueSet * >	_BufLiaisons
std::vector< IBaseBoolType * >	_Conds
std::list< CValueSet * >	_Conflits
bool	_FirstOrderTrue
std::list< CValueSet * >	_Liaisons
sint32	_NbValid
std::vector< std::vector< + sint32 > >	_PosVarsCond
std::list< CBoolAssert * >	_SimpleConds
std::vector< IBaseVar * >	_Vars
sint32	NbInstanciated
Private Member Functions
void	getConcPosList (sint32, sint32, std::vector< sint32 > &)
Private Attributes
std::vector< IBaseAssert * >	_Concs
std::vector< std::vector< + sint32 > >	_PosVarsConc

Member Enumeration Documentation

+ + + + +
+ + +
enum NLAIAGENT::IObjetOp::TOpId [inherited] +
+
+ + + + + +
+ + + +
+
Enumeration values:
+ + + + + + + + + + + + + + +
op_add +
op_sub +
op_mul +
op_div +
op_eq +
op_inf +
op_sup +
op_inf_eq +
op_sup_eq +
op_not +
op_diff +
op_neg +
op_last +
+
+ +
+Definition at line 46 of file agent_operator.h. +
+
00047 { +00048 op_add , +00049 op_sub , +00050 op_mul , +00051 op_div , +00052 op_eq , +00053 op_inf , +00054 op_sup , +00055 op_inf_eq , +00056 op_sup_eq , +00057 op_not , +00058 op_diff , +00059 op_neg, +00060 op_last +00061 }; +

+

Constructor & Destructor Documentation

+ + + + +
+ + + + + + + + + +
NLAILOGIC::CRule::CRule ( )
+
+ + + + + +
+ + + +
+ +
+Definition at line 29 of file rule.cpp. +
+Referenced by clone(), and newInstance(). +
+
00030 { +00031 } +

+

+ + + + +
+ + + + + + + + + + + + + + + + + + + +
NLAILOGIC::CRule::CRule ( std::list< CFactPattern * > & ,
std::list< CFactPattern * > &
)
+
+ + + + + +
+ + + +
+ +
+Definition at line 33 of file rule.cpp. +
+References addConc(). +
+
00033 : CClause( conds ) +00034 { +00035 std::list<CFactPattern *>::iterator it_c = concs.begin(); +00036 while ( it_c != concs.end() ) +00037 { +00038 addConc( *it_c ); +00039 it_c++; +00040 } +00041 } +

+

+ + + + +
+ + + + + + + + + + +
NLAILOGIC::CRule::CRule ( const CRule & )
+
+ + + + + +
+ + + +
+ +
+Definition at line 43 of file rule.cpp. +
+References _Concs, and _PosVarsConc. +
+
00043 : CClause(c) +00044 { +00045 std::vector<IBaseAssert *>::const_iterator it_c = c._Concs.begin(); +00046 while ( it_c != c._Concs.end() ) +00047 { +00048 _Concs.push_back( *it_c ); +00049 it_c++; +00050 } +00051 +00052 std::vector< std::vector<sint32> >::const_iterator it_li = c._PosVarsConc.begin(); +00053 while ( it_li != c._PosVarsConc.end() ) +00054 { +00055 std::vector<sint32>::const_iterator it_i = (*it_li).begin(); +00056 _PosVarsConc.push_back( std::vector<sint32>() ); +00057 +00058 while ( it_i != (*it_li).end() ) +00059 { +00060 _PosVarsConc.back().push_back( *it_i ) ; +00061 it_i++; +00062 } +00063 it_li++; +00064 } +00065 } +

+

+ + + + +
+ + + + + + + + + +
NLAILOGIC::CRule::~CRule ( )
+
+ + + + + +
+ + + +
+ +
+Definition at line 84 of file rule.cpp. +
+
00085 { +00086 } +

+

Member Function Documentation

+ + + + +
+ + + + + + + + + +
void NLAILOGIC::CClause::addBuffer ( ) [virtual, inherited]
+
+ + + + + +
+ + + +
+ +
+Definition at line 328 of file clause.cpp. +
+References NLAILOGIC::CClause::_BufLiaisons, and NLAILOGIC::CClause::_Liaisons. +
+Referenced by NLAILOGIC::CClause::propagate(). +
+
00329 { +00330 while ( !_BufLiaisons.empty() ) +00331 { +00332 _Liaisons.push_back( _BufLiaisons.front() ); +00333 std::string buf; +00334 _BufLiaisons.front()->getDebugString( buf ); +00335 //TRACE ( "Ajout de la liaison du buffer: %s ", buf ); +00336 _BufLiaisons.pop_front(); +00337 } +00338 } +

+

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

+

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

+

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

+

+ + + + +
+ + + + + + + + + + +
void NLAILOGIC::CVarSet::addVar ( IBaseVar * ) [inherited]
+
+ + + + + +
+ + + +
+ +
+Definition at line 144 of file varset.cpp. +
+References NLAIC::IBasicType::clone(). +
+Referenced by NLAISCRIPT::COperatorClass::addFirstOrderCond(), backWard(), NLAISCRIPT::COperatorClass::buildLogicTables(), NLAISCRIPT::COperatorClass::initialiseFactBase(), NLAILOGIC::CVarSet::unify(), and unifyBack(). +
+
00145 { +00146 IBaseVar *tmp = (IBaseVar *) var->clone(); +00147 _Vars.push_back( tmp ); +00148 } +

+

+ + + + +
+ + + + + + + + + +
CValueSet * NLAILOGIC::CVarSet::asCValueSet ( ) [inherited]
+
+ + + + + +
+ + + +
+ +
+Definition at line 290 of file varset.cpp. +
+Referenced by NLAILOGIC::CFirstOrderAssert::addFact(), and unifyBack(). +
+
00291 { +00292 CValueSet *result = new CValueSet( _Vars ); +00293 return result; +00294 } +

+

+ + + + +
+ + + + + + + + + + +
void NLAILOGIC::CRule::backward ( std::list< CValueSet * > * )
+
+ + + + + +
+ + + +
+ +
+Definition at line 387 of file rule.cpp. +
+
00388 { +00389 std::vector<IBaseBoolType *>::iterator it_cond = _Conds.begin(); +00390 while ( it_cond != _Conds.end() ) +00391 { +00392 std::list<CValueSet *>::iterator it_vs = vs->begin(); +00393 while ( it_vs != vs->end() ) +00394 { +00395 // ( (CFirstOrderAssert *) *it_cond )->backward( *it_vs ); +00396 it_vs++; +00397 } +00398 it_cond++; +00399 } +00400 } +

+

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

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

+

+ + + + +
+ + + + + + + + + + +
TQueue NLAIAGENT::IObjectIA::canProcessMessage ( const IVarName & ) [virtual, inherited]
+
+ + + + + +
+ + + +
+The method canProcessMessage(const IVarName &msgName) allow us to know if agent can preocess given by msgName.
+TQueue contain the liste of method (same as a run(msg)) that coud process the msg. +
+Reimplemented in NLAIAGENT::CLocalAgentMail. +
+Definition at line 350 of file baseai.cpp. +
+References NLAIAGENT::TQueue. +
+Referenced by NLAIAGENT::CLocalAgentMail::canProcessMessage(). +
+
00351 { +00352 return TQueue(); +00353 } +

+

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

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

+ + + + +
+ + + + + + + + + +
const NLAIC::IBasicType * NLAILOGIC::CRule::clone ( ) const [virtual]
+
+ + + + + +
+ + + +
+This function allow a pointer copy, that mean that the new class have the sam attributs caracteristics as the owne. +
+Reimplemented from NLAILOGIC::CClause. +
+Definition at line 88 of file rule.cpp. +
+References CRule(). +
+Referenced by init(). +
+
00089 { +00090 NLAIC::IBasicInterface *m = new CRule(*this); +00091 return m; +00092 } +

+

+ + + + +
+ + + + + + + + + +
sint32 NLAIC::IPointerGestion::decRef ( ) [inline, inherited]
+
+ + + + + +
+ + + +
+Decrement the reference of an object. +
+ +
+Definition at line 93 of file abstract_interface.h. +
+References NLAIC::IPointerGestion::_Ref, and sint32. +
+Referenced by NLAIC::IPointerGestion::release(), and NLAIAGENT::CAgentTimerHandle::~CAgentTimerHandle(). +
+
00094 { +00095 return --_Ref; +00096 } +

+

+ + + + +
+ + + + + + + + + + +
sint32 NLAILOGIC::CClause::findAssert ( IBaseAssert * ) [protected, inherited]
+
+ + + + + +
+ + + +
+ +
+Definition at line 110 of file clause.cpp. +
+References NLAILOGIC::CClause::_Asserts, NLAILOGIC::IBaseAssert::getName(), and sint32. +
+Referenced by addConc(), and NLAILOGIC::CClause::addCond(). +
+
00111 { +00112 if ( a ) +00113 for ( sint32 i = 0; i < (sint32)_Asserts.size(); i++ ) +00114 { +00115 if ( _Asserts[i]->getName() == a->getName() ) +00116 { +00117 return i; +00118 } +00119 } +00120 +00121 return -1; +00122 } +

+

+ + + + +
+ + + + + + + + + + +
void NLAILOGIC::CRule::forward ( CVarSet * )
+
+ + + + + +
+ + + +
+ +
+Definition at line 160 of file rule.cpp. +
+
00161 { +00162 +00163 } +

+

+ + + + +
+ + + + + + + + + +
virtual std::string NLAIC::IPointerGestion::getClassName ( ) [inline, virtual, inherited]
+
+ + + + + +
+ + + +
+ +
+Implements NLMISC::IClassable. +
+Reimplemented in NLAIC::CIdentType. +
+Definition at line 116 of file abstract_interface.h. +
+Referenced by NLAISCRIPT::CAgentClass::isClassInheritedFrom(). +
+
00117 { +00118 return std::string("<unnamed>"); +00119 } +

+

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

+ + + + +
+ + + + + + + + + + +
void NLAILOGIC::CRule::getDebugString ( std::string & ) const [virtual]
+
+ + + + + +
+ + + +
+This is a Debug function, text is an character pointer to receive the debug text output, the debug text containe all think sensible to interset user. +
+Reimplemented from NLAILOGIC::CClause. +
+Definition at line 239 of file rule.cpp. +
+References sint32. +
+
00240 { +00241 txt += "CRule\n - Conditions: "; +00242 std::vector<IBaseBoolType *>::const_iterator it_c = _Conds.begin(); +00243 while ( it_c != _Conds.end() ) +00244 { +00245 std::string buf; +00246 ( *it_c )->getDebugString( buf ); +00247 txt += " - "; +00248 txt += buf; +00249 it_c++; +00250 } +00251 +00252 txt += "\n - Conclusions: "; +00253 +00254 std::vector<IBaseAssert *>::const_iterator it_cc = _Concs.begin(); +00255 +00256 while ( it_cc != _Concs.end() ) +00257 { +00258 std::string buf; +00259 ( *it_cc )->getDebugString( buf ); +00260 txt += " - "; +00261 txt += buf; +00262 it_cc++; +00263 } +00264 +00265 txt += "\n - Variables "; +00266 for (sint32 i = 0; i < (sint32)_Vars.size(); i++ ) +00267 { +00268 std::string buf; +00269 _Vars[ i ]->getDebugString( buf ); +00270 txt += " - "; +00271 txt += buf; +00272 } +00273 } +

+

+ + + + +
+ + + + + + + + + +
virtual const std::string NLAIC::IBasicType::getInfo ( ) [inline, virtual, inherited]
+
+ + + + + +
+ + + +
+ +
+Definition at line 292 of file abstract_interface.h. +
+References NLAIC::IBasicType::getDebugString(), and s. +
+
00293 { +00294 std::string s; +00295 getDebugString(s); +00296 return s; +00297 } +

+

+ + + + +
+ + + + + + + + + +
std::list< CClause * > * NLAILOGIC::CClause::getInputs ( ) [inherited]
+
+ + + + + +
+ + + +
+ +
+Definition at line 368 of file clause.cpp. +
+
00369 { +00370 return new std::list<CClause *>; +00371 } +

+

+ + + + +
+ + + + + + + + + + + + + + + + + + + +
std::string NLAIAGENT::IObjectIA::getMethodeMemberDebugString ( sint32 ,
sint32
) const [virtual, inherited]
+
+ + + + + +
+ + + +
+The methode getMethodeMemberDebugString(sint32 heritance, sint32 index) return a string that define the name and the argument of the method +
+Reimplemented in NLAIAGENT::CAgentScript. +
+Definition at line 311 of file baseai.cpp. +
+References sint32. +
+Referenced by NLAISCRIPT::CCallHeapMethodi::getDebugResult(), NLAISCRIPT::CCallStackMethodi::getDebugResult(), NLAISCRIPT::CCallMethodi::getDebugResult(), NLAISCRIPT::CLibHeapMemberMethod::getDebugResult(), NLAISCRIPT::CLibStackNewMemberMethod::getDebugResult(), NLAISCRIPT::CLibStackMemberMethod::getDebugResult(), NLAISCRIPT::CLibCallMethodi::getDebugResult(), NLAISCRIPT::CLibCallInheritedMethod::getDebugResult(), NLAISCRIPT::CLibCallMethod::getDebugResult(), NLAISCRIPT::CLibMemberMethodi::getDebugResult(), NLAISCRIPT::CLibMemberInheritedMethod::getDebugResult(), and NLAISCRIPT::CLibMemberMethod::getDebugResult(). +
+
00312 { +00313 switch(id) +00314 { +00315 case 0: +00316 { +00317 return std::string("IObjectIA::sendMessage(IMessage)"); +00318 } +00319 break; +00320 case 1: +00321 break; +00322 case 2: +00323 return std::string("IObjectIA::run()"); +00324 break; +00325 +00326 case 3: +00327 { +00328 return std::string("IObjectIA::getStaticMember(Integer)"); +00329 } +00330 } +00331 return std::string("Mathod_?????(Param_?????)"); +00332 } +

+

+ + + + +
+ + + + + + + + + +
sint32 NLAIAGENT::IObjetOp::getMethodIndexSize ( ) const [virtual, inherited]
+
+ + + + + +
+ + + +
+getMethodIndexSize define the nomber of method define in the class. +
+Reimplemented from NLAIAGENT::IObjectIA. +
+Reimplemented in NLAIAGENT::IVector, NLAIAGENT::INombreDefine, NLAIAGENT::CPairType, NLAIAGENT::IBaseGroupType, NLAIAGENT::CVectorGroupType, NLAIAGENT::IListBasicManager, NLAIAGENT::CMessageScript, NLAIAGENT::IMessageBase, NLAIAGENT::CAgentOperation, NLAIFUZZY::CFuzzyVar, NLAILOGIC::CFact, NLAILOGIC::CGoal, NLAILOGIC::CInternalGoal, and NLAILOGIC::IBaseVar. +
+Definition at line 93 of file agent_operator.cpp. +
+References NLAIAGENT::IObjetOp::op_last, and sint32. +
+
00094 { +00095 return IObjectIA::getMethodIndexSize() + op_last; +00096 } +

+

+ + + + +
+ + + + + + + + + +
virtual IObjetOp* NLAIAGENT::IObjetOp::getNeg ( ) const [inline, virtual, inherited]
+
+ + + + + +
+ + + +
+ +
+Definition at line 165 of file agent_operator.h. +
+References NLAIC::IBasicType::clone(), and NLAIAGENT::IObjetOp::neg(). +
+Referenced by NLAISCRIPT::CNegOpCode::runOpCode(). +
+
00166 { +00167 IObjetOp *o = (IObjetOp *)clone(); +00168 o->neg(); +00169 return o; +00170 } +

+

+ + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + + +
void NLAILOGIC::CRule::getPosListBackward ( sint32 ,
sint32 ,
std::vector< sint32 > &
)
+
+ + + + + +
+ + + +
+ +
+Definition at line 446 of file rule.cpp. +
+References sint32. +
+
00447 { +00448 std::vector<sint32>::iterator it_conc = _PosVarsConc[ no_conc ].begin(); +00449 while ( it_conc != _PosVarsConc[ no_conc ].end() ) +00450 { +00451 std::vector<sint32>::iterator it_cond = _PosVarsCond[ no_cond ].begin(); +00452 while ( it_cond != _PosVarsCond[ no_cond ].end() ) +00453 { +00454 if ( (*it_conc) == (*it_cond) ) +00455 { +00456 cond_pos.push_back( *it_cond ); +00457 } +00458 it_cond++; +00459 } +00460 it_conc++; +00461 } +00462 } +

+

+ + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + + +
void NLAILOGIC::CRule::getPosListForward ( sint32 ,
sint32 ,
std::vector< sint32 > &
)
+
+ + + + + +
+ + + +
+ +
+Definition at line 465 of file rule.cpp. +
+References sint32. +
+
00466 { +00467 std::vector<sint32>::iterator it_cond = _PosVarsCond[ no_cond ].begin(); +00468 while ( it_cond != _PosVarsCond[ no_cond ].end() ) +00469 { +00470 std::vector<sint32>::iterator it_conc = _PosVarsConc[ no_conc ].begin(); +00471 while ( it_conc != _PosVarsConc[ no_conc ].end() ) +00472 { +00473 if ( (*it_cond) == (*it_conc) ) +00474 { +00475 conc_pos.push_back( *it_conc ); +00476 } +00477 it_conc++; +00478 } +00479 it_cond++; +00480 } +00481 } +

+

+ + + + +
+ + + + + + + + + +
const sint32& NLAIC::IPointerGestion::getRef ( ) const [inline, inherited]
+
+ + + + + +
+ + + +
+get the refence count. +
+ +
+Definition at line 99 of file abstract_interface.h. +
+References NLAIC::IPointerGestion::_Ref, and sint32. +
+Referenced by NLAIAGENT::CAgentTimerHandle::~CAgentTimerHandle(). +
+
00100 { +00101 return _Ref; +00102 } +

+

+ + + + +
+ + + + + + + + + + +
const IObjectIA* NLAIAGENT::IObjectIA::getStaticMember ( const IVarName & compName ) const [inline, inherited]
+
+ + + + + +
+ + + +
+to get the pointer of a given components referened by an string. +
+Definition at line 261 of file baseai.h. +
+References NLAIAGENT::IObjectIA::getStaticMember(), and NLAIAGENT::IObjectIA::getStaticMemberIndex(). +
+
00262 { +00263 return getStaticMember(getStaticMemberIndex(compName)); +00264 } +

+

+ + + + +
+ + + + + + + + + + +
sint32 NLAIAGENT::IObjectIA::getStaticMemberIndex ( const IVarName & ) const [virtual, inherited]
+
+ + + + + +
+ + + +
+to get the index of a given components name. +
+Reimplemented in NLAIAGENT::CLocalAgentMail, NLAIAGENT::CAgentScript, and NLAIAGENT::CMessageScript. +
+Definition at line 188 of file baseai.cpp. +
+References sint32. +
+Referenced by NLAISCRIPT::CCompilateur::affectation(), NLAIAGENT::CComponentHandle::getComponent(), NLAIAGENT::IObjectIA::getStaticMember(), NLAIAGENT::CLocalAgentMail::getStaticMemberIndex(), NLAISCRIPT::CCompilateur::getValidateHierarchyBase(), NLAISCRIPT::CCompilateur::isValidateVarName(), NLAISCRIPT::CCodeBrancheRunDebug::printVariable(), NLAISCRIPT::CCompilateur::processingVar(), NLAISCRIPT::CConstraintStackComp::run(), and NLAIAGENT::IObjectIA::setStaticMember(). +
+
00189 { +00190 return -1; +00191 } +

+

+ + + + +
+ + + + + + + + + +
sint32 NLAIAGENT::IObjectIA::getStaticMemberSize ( ) const [virtual, inherited]
+
+ + + + + +
+ + + +
+Static member is the component that the agent is create and die with. getStaticMemberSize to get the size of the static member components +
+Reimplemented in NLAIAGENT::CLocalAgentMail, NLAIAGENT::CAgentScript, NLAIAGENT::CMessageScript, NLAISCRIPT::IClassInterpret, and NLAISCRIPT::CAgentClass. +
+Definition at line 180 of file baseai.cpp. +
+References NLAIC::IBasicType::getType(), sint32, and NLAIC::stringGetBuild(). +
+Referenced by NLAIAGENT::CLocalAgentMail::getStaticMemberSize(). +
+
00181 { +00182 std::string text; +00183 text = NLAIC::stringGetBuild("sint32 IObjectIA::getStaticMemberSize() note implementaited for the '%s' interface",(const char *)getType()); +00184 throw NLAIE::CExceptionNotImplemented(text.c_str()); +00185 return 0; +00186 } +

+

+ + + + +
+ + + + + + + + + +
const NLAIC::CIdentType & NLAILOGIC::CRule::getType ( ) const [virtual]
+
+ + + + + +
+ + + +
+getType return a unique string how represente the class, it can be the name of the class. This function is used for the sytem regstry class (see the definition of the template class Gen::CRegistry). +
+Reimplemented from NLAILOGIC::CVarSet. +
+Definition at line 234 of file rule.cpp. +
+References IdRule. +
+
00235 { +00236 return IdRule; +00237 } +

+

+ + + + +
+ + + + + + + + + +
std::list< IObjetOp * > * NLAILOGIC::CVarSet::getValues ( ) [inherited]
+
+ + + + + +
+ + + +
+ +
+Definition at line 272 of file varset.cpp. +
+References sint32. +
+Referenced by NLAILOGIC::CFirstOrderAssert::addFact(), NLAILOGIC::CFact::CFact(), and unifyBack(). +
+
00273 { +00274 std::list<IObjetOp *> *result = new std::list<IObjetOp *>; +00275 +00276 IObjetOp *tmp_val; +00277 +00278 for ( sint32 i = 0; i < (sint32)_Vars.size(); i++ ) +00279 { +00280 tmp_val = _Vars[ i ]; +00281 IObjetOp *val; +00282 if ( (val = _Vars[ i ]->getValue()) ) +00283 result->push_back( val ); +00284 } +00285 +00286 return result; +00287 } +

+

+ + + + +
+ + + + + + + + + +
std::vector< IBaseVar * > * NLAILOGIC::CVarSet::getVars ( ) [virtual, inherited]
+
+ + + + + +
+ + + +
+ +
+Definition at line 165 of file varset.cpp. +
+Referenced by addConc(), NLAILOGIC::CClause::addCond(), backWard(), NLAISCRIPT::COperatorClass::compileFactPattern(), NLAILOGIC::CFirstOrderOperator::compileFactPattern(), and init(). +
+
00166 { +00167 std::vector<IBaseVar *> *result= new std::vector<IBaseVar *>; +00168 +00169 std::vector<IBaseVar *>::iterator it_var = _Vars.begin(); +00170 while ( it_var != _Vars.end() ) +00171 { +00172 result->push_back( (IBaseVar *) (*it_var)->clone() ); +00173 it_var++; +00174 } +00175 return result; +00176 } +

+

+ + + + +
+ + + + + + + + + + +
void NLAILOGIC::CRule::init ( NLAIAGENT::IObjectIA * ) [virtual]
+
+ + + + + +
+ + + +
+Init method alows to init the attribut of an object. the maparmetre is in more time a list of IObjectIA. +
+Reimplemented from NLAIAGENT::IObjectIA. +
+Definition at line 197 of file rule.cpp. +
+References addConc(), clone(), NLAIAGENT::IBaseGroupType::getIterator(), NLAILOGIC::CVarSet::getVars(), NLAIAGENT::CConstIteratorContener::isInEnd(), params, NLAIC::IPointerGestion::release(), and sint32. +
+
00198 { +00199 /* if ( params->size() != 3 ) +00200 { +00201 // TODO throw Exc::.... +00202 }*/ +00203 +00204 // Conditions +00205 CClause *cond = (CClause *) ((IBaseGroupType *)params)->popFront(); +00206 std::vector<IBaseVar *> *vars = cond->getVars(); +00207 +00208 int i; +00209 +00210 for ( i = 0; i < (sint32)vars->size() ; i++ ) +00211 { +00212 _Vars.push_back( (IBaseVar *) (* vars)[ i ]->clone() ); +00213 } +00214 +00215 for ( i = 0; i < (sint32) vars->size() ; i++ ) +00216 (*vars)[i]->release(); +00217 delete vars; +00218 cond->release(); +00219 +00220 // Conclusions +00221 IBaseGroupType *concs = (IBaseGroupType *) ((IBaseGroupType *)params)->popFront(); +00222 CIteratorContener it_fp = concs->getIterator(); +00223 while ( !it_fp.isInEnd() ) +00224 { +00225 CFactPattern *tmp = (CFactPattern *) ( it_fp ++)->clone(); +00226 addConc( tmp); +00227 tmp->release(); +00228 //it_fp++; +00229 } +00230 +00231 concs->release(); +00232 } +

+

+ + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + + +
virtual TQueue NLAIAGENT::IObjetOp::IObjetOp::isMember ( const IVarName * ,
const IVarName * ,
const IObjectIA &
) const [virtual, inherited]
+
+ + + + + +
+ + + +
+
+

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

+ + + + +
+ + + + + + + + + + +
sint32 NLAIAGENT::IObjectIA::isClassInheritedFrom ( const IVarName & ) const [virtual, inherited]
+
+ + + + + +
+ + + +
+isClassInheritedFrom(className) allow us to known if this class have a base class with the name className.
+If true the method return the range of the base class, this range is an arbitrary reference id define by the programmer or bay the scrypt. the false return is define by -1. +
+Reimplemented in NLAIAGENT::IVector, NLAIAGENT::CLocalAgentMail, NLAIAGENT::INombreDefine, NLAIAGENT::IBaseGroupType, and NLAIAGENT::CMessageScript. +
+Definition at line 246 of file baseai.cpp. +
+References sint32. +
+Referenced by NLAISCRIPT::CCompilateur::getValidateHierarchyBase(), NLAIAGENT::CLocalAgentMail::isClassInheritedFrom(), NLAIAGENT::CActorScript::Launch(), NLAIAGENT::CFsmScript::setTopLevel(), and NLAIAGENT::CActorScript::setTopLevel(). +
+
00247 { +00248 return -1; +00249 } +

+

+ + + + +
+ + + + + + + + + + +
bool NLAILOGIC::CVarSet::isEqual ( const NLAIAGENT::IBasicObjectIA & a ) const [inherited]
+
+ + + + + +
+ + + +
+ +
+Reimplemented in NLAILOGIC::CFactPattern. +
+Definition at line 131 of file varset.cpp. +
+References sint32. +
+
00132 { +00133 /* if ( ! ( _Assert == ((CVarSet &)a)._Assert ) ) +00134 return false; +00135 */ +00136 for (sint32 i = 0; i < (sint32)_Vars.size() ; i++ ) +00137 { +00138 if (! ( ( *_Vars[ i ] ) == ( *((CVarSet &) a)._Vars[i]) )) +00139 return false; +00140 } +00141 return true; +00142 } +

+

+ + + + +
+ + + + + + + + + + +
bool NLAILOGIC::CVarSet::isEqual ( const CVarSet & a ) const [virtual, inherited]
+
+ + + + + +
+ + + +
+ +
+Definition at line 126 of file varset.cpp. +
+Referenced by NLAILOGIC::CVarSet::operator!=(). +
+
00127 { +00128 return false; +00129 } +

+

+ + + + +
+ + + + + + + + + +
bool NLAIAGENT::IObjectIA::isLocal ( ) [virtual, inherited]
+
+ + + + + +
+ + + +
+If the result is true the object is loclal else its a representation of an object on the server. By the method return true. +
+ +
+Definition at line 356 of file baseai.cpp. +
+
00357 { +00358 return true; +00359 } +

+

+ + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + + +
TQueue NLAIAGENT::IObjectIA::isMember ( const IVarName * ,
const IVarName * ,
const IObjectIA &
) const [virtual, inherited]
+
+ + + + + +
+ + + +
+The method isMember(nameSubClass,methodName,param) return the best method correspondent to the search. remember we use the overloadind method.
+NameSubClass: if this pointer is not NULL then NameSubClass is the name of the base class were the method are defined.
+methodName: is the name of the class.
+param: is an IObjectIA where it defined the parametre of the method. lot of method use a IObjectIA vector object with an NLAIC::CIdentType as the the template argm. +
+Reimplemented in NLAIAGENT::IBasicAgent, NLAIAGENT::IVector, NLAIAGENT::CLocalAgentMail, NLAIAGENT::INombreDefine, NLAIAGENT::CPairType, NLAIAGENT::IBaseGroupType, NLAIAGENT::CVectorGroupType, NLAIAGENT::CProxyAgentMail, NLAIAGENT::CAgentTimerHandle, NLAIAGENT::IListBasicManager, NLAIAGENT::CMessageScript, and NLAIAGENT::IMessageBase. +
+Definition at line 206 of file baseai.cpp. +
+References _CONSTRUCTOR_, _RUN_, _SEND_, param, r, NLAIAGENT::IObjectIA::run(), and NLAIAGENT::TQueue. +
+Referenced by NLAIAGENT::CAgentWatchTimer::addAttrib(), NLAISCRIPT::CCompilateur::findMethode(), NLAISCRIPT::CAgentClass::isMember(), NLAIAGENT::CLocalAgentMail::isMember(), and NLAISCRIPT::CFindRunMsg::runOpCode(). +
+
00207 { +00208 static CStringVarName send(_SEND_); +00209 static CStringVarName constructor(_CONSTRUCTOR_); +00210 static CStringVarName run(_RUN_); +00211 static CStringVarName statM("GetStaticMember"); +00212 +00213 if(*methodName == send) +00214 { +00215 TQueue r; +00216 CObjectType *c = new CObjectType(new NLAIC::CIdentType(NLAIC::CIdentType::VoidType)); +00217 r.push(CIdMethod(0,0.0,NULL,c)); +00218 return r; +00219 } +00220 else +00221 if(*methodName == constructor && !((const NLAISCRIPT::CParam &)param).size()) +00222 { +00223 TQueue r; +00224 CObjectType *c = new CObjectType(new NLAIC::CIdentType(NLAIC::CIdentType::VoidType)); +00225 r.push(CIdMethod(1,0.0,NULL,c)); +00226 return r; +00227 } +00228 else +00229 if(*methodName == run && !((const NLAISCRIPT::CParam &)param).size()) +00230 { +00231 TQueue r; +00232 CObjectType *c = new CObjectType(new NLAIC::CIdentType(NLAIC::CIdentType::VoidType)); +00233 r.push(CIdMethod(2,0.0,NULL,c)); +00234 return r; +00235 } +00236 if(*methodName == statM && ((const NLAISCRIPT::CParam &)param).size()) +00237 { +00238 TQueue r; +00239 CObjectType *c = new CObjectType(new NLAIC::CIdentType(*IAgent::IdAgent)); +00240 r.push(CIdMethod(3,0.0,NULL,c)); +00241 return r; +00242 } +00243 return TQueue(); +00244 } +

+

+ + + + +
+ + + + + + + + + +
bool NLAILOGIC::CClause::isTrue ( ) const [virtual, inherited]
+
+ + + + + +
+ + + +
+throw (NLAIE::CExceptionNotImplemented) +
+ +
+Reimplemented from NLAILOGIC::CVarSet. +
+Definition at line 275 of file clause.cpp. +
+References NLAILOGIC::CClause::_NbValid. +
+Referenced by NLAILOGIC::CClause::operator!(), NLAILOGIC::CClause::operator!=(), and NLAILOGIC::CClause::operator==(). +
+
00276 { +00277 return ( _NbValid > 0 ); +00278 } +

+

+ + + + +
+ + + + + + + + + +
bool NLAILOGIC::CVarSet::isUnified ( ) [inherited]
+
+ + + + + +
+ + + +
+ +
+Definition at line 267 of file varset.cpp. +
+References NLAILOGIC::CVarSet::NbInstanciated. +
+
00268 { +00269 return ( NbInstanciated == 0 ); +00270 } +

+

+ + + + +
+ + + + + + + + + + +
void NLAILOGIC::CVarSet::load ( NLMISC::IStream & is ) [virtual, inherited]
+
+ + + + + +
+ + + +
+Load the class from a stream. +
+Implements NLAIC::IBasicInterface. +
+Definition at line 84 of file varset.cpp. +
+References NLMISC::IStream::serial(), and sint32. +
+
00085 { +00086 IObjectIA::load(is); +00087 sint32 nb_vars; +00088 is.serial( nb_vars ); +00089 +00090 for (sint32 i = 0; i < nb_vars; i++ ) +00091 { +00092 NLAIC::CIdentTypeAlloc id; +00093 is.serial( id ); +00094 IBaseVar *tmp_var = (IBaseVar *)id.allocClass(); +00095 _Vars.push_back( tmp_var ); +00096 } +00097 } +

+

+ + + + +
+ + + + + + + + + +
sint32 NLAILOGIC::CClause::nbVars ( ) [inherited]
+
+ + + + + +
+ + + +
+ +
+Definition at line 373 of file clause.cpp. +
+References sint32. +
+Referenced by NLAILOGIC::CValueSet::forward(). +
+
00374 { +00375 return _Vars.size(); +00376 } +

+

+ + + + +
+ + + + + + + + + +
const NLAIC::IBasicType * NLAILOGIC::CRule::newInstance ( ) const [virtual]
+
+ + + + + +
+ + + +
+This function allow a new instance, that mean that the class is a class factory. +
+Reimplemented from NLAILOGIC::CClause. +
+Definition at line 94 of file rule.cpp. +
+References CRule(). +
+
00095 { +00096 CRule *instance = new CRule(); +00097 return instance; +00098 } +

+

+ + + + +
+ + + + + + + + + + +
virtual IObjetOp* NLAIAGENT::IObjetOp::operator * ( IObjetOp * a ) [inline, virtual, inherited]
+
+ + + + + +
+ + + +
+throw (NLAIE::CExceptionNotImplemented) +
+ +
+Definition at line 202 of file agent_operator.h. +
+
00203 { +00204 return *this * *a; +00205 +00206 } +

+

+ + + + +
+ + + + + + + + + + +
virtual IObjetOp* NLAIAGENT::IObjetOp::operator * ( const IObjetOp & ) [inline, virtual, inherited]
+
+ + + + + +
+ + + +
+throw (NLAIE::CExceptionNotImplemented) +
+ +
+Reimplemented in NLAIAGENT::INombre< tNombre >, NLAIAGENT::INombre< double >, NLAIAGENT::INombre< uint16 >, NLAIAGENT::INombre< float >, NLAIAGENT::INombre< sint8 >, NLAIAGENT::INombre< uint64 >, NLAIAGENT::INombre< sint16 >, NLAIAGENT::INombre< uint8 >, NLAIAGENT::INombre< uint32 >, and NLAIAGENT::INombre< sint32 >. +
+Definition at line 147 of file agent_operator.h. +
+References NLAIC::IBasicType::getType(), and NLAIC::stringGetBuild(). +
+
00148 { +00149 std::string text; +00150 text = NLAIC::stringGetBuild("opertor <virtual IObjetOp *operator * (const IObjetOp &a) const> note implemented for the '%s' interface",(const char *)getType()); +00151 throw NLAIE::CExceptionNotImplemented(text.c_str()); +00152 return (IObjetOp *)this; +00153 } +

+

+ + + + +
+ + + + + + + + + + +
virtual IObjetOp& NLAIAGENT::IObjetOp::operator *= ( IObjetOp * a ) [inline, virtual, inherited]
+
+ + + + + +
+ + + +
+throw (NLAIE::CExceptionNotImplemented) +
+ +
+Definition at line 182 of file agent_operator.h. +
+
00183 { +00184 return *this *= *a; +00185 +00186 } +

+

+ + + + +
+ + + + + + + + + + +
virtual IObjetOp& NLAIAGENT::IObjetOp::operator *= ( const IObjetOp & ) [inline, virtual, inherited]
+
+ + + + + +
+ + + +
+throw (NLAIE::CExceptionNotImplemented) +
+ +
+Reimplemented in NLAIAGENT::INombre< tNombre >, NLAIAGENT::CAgentOperation, NLAIAGENT::INombre< double >, NLAIAGENT::INombre< uint16 >, NLAIAGENT::INombre< float >, NLAIAGENT::INombre< sint8 >, NLAIAGENT::INombre< uint64 >, NLAIAGENT::INombre< sint16 >, NLAIAGENT::INombre< uint8 >, NLAIAGENT::INombre< uint32 >, and NLAIAGENT::INombre< sint32 >. +
+Definition at line 110 of file agent_operator.h. +
+References NLAIC::IBasicType::getType(), and NLAIC::stringGetBuild(). +
+
00111 { +00112 std::string text; +00113 text = NLAIC::stringGetBuild("opertor <IObjectIA &operator *= (const IObjectIA &a)> note implemented for the '%s' interface",(const char *)getType()); +00114 throw NLAIE::CExceptionNotImplemented(text.c_str()); +00115 return *this; +00116 } +

+

+ + + + +
+ + + + + + + + + +
IObjetOp * NLAILOGIC::CClause::operator! ( ) const [virtual, inherited]
+
+ + + + + +
+ + + +
+throw (NLAIE::CExceptionNotImplemented) +
+ +
+Reimplemented from NLAILOGIC::CVarSet. +
+Definition at line 264 of file clause.cpp. +
+References NLAILOGIC::CClause::isTrue(). +
+
00265 { +00266 +00267 return new CBoolType( !isTrue() ); +00268 } +

+

+ + + + +
+ + + + + + + + + + +
IObjetOp * NLAILOGIC::CClause::operator!= ( NLAIAGENT::IObjetOp & a ) const [virtual, inherited]
+
+ + + + + +
+ + + +
+throw (NLAIE::CExceptionNotImplemented) +
+ +
+Reimplemented from NLAILOGIC::CVarSet. +
+Definition at line 270 of file clause.cpp. +
+References NLAIAGENT::IObjetOp::isTrue(), and NLAILOGIC::CClause::isTrue(). +
+
00271 { +00272 return new CBoolType( isTrue() != a.isTrue() ); +00273 } +

+

+ + + + +
+ + + + + + + + + + +
virtual IObjetOp* NLAIAGENT::IObjetOp::operator+ ( IObjetOp * a ) [inline, virtual, inherited]
+
+ + + + + +
+ + + +
+throw (NLAIE::CExceptionNotImplemented) +
+ +
+Reimplemented in NLAIAGENT::CGroupType, and NLAIAGENT::CVectorGroupType. +
+Definition at line 193 of file agent_operator.h. +
+
00194 { +00195 return *this + *a; +00196 } +

+

+ + + + +
+ + + + + + + + + + +
virtual IObjetOp& NLAIAGENT::IObjetOp::operator+= ( 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-= ( 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/ ( 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 } +

+

+ + + + +
+ + + + + + + + + + +
bool NLAIAGENT::IBasicObjectIA::operator== ( const IBasicObjectIA & classType ) const [inherited]
+
+ + + + + +
+ + + +
+Lot of algo use this function to determine the equality between 2 class, in particular the extraction from stl list. the == operator call the bool isEqual(const IBasicObjectIA &a) const member method to determine the equality between tow class. +
+Definition at line 134 of file baseai.cpp. +
+References NLAIC::IBasicType::getType(), and NLAIAGENT::IBasicObjectIA::isEqual(). +
+
00135 { +00136 if(a.getType() == getType() ) return isEqual(a); +00137 return false; +00138 } +

+

+ + + + +
+ + + + + + + + + + +
IObjetOp * NLAILOGIC::CClause::operator== ( NLAIAGENT::IObjetOp & a ) const [virtual, inherited]
+
+ + + + + +
+ + + +
+throw (NLAIE::CExceptionNotImplemented) +
+ +
+Reimplemented from NLAIAGENT::IObjetOp. +
+Definition at line 288 of file clause.cpp. +
+References NLAIAGENT::IObjetOp::isTrue(), and NLAILOGIC::CClause::isTrue(). +
+
00289 { +00290 return new CBoolType( isTrue() == a.isTrue() ); +00291 } +

+

+ + + + +
+ + + + + + + + + + +
IBaseVar * NLAILOGIC::CVarSet::operator[] ( sint32 ) [virtual, inherited]
+
+ + + + + +
+ + + +
+ +
+Definition at line 305 of file varset.cpp. +
+References sint32. +
+
00306 { +00307 return _Vars[i]; +00308 } +

+

+ + + + +
+ + + + + + + + + + +
void NLAILOGIC::CClause::propagate ( CFactPattern * ) [virtual, inherited]
+
+ + + + + +
+ + + +
+ +
+Definition at line 195 of file clause.cpp. +
+
00196 { +00197 // Pour chaque liaison... +00198 /* std::list< CValueSet *>::iterator it_l = _Liaisons.begin(); +00199 +00200 while ( it_l != _Liaisons.end() ) +00201 { +00202 CValueSet *result; +00203 if ( result = fp->unify( *it_l ) ) +00204 { +00205 if ( result->undefined() == 0 ) +00206 _Conflits.push_back( result ); +00207 else +00208 _BufLiaisons.push_back( result ); +00209 } +00210 it_l++; +00211 }*/ +00212 } +

+

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

+

+ + + + +
+ + + + + + + + + + +
void NLAILOGIC::CVarSet::removeVar ( IBaseVar * ) [inherited]
+
+ + + + + +
+ + + +
+ +
+Definition at line 150 of file varset.cpp. +
+
00151 { +00152 std::vector<IBaseVar *>::iterator it_var = _Vars.begin(); +00153 while ( it_var != _Vars.end() ) +00154 { +00155 if ( var == *it_var ) +00156 { +00157 ( *it_var )->release(); +00158 _Vars.erase( it_var ); +00159 return; +00160 } +00161 it_var++; +00162 } +00163 } +

+

+ + + + +
+ + + + + + + + + +
const IObjectIA::CProcessResult & NLAILOGIC::CVarSet::run ( ) [virtual, inherited]
+
+ + + + + +
+ + + +
+Some where Run method define the process of the agen. +
+Implements NLAILOGIC::IBaseBoolType. +
+Definition at line 121 of file varset.cpp. +
+
00122 { +00123 return IObjectIA::ProcessRun; +00124 } +

+

+ + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + + +
IObjectIA::CProcessResult NLAIAGENT::IObjectIA::runMethodeMember ( sint32 ,
sint32 ,
IObjectIA *
) [virtual, inherited]
+
+ + + + + +
+ + + +
+The methode runMethodeMember(sint32 heritance, sint32 index, IObjectIA *param) allow us to run a member method.
+heritance: is the id returned by the methodisClassInheritedFrom(const IVarName &). index: is the method id return by the isMember(const IVarName *,const IVarName *,const IObjectIA &) const method. param: is the parametre for the method. +
+Reimplemented in NLAIAGENT::IBasicAgent, NLAIAGENT::IVector, NLAIAGENT::CLocalAgentMail, NLAIAGENT::INombre< tNombre >, NLAIAGENT::CPairType, NLAIAGENT::IBaseGroupType, NLAIAGENT::CVectorGroupType, NLAIAGENT::CProxyAgentMail, NLAIAGENT::CAgentScript, NLAIAGENT::CAgentTimerHandle, NLAILOGIC::CGoalStack, NLAIAGENT::IListBasicManager, NLAIAGENT::CMessageScript, NLAIAGENT::IMessageBase, NLAIAGENT::CSuccessMsg, NLAIAGENT::CFailureMsg, NLAIAGENT::CFactMsg, NLAIAGENT::CGetValueMsg, NLAIAGENT::CGoalMsg, NLAIAGENT::CCancelGoalMsg, NLAIAGENT::CSetValueMsg, NLAIFUZZY::CFuzzyVar, NLAILOGIC::CFact, NLAILOGIC::CGoal, NLAILOGIC::CInternalGoal, NLAILOGIC::CGoalStack, NLAISCRIPT::CCallPrint, NLAISCRIPT::CLibTest, NLAIAGENT::INombre< double >, NLAIAGENT::INombre< uint16 >, NLAIAGENT::INombre< float >, NLAIAGENT::INombre< sint8 >, NLAIAGENT::INombre< uint64 >, NLAIAGENT::INombre< sint16 >, NLAIAGENT::INombre< uint8 >, NLAIAGENT::INombre< uint32 >, and NLAIAGENT::INombre< sint32 >. +
+Definition at line 257 of file baseai.cpp. +
+References sint32. +
+Referenced by NLAISCRIPT::CLibHeapMemberMethod::runOpCode(), NLAISCRIPT::CLibStackNewMemberMethod::runOpCode(), NLAISCRIPT::CLibStackMemberMethod::runOpCode(), NLAISCRIPT::CLibCallMethodi::runOpCode(), NLAISCRIPT::CLibCallInheritedMethod::runOpCode(), NLAISCRIPT::CLibCallMethod::runOpCode(), and NLAISCRIPT::CLibMemberMethodi::runOpCode(). +
+
00258 { +00259 /*char text[2048*8]; +00260 sprintf(text,"method runMethodeMember(sint32 h, sint32 id,const IObjectIA &) not implemented for the '%s' interface",(const char *)getType()); +00261 throw NLAIE::CExceptionNotImplemented(text); +00262 return CProcessResult();*/ +00263 return IObjectIA::runMethodeMember(id,a); +00264 } +

+

+ + + + +
+ + + + + + + + + +
const IObjectIA::CProcessResult & NLAIAGENT::IObjectIA::runStep ( ) [virtual, inherited]
+
+ + + + + +
+ + + +
+Some where Run method define the process of the agen. +
+Reimplemented in NLAIAGENT::IAgent, and NLAIAGENT::CAgentScript. +
+Definition at line 163 of file baseai.cpp. +
+References NLAIC::IBasicType::getType(), and NLAIC::stringGetBuild(). +
+Referenced by NLAIAGENT::IAgent::runChildrenStepByStep(). +
+
00164 { +00165 std::string text; +00166 text = NLAIC::stringGetBuild("const CProcessResult &IObjectIA::runStep() note implementaited for the '%s' interface",(const char *)getType()); +00167 throw NLAIE::CExceptionNotImplemented(text.c_str()); +00168 return IObjectIA::ProcessNotComplit; +00169 } +

+

+ + + + +
+ + + + + + + + + + +
void NLAILOGIC::CVarSet::save ( NLMISC::IStream & os ) [virtual, inherited]
+
+ + + + + +
+ + + +
+Save the class in a stream. +
+Implements NLAIC::IBasicInterface. +
+Definition at line 71 of file varset.cpp. +
+References NLAILOGIC::CVarSet::getType(), NLMISC::IStream::serial(), sint32, and size. +
+
00072 { +00073 IObjectIA::save(os); +00074 sint32 size = _Vars.size(); +00075 os.serial( size ); +00076 +00077 for (sint32 i = 0; i < (sint32)_Vars.size() ; i++ ) +00078 { +00079 os.serial( (NLAIC::CIdentType &) _Vars[ i ]->getType() ); +00080 _Vars[ i ]->save( os ); +00081 } +00082 } +

+

+ + + + +
+ + + + + + + + + + + + + + + + + + + +
IObjectIA::CProcessResult NLAIAGENT::IObjectIA::sendMessage ( const IVarName & ,
IObjectIA *
) [virtual, inherited]
+
+ + + + + +
+ + + +
+This method allow to send a message to an compoment given by an string IVarName. +
+Reimplemented in NLAIAGENT::CProxyAgentMail, NLAIAGENT::CAgentScript, and NLAIAGENT::IMessageBase. +
+Definition at line 334 of file baseai.cpp. +
+References NLAIAGENT::IVarName::getString(), NLAIC::IBasicType::getType(), and NLAIC::stringGetBuild(). +
+
00335 { +00336 std::string text; +00337 text = NLAIC::stringGetBuild("method 'sendMessage(%s,const IObjectIA &)' '%s' interface",name.getString(), (const char *)getType()); +00338 throw NLAIE::CExceptionNotImplemented(text.c_str()); +00339 return CProcessResult(); +00340 } +

+

+ + + + +
+ + + + + + + + + + +
IObjectIA::CProcessResult NLAIAGENT::IObjectIA::sendMessage ( IObjectIA * ) [virtual, inherited]
+
+ + + + + +
+ + + +
+The method sendMessage(const IObjectIA &msg) allow us to achive a message defined in msg. +
+Reimplemented in NLAIAGENT::CActorScript, NLAIAGENT::CLocalAgentMail, NLAIAGENT::CProxyAgentMail, NLAIAGENT::CAgentScript, NLAIAGENT::CAgentTimerHandle, NLAIAGENT::IConnectIA, NLAIAGENT::IListManager, NLAIAGENT::CMainAgentScript, and NLAIAGENT::IMessageBase. +
+Definition at line 342 of file baseai.cpp. +
+References NLAIC::IBasicType::getType(), and NLAIC::stringGetBuild(). +
+Referenced by NLAIAGENT::IObjectIA::runMethodeMember(), NLAIAGENT::CAgentScript::sendBroadCast(), NLAIAGENT::IMessageBase::sendMessage(), NLAIAGENT::IListManager::sendMessage(), and NLAIAGENT::CAgentScript::sendMessage(). +
+
00343 { +00344 std::string text; +00345 text = NLAIC::stringGetBuild("method 'sendMessage(const IObjectIA &)' '%s' interface", (const char *)getType()); +00346 throw NLAIE::CExceptionNotImplemented(text.c_str()); +00347 return CProcessResult(); +00348 } +

+

+ + + + +
+ + + + + + + + + + +
virtual void NLAIC::IBasicInterface::serial ( NLMISC::IStream & f ) throw (NLMISC::EStream) [inline, virtual, inherited]
+
+ + + + + +
+ + + +
+ +
+Reimplemented from NLAIC::IPointerGestion. +
+Definition at line 328 of file abstract_interface.h. +
+References NLAIC::IBasicInterface::load(), and NLAIC::IBasicInterface::save(). +
+
00329 { +00330 if ( f.isReading() ) +00331 load( f ); +00332 else +00333 save( f ); +00334 } +

+

+ + + + +
+ + + + + + + + + + +
void NLAILOGIC::CRule::setCond ( CClause & )
+
+ + + + + +
+ + + +
+ +
+Definition at line 67 of file rule.cpp. +
+
00068 { +00069 /* std::list< std::vector<sint32> >::const_iterator it_li = c._pos_vars.begin(); +00070 while ( it_li != c._pos_vars.end() ) +00071 { +00072 std::vector<sint32>::const_iterator it_i = (*it_li).begin(); +00073 _pos_vars.push_back( std::vector<sint32>() ); +00074 +00075 while ( it_i != (*it_li).end() ) +00076 { +00077 _pos_vars.back().push_back( *it_i ) ; +00078 it_i++; +00079 } +00080 it_li++; +00081 }*/ +00082 } +

+

+ + + + +
+ + + + + + + + + + + + + + + + + + + +
bool NLAIAGENT::IObjectIA::setStaticMember ( sint32 ,
IObjectIA *
) [virtual, inherited]
+
+ + + + + +
+ + + +
+to cahnge a given components given by a string. +
+Reimplemented in NLAIAGENT::CLocalAgentMail, NLAIAGENT::CAgentScript, NLAIAGENT::CMessageScript, and NLAISCRIPT::CAgentClass. +
+Definition at line 198 of file baseai.cpp. +
+References NLAIC::IBasicType::getType(), sint32, and NLAIC::stringGetBuild(). +
+
00199 { +00200 std::string text; +00201 text = NLAIC::stringGetBuild("Function void IObjectIA::setStaticMember(sint32,IObjectIA *) note implementaited for the '%s' interface",(const char *)getType()); +00202 throw NLAIE::CExceptionNotImplemented(text.c_str()); +00203 return false; +00204 } +

+

+ + + + +
+ + + + + + + + + + + + + + + + + + + +
bool NLAIAGENT::IObjectIA::setStaticMember ( const IVarName & compName,
IObjectIA * change
) [inline, inherited]
+
+ + + + + +
+ + + +
+to cahnge a given components given by an index. +
+Definition at line 268 of file baseai.h. +
+References NLAIAGENT::IObjectIA::getStaticMemberIndex(). +
+Referenced by NLAISCRIPT::CAffHeapMemberiOpCode::runOpCode(), NLAISCRIPT::CAffMemberiOpCode::runOpCode(), and NLAIAGENT::CLocalAgentMail::setStaticMember(). +
+
00269 { +00270 return setStaticMember(getStaticMemberIndex(compName),change); +00271 } +

+

+ + + + +
+ + + + + + + + + +
void NLAILOGIC::CClause::showBuffer ( ) [inherited]
+
+ + + + + +
+ + + +
+ +
+Definition at line 304 of file clause.cpp. +
+References NLAILOGIC::CClause::_BufLiaisons. +
+
00305 { +00306 std::list<CValueSet *>::iterator it_vs = _BufLiaisons.begin(); +00307 while ( it_vs != _BufLiaisons.end() ) +00308 { +00309 std::string buf; +00310 ( *it_vs )->getDebugString( buf ); +00311 it_vs++; +00312 } +00313 } +

+

+ + + + +
+ + + + + + + + + +
void NLAILOGIC::CClause::showConflicts ( ) [inherited]
+
+ + + + + +
+ + + +
+ +
+Definition at line 293 of file clause.cpp. +
+References NLAILOGIC::CClause::_Conflits. +
+
00294 { +00295 std::list<CValueSet *>::iterator it_vs = _Conflits.begin(); +00296 while ( it_vs != _Conflits.end() ) +00297 { +00298 std::string buf; +00299 ( *it_vs )->getDebugString( buf ); +00300 it_vs++; +00301 } +00302 } +

+

+ + + + +
+ + + + + + + + + +
void NLAILOGIC::CClause::showLiaisons ( ) [inherited]
+
+ + + + + +
+ + + +
+ +
+Definition at line 315 of file clause.cpp. +
+References NLAILOGIC::CClause::_Liaisons. +
+
00316 { +00317 std::list<CValueSet *>::iterator it_vs = _Liaisons.begin(); +00318 while ( it_vs != _Liaisons.end() ) +00319 { +00320 std::string buf; +00321 ( *it_vs )->getDebugString( buf ); +00322 it_vs++; +00323 } +00324 } +

+

+ + + + +
+ + + + + + + + + +
sint32 NLAILOGIC::CVarSet::size ( ) [inherited]
+
+ + + + + +
+ + + +
+ +
+Definition at line 240 of file varset.cpp. +
+References sint32. +
+
00241 { +00242 return _Vars.size(); +00243 } +

+

+ + + + +
+ + + + + + + + + +
float NLAILOGIC::CClause::truthValue ( ) const [virtual, inherited]
+
+ + + + + +
+ + + +
+Returns a value in [0,1]. +
+ +
+Reimplemented from NLAILOGIC::CVarSet. +
+Definition at line 280 of file clause.cpp. +
+References NLAILOGIC::CClause::_NbValid. +
+
00281 { +00282 if ( _NbValid > 0 ) +00283 return 1.0; +00284 else +00285 return 0.0; +00286 } +

+

+ + + + +
+ + + + + + + + + +
sint32 NLAILOGIC::CVarSet::undefined ( ) [virtual, inherited]
+
+ + + + + +
+ + + +
+ +
+Definition at line 296 of file varset.cpp. +
+References sint32. +
+
00297 { +00298 sint32 nb_undef = _Vars.size(); +00299 for ( sint32 i = 0; i < (sint32) _Vars.size(); i++ ) +00300 if ( _Vars[i]->getValue() != NULL ) +00301 nb_undef--; +00302 return nb_undef; +00303 } +

+

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

+

+ + + + +
+ + + + + + + + + + +
CVarSet * NLAILOGIC::CClause::unify ( CVarSet * ) [virtual, inherited]
+
+ + + + + +
+ + + +
+ +
+Reimplemented from NLAILOGIC::CVarSet. +
+Definition at line 351 of file clause.cpp. +
+
00352 { +00353 // TODO: +00354 /* +00355 std::list<CValueSet *>::iterator it_l = _Liaisons.begin(); +00356 while ( it_cond != _Conds.end() ) +00357 { +00358 CVarSet *tmp = ( *it_cond )->unify( fact ); +00359 +00360 if ( !tmp ) +00361 return; +00362 it_cond++; +00363 } +00364 */ +00365 return NULL; +00366 } +

+

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

+

+ + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + + +
CValueSet * NLAILOGIC::CClause::unifyLiaison ( const CValueSet * ,
std::list< NLAIAGENT::IObjectIA * > * ,
std::vector< sint32 > &
) [inherited]
+
+ + + + + +
+ + + +
+ +
+Definition at line 251 of file clause.cpp. +
+References NLAILOGIC::CValueSet::unify(). +
+Referenced by NLAILOGIC::CClause::propagate(). +
+
00252 { +00253 CValueSet *result; +00254 +00255 if ( (result = fp->unify( vals, pos_vals )) ) +00256 return result; +00257 else +00258 { +00259 delete result; +00260 return NULL; +00261 } +00262 } +

+

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

+

Field Documentation

+ + + + +
+ + +
std::vector<IBaseAssert *> NLAILOGIC::CClause::_Asserts [protected, inherited] +
+
+ + + + + +
+ + + +
+ +
+Definition at line 48 of file clause.h. +
+Referenced by NLAILOGIC::CClause::addCond(), and NLAILOGIC::CClause::findAssert().
+

+ + + + +
+ + +
std::list< CValueSet *> NLAILOGIC::CClause::_BufLiaisons [protected, inherited] +
+
+ + + + + +
+ + + +
+ +
+Definition at line 43 of file clause.h. +
+Referenced by NLAILOGIC::CClause::addBuffer(), NLAILOGIC::CClause::propagate(), NLAILOGIC::CClause::showBuffer(), and NLAILOGIC::CClause::~CClause().
+

+ + + + +
+ + +
std::vector<IBaseAssert *> NLAILOGIC::CRule::_Concs [private] +
+
+ + + + + +
+ + + +
+ +
+Definition at line 45 of file rule.h. +
+Referenced by CRule().
+

+ + + + +
+ + +
std::vector<IBaseBoolType *> NLAILOGIC::CClause::_Conds [protected, inherited] +
+
+ + + + + +
+ + + +
+ +
+Definition at line 40 of file clause.h. +
+Referenced by NLAILOGIC::CClause::CClause().
+

+ + + + +
+ + +
std::list< CValueSet *> NLAILOGIC::CClause::_Conflits [protected, inherited] +
+
+ + + + + +
+ + + +
+ +
+Definition at line 44 of file clause.h. +
+Referenced by NLAILOGIC::CClause::propagate(), NLAILOGIC::CClause::showConflicts(), and NLAILOGIC::CClause::~CClause().
+

+ + + + +
+ + +
bool NLAILOGIC::CClause::_FirstOrderTrue [protected, inherited] +
+
+ + + + + +
+ + + +
+ +
+Definition at line 50 of file clause.h.
+

+ + + + +
+ + +
std::list< CValueSet *> NLAILOGIC::CClause::_Liaisons [protected, inherited] +
+
+ + + + + +
+ + + +
+ +
+Definition at line 42 of file clause.h. +
+Referenced by NLAILOGIC::CClause::addBuffer(), NLAILOGIC::CClause::CClause(), NLAILOGIC::CClause::propagate(), NLAILOGIC::CClause::showLiaisons(), and NLAILOGIC::CClause::~CClause().
+

+ + + + +
+ + +
sint32 NLAILOGIC::CClause::_NbValid [protected, inherited] +
+
+ + + + + +
+ + + +
+ +
+Definition at line 45 of file clause.h. +
+Referenced by NLAILOGIC::CClause::CClause(), NLAILOGIC::CClause::isTrue(), NLAILOGIC::CClause::propagate(), and NLAILOGIC::CClause::truthValue().
+

+ + + + +
+ + +
std::vector< std::vector<sint32> > NLAILOGIC::CRule::_PosVarsConc [private] +
+
+ + + + + +
+ + + +
+ +
+Definition at line 46 of file rule.h. +
+Referenced by CRule().
+

+ + + + +
+ + +
std::vector< std::vector<sint32> > NLAILOGIC::CClause::_PosVarsCond [protected, inherited] +
+
+ + + + + +
+ + + +
+ +
+Definition at line 41 of file clause.h. +
+Referenced by NLAILOGIC::CClause::addCond(), and NLAILOGIC::CClause::CClause().
+

+ + + + +
+ + +
std::list<CBoolAssert *> NLAILOGIC::CClause::_SimpleConds [protected, inherited] +
+
+ + + + + +
+ + + +
+ +
+Definition at line 39 of file clause.h.
+

+ + + + +
+ + +
std::vector<IBaseVar *> NLAILOGIC::CVarSet::_Vars [protected, inherited] +
+
+ + + + + +
+ + + +
+ +
+Definition at line 39 of file varset.h. +
+Referenced by NLAILOGIC::CVarSet::CVarSet(), and NLAILOGIC::CVarSet::unify().
+

+ + + + +
+ + +
const NLAIC::CIdentType CClause::IdClause [static, inherited] +
+
+ + + + + +
+ + + +
+Initial value:
NLAIC::CIdentType( "Clause", NLAIC::CSelfClassFactory(CClause()), + NLAIC::CTypeOfObject::tLogic, + NLAIC::CTypeOfOperator::opAdd ) +
+
+Definition at line 437 of file static_def_init.cpp.
+

+ + + + +
+ + +
const NLAIC::CIdentType CRule::IdRule [static] +
+
+ + + + + +
+ + + +
+Initial value:
NLAIC::CIdentType( "Rule", NLAIC::CSelfClassFactory(CRule()), + NLAIC::CTypeOfObject::tLogic, + NLAIC::CTypeOfOperator::opAdd ) +
+
+Definition at line 441 of file static_def_init.cpp. +
+Referenced by getType().
+

+ + + + +
+ + +
const NLAIC::CIdentType CVarSet::IdVarSet [static, inherited] +
+
+ + + + + +
+ + + +
+ +
+Referenced by NLAILOGIC::CVarSet::getType().
+

+ + + + +
+ + +
sint32 NLAILOGIC::CVarSet::NbInstanciated [protected, inherited] +
+
+ + + + + +
+ + + +
+ +
+Definition at line 40 of file varset.h. +
+Referenced by NLAILOGIC::CVarSet::CVarSet(), NLAILOGIC::CVarSet::isUnified(), and NLAILOGIC::CVarSet::operator!().
+

+ + + + +
+ + +
TProcessStatement NLAIAGENT::IObjectIA::ProcessBuzzy = processBuzzy [static, inherited] +
+
+ + + + + +
+ + + +
+Define the an buzzy state for an agent all time in this state. +
+Definition at line 147 of file baseai.cpp.
+

+ + + + +
+ + +
TProcessStatement NLAIAGENT::IObjectIA::ProcessEnd = processEnd [static, inherited] +
+
+ + + + + +
+ + + +
+Define the an end state for an agent all time in this state. +
+Definition at line 148 of file baseai.cpp.
+

+ + + + +
+ + +
TProcessStatement NLAIAGENT::IObjectIA::ProcessError = processError [static, inherited] +
+
+ + + + + +
+ + + +
+Define the an error state for an agent all time in this state. +
+Definition at line 149 of file baseai.cpp.
+

+ + + + +
+ + +
TProcessStatement NLAIAGENT::IObjectIA::ProcessIdle = processIdle [static, inherited] +
+
+ + + + + +
+ + + +
+Define the an idle state for an agent all time in this state. +
+Definition at line 145 of file baseai.cpp.
+

+ + + + +
+ + +
TProcessStatement NLAIAGENT::IObjectIA::ProcessLocked = processLocked [static, inherited] +
+
+ + + + + +
+ + + +
+Define the an locked state for an agent all time in this state. +
+Definition at line 146 of file baseai.cpp.
+

+ + + + +
+ + +
IObjectIA::CProcessResult NLAIAGENT::IObjectIA::ProcessNotComplit = IObjectIA::CProcessResult(processNotComplete) [static, inherited] +
+
+ + + + + +
+ + + +
+ +
+Definition at line 144 of file baseai.cpp.
+

+ + + + +
+ + +
IObjectIA::CProcessResult NLAIAGENT::IObjectIA::ProcessRun = IObjectIA::CProcessResult() [static, inherited] +
+
+ + + + + +
+ + + +
+ +
+Definition at line 143 of file baseai.cpp.
+

The documentation for this class was generated from the following files:

Generated on Tue Mar 16 10:57:41 2004 for NeL by + +

+1.3.6

+ + -- cgit v1.2.1

NLAILOGIC::CRule Class Reference

IObjectIA base class method;

[NOHEADER]

[NOHEADER]

Public Types

Public Member Functions

Static Public Attributes

Protected Member Functions

Protected Attributes

Private Member Functions

Private Attributes

Member Enumeration Documentation

Constructor & Destructor Documentation

Member Function Documentation

Field Documentation