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

NLAISCRIPT::CConstraintStackComp Class Reference

#include <constraint_stack_component.h> +

+

Inheritance diagram for NLAISCRIPT::CConstraintStackComp: +

+ +NLAISCRIPT::IOpType +NLAISCRIPT::IConstraint +NLAIC::IPointerGestion +NLMISC::IStreamable +NLMISC::IClassable + +

Detailed Description

+Class CConstraintStackComp.

+This class is allow to load component from the stack or the heap.

+

Author:
Chafik sameh

+Nevrax France

+
Date:
2000
+ +

+ +

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

NLMISC::IStreamable method.

virtual std::string getClassName ()
virtual void serial (NLMISC::IStream &) throw (NLMISC::EStream)

Public Types

enum  ConstraintTypeEnum {
+  constraintMethode, +constraintChkMethodeType, +operandSimple, +operandSimpleListOr, +
+  operandAnyObject, +operandVoid, +operandUnknown, +operationType, +
+  operationTypeGD, +operandListType, +constraintStackComp, +constraintDebug, +
+  constraintFindRun +
+ }
enum  OpCodeType { heapCall, +stackCall, +heapAffectation + }
 This enum give information of the way to load the compoment. More...


Public Member Functions

void addConstraint (IConstraint *c)
 Add a constraint dependency. We add a constraint dependency when a given constraint want the result of an other constraint.

 CConstraintStackComp (OpCodeType opCodeType, sint32 stackPos, const std::list< NLAISCRIPT::CStringType > &memberName, IOpType *typeStack, sint32 lign, sint32 col)
sint32 decRef ()
 Decrement the reference of an object.

virtual void getDebugString (std::string &t) const
const sint32getRef () const
 get the refence count.

void incRef ()
 Inc a reference. We use this when we have to conserve a pointer memeory for exemple in a list.

void popConstraint (IConstraint *c)
 pop the last constaint dependency.

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

void runConnexcion ()
 When a constraint is resoved,we call all dependency.

virtual ~CConstraintStackComp ()
IConstraint method.
void addIndex (sint32 i, CCodeBrancheRun *c)
const IConstraintclone () const
 Get a clone pointer memory.

bool dependOn (const IConstraint *) const
 If this constraint depond on other constraint.

int getColone () const
 get the colone of the expression that it have to be resolve by constraint in the code source.

const NLAIC::CIdentTypegetConstraintTypeOf ()
 Type of the expression that it have to be resolve by constraint.

void getError (char *) const
 get an error string when the constraint is'nt stisfied.

const char * getInfo ()
 Get a string info.

int getLine () const
 get the line of the expression that it have to be resolve by constraint in the code source.

virtual ConstraintTypeEnum getTypeOfClass () const
 get the type of class. the type must be in the ConstraintTypeEnum enumeration.

bool operator== (const IConstraint &c) const
void run (IConstraint *)
 Run with a IConstraint dependency.

void run (CCompilateur &)
 Run with a CCompilateur dependency.

bool satisfied ()
 If the constraint is resolved.


Static Public Member Functions

const IOpTypeloadIOpType (NLMISC::IStream &f)
 Loader for IOpType. Not that we save and load an know type.


Private Attributes

NLAIC::CIdentType_Id
 The type of compoment when it resolve.

std::list< NLAISCRIPT::CStringType_MemberName
 Set herarchy name (a hierarchy name is some thing like classBaseName.className.component).

OpCodeType _OpCodeType
 Type of load.

sint32 _StackPos
 It used when the type is a heapCall and define the heap position.

IOpType_TypeStack
 Set the type of component, it can be an unresolved constraint.

Attribut need for IConstraint method.
std::list< std::pair< sint32,
+ CCodeBrancheRun * > > 
_Code
sint32 _Col
sint32 _Lin
bool _Satisfied
char * _TxtInfo
+


Member Enumeration Documentation

+

+ + + + +
+ + +
enum NLAISCRIPT::IConstraint::ConstraintTypeEnum [inherited] +
+
+ + + + + +
+   + + +

+This enum define all IConstraint class type defined. That is'nt very clean because it is'nt very objects way to do jobs but that make easy to make job with out make heavy the hisarchy class. Because the best way is to derive class form NLAIC::IBasicInterface but we have to register class in class factory, define a save an load ..., in short make a lot of work for an internal work. If later peopole need this kind of class we'll clean it.

Enumeration values:
+ + + + + + + + + + + + + + +
constraintMethode  +Class CConstraintMethode.
constraintChkMethodeType  +Class CConstraintChkMethodeType.
operandSimple  +Class COperandSimple.
operandSimpleListOr  +class COperandSimpleListOr
operandAnyObject  +Any class!!!!
operandVoid  +Class COperandVoid.
operandUnknown  +Class COperandUnknown.
operationType  +Class COperationType.
operationTypeGD  +Class COperationTypeGD.
operandListType  +Class COperandListType.
constraintStackComp  +Class CConstraintStackComp.
constraintDebug  +Class CConstraintDebug.
constraintFindRun  +Class CConstraintFindRun.
+
+ +

+Definition at line 138 of file constraint.h. +

+

+

+ + + + +
+ + +
enum NLAISCRIPT::CConstraintStackComp::OpCodeType +
+
+ + + + + +
+   + + +

+This enum give information of the way to load the compoment. +

+

Enumeration values:
+ + + + +
heapCall  +Load the compoment from a class stored in the heap.
stackCall  +Load the compoment from a class stored in the stack.
heapAffectation  +set a compoment stored in the self class.
+
+ +

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

+

00044                                 {
+00046                         heapCall,
+00048                         stackCall,
+00050                         heapAffectation
+00051                 };
+
+


Constructor & Destructor Documentation

+

+ + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
NLAISCRIPT::CConstraintStackComp::CConstraintStackComp OpCodeType  opCodeType,
sint32  stackPos,
const std::list< NLAISCRIPT::CStringType > &  memberName,
IOpType typeStack,
sint32  lign,
sint32  col
+
+ + + + + +
+   + + +

+ +

+Definition at line 32 of file constraint_stack_component.cpp. +

+References _MemberName, _OpCodeType, _StackPos, nlinfo, s, sint32, and NLAIC::stringGetBuild(). +

+Referenced by clone(). +

+

00032                                                                                                                                                                                    :
+00033         _TypeStack(typeStack),_MemberName(memberName),_Lin(lign),_Col(col)
+00034         {               
+00035                 char m[1028*8];
+00036                 std::list<NLAISCRIPT::CStringType >::const_iterator i = _MemberName.begin();
+00037                 m[0] = 0;
+00038                 while(i != _MemberName.end())
+00039                 {
+00040                         const NLAISCRIPT::CStringType &s = *i;
+00041                         strcat(m,s.data());
+00042                         i ++;
+00043                         if(i != _MemberName.end()) strcat(m,".");
+00044                 }
+00045                 std::string text;
+00046                 text = NLAIC::stringGetBuild("resolve constraint for the component '%s' at line %d",m,_Lin);
+00047                 _TxtInfo = new char [strlen(text.c_str()) + 1];
+00048                 strcpy(_TxtInfo,text.c_str());          
+00049                 _Satisfied = false;
+00050                 _Id = NULL;
+00051                 _OpCodeType = opCodeType;
+00052                 _StackPos = stackPos;
+00053 
+00054 #ifdef NL_DEBUG
+00055                 static int kkkkk = 0;
+00056                 nlinfo("meme %4x, %d",this, kkkkk ++);
+00057 #endif
+00058         }
+
+
+

+ + + + +
+ + + + + + + + + +
NLAISCRIPT::CConstraintStackComp::~CConstraintStackComp  )  [virtual]
+
+ + + + + +
+   + + +

+ +

+Definition at line 60 of file constraint_stack_component.cpp. +

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

+

00061         {
+00062                 _TypeStack->release();
+00063                 if(_Id) delete _Id;
+00064                 delete _TxtInfo;
+00065         }
+
+


Member Function Documentation

+

+ + + + +
+ + + + + + + + + + +
void NLAISCRIPT::IConstraint::addConstraint IConstraint c  )  [inline, inherited]
+
+ + + + + +
+   + + +

+Add a constraint dependency. We add a constraint dependency when a given constraint want the result of an other constraint. +

+ +

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

+References NLAISCRIPT::IConstraint::_ConstraintList. +

+Referenced by NLAISCRIPT::COperandUnknown::COperandUnknown(). +

+

00208                 {
+00209                         _ConstraintList.push_back(c);
+00210                 }
+
+

+ + + + +
+ + + + + + + + + + + + + + + + + + + +
virtual void NLAISCRIPT::IOpType::addIndex int  i,
CCodeBrancheRun
[inline, virtual, inherited]
+
+ + + + + +
+   + + +

+Add a op-code dependency. the integer n is the index of the opcode in in the opcodePtr pointer. +

+Implements NLAISCRIPT::IConstraint. +

+Definition at line 55 of file type_def.h. +

+

00055 {}
+
+

+ + + + +
+ + + + + + + + + + + + + + + + + + + +
void NLAISCRIPT::CConstraintStackComp::addIndex sint32  i,
CCodeBrancheRun c
[inline]
+
+ + + + + +
+   + + +

+ +

+Definition at line 90 of file constraint_stack_component.h. +

+References sint32. +

+

00091                 {
+00092                         _Code.push_back(std::pair<sint32, CCodeBrancheRun *>(i,c));
+00093                 }
+
+

+ + + + +
+ + + + + + + + + +
const IConstraint * NLAISCRIPT::CConstraintStackComp::clone  )  const [virtual]
+
+ + + + + +
+   + + +

+Get a clone pointer memory. +

+ +

+Implements NLAISCRIPT::IConstraint. +

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

+References _MemberName, _OpCodeType, _TypeStack, CConstraintStackComp(), NLAIC::IPointerGestion::incRef(), and x. +

+

00181         {
+00182                 _TypeStack->incRef();
+00183                 IConstraint *x = new CConstraintStackComp(_OpCodeType,0,_MemberName,_TypeStack,_Lin,_Col);
+00184                 return x;
+00185         }
+
+

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

+ + + + +
+ + + + + + + + + + +
bool NLAISCRIPT::CConstraintStackComp::dependOn const IConstraint  )  const [virtual]
+
+ + + + + +
+   + + +

+If this constraint depond on other constraint. +

+ +

+Implements NLAISCRIPT::IConstraint. +

+Definition at line 157 of file constraint_stack_component.cpp. +

+References _TypeStack. +

+

00158         {
+00159                 return _TypeStack == c;
+00160         }
+
+

+ + + + +
+ + + + + + + + + + +
double NLAISCRIPT::IOpType::eval IOpType  )  [virtual, inherited]
+
+ + + + + +
+   + + +

+ +

+Reimplemented in NLAISCRIPT::COperandSimpleListOr. +

+Definition at line 76 of file type_def.cpp. +

+References NLAISCRIPT::IOpType::evalParam(), NLAISCRIPT::IConstraint::getConstraintTypeOf(), NLAISCRIPT::IConstraint::getTypeOfClass(), NLAISCRIPT::l, and x. +

+Referenced by NLAISCRIPT::CParam::eval(). +

+

00077         {
+00078                 if(getConstraintTypeOf() != NULL && e->getConstraintTypeOf() != NULL)
+00079                 {
+00080                         if(e->getTypeOfClass() == operandSimpleListOr)
+00081                         {
+00082                                 COperandSimpleListOr *l = (COperandSimpleListOr *)e;
+00083                                 std::list<NLAIC::CIdentType *>::const_iterator i = l->getList().begin();
+00084                                 while(i != l->getList().end() )
+00085                                 {
+00086                                         COperandSimple *x =new COperandSimple (new NLAIC::CIdentType(*(*i++)));
+00087                                         double d = evalParam(x);
+00088                                         delete x;
+00089                                         if(d >= 0.0) return d;                                  
+00090                                 }
+00091 
+00092                         }
+00093                         else return evalParam(e);
+00094                 }
+00095                 return -1.0;
+00096         }
+
+

+ + + + +
+ + + + + + + + + + +
double NLAISCRIPT::IOpType::evalParam IOpType  )  [inherited]
+
+ + + + + +
+   + + +

+ +

+Definition at line 34 of file type_def.cpp. +

+References NLAISCRIPT::IClassInterpret::getComputeBaseClass(), NLAISCRIPT::IConstraint::getConstraintTypeOf(), NLAIC::CIdentType::getFactory(), NLAISCRIPT::IClassInterpret::getType(), and type. +

+Referenced by NLAISCRIPT::IOpType::eval(). +

+

00035         {
+00036                 double d;
+00037                 if(e->getConstraintTypeOf() != NULL)
+00038                 {
+00039                         const NLAIC::CIdentType &idG = *getConstraintTypeOf();
+00040                         const NLAIC::CIdentType &idD = *e->getConstraintTypeOf();
+00041                         if(!(idG == idD))
+00042                         {
+00043                                 if(((const NLAIC::CTypeOfObject &)idD) & NLAIC::CTypeOfObject::tInterpret )
+00044                                 {
+00045                                         IClassInterpret *o = (IClassInterpret *)((CClassInterpretFactory *)idD.getFactory())->getClass();                                               
+00046                                         bool type = false;                                              
+00047                                         d = 0.0;
+00048                                         while(o != NULL)
+00049                                         {                                                               
+00050                                                 if( o->getType() == idG)
+00051                                                 {
+00052                                                         d += 1.0;
+00053                                                         type = true;
+00054                                                         break;
+00055                                                 }
+00056                                                 o = (IClassInterpret *)o->getComputeBaseClass();                                                
+00057                                         }
+00058                                         if(!type) return -1.0;
+00059                                         else return d;
+00060                                 }
+00061                                 else
+00062                                 {
+00063                                         //NLAIC::CTypeOfObject o_t(tNombre | TString | tList | tLogic);
+00064                                         if(((const NLAIC::CTypeOfObject &)idD) & ((const NLAIC::CTypeOfObject &)idG))
+00065                                         {
+00066                                                 return 0.0;
+00067                                         }
+00068                                         else return -1.0;
+00069                                 }
+00070                         }
+00071                         else return 0.0;
+00072                 }
+00073                 else return -1.0;               
+00074         }
+
+

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

+ + + + +
+ + + + + + + + + +
int NLAISCRIPT::CConstraintStackComp::getColone  )  const [inline, virtual]
+
+ + + + + +
+   + + +

+get the colone of the expression that it have to be resolve by constraint in the code source. +

+ +

+Reimplemented from NLAISCRIPT::IOpType. +

+Definition at line 106 of file constraint_stack_component.h. +

+

00107                 {
+00108                         return _Col;
+00109                 }
+
+

+ + + + +
+ + + + + + + + + +
const NLAIC::CIdentType * NLAISCRIPT::CConstraintStackComp::getConstraintTypeOf  )  [virtual]
+
+ + + + + +
+   + + +

+Type of the expression that it have to be resolve by constraint. +

+ +

+Implements NLAISCRIPT::IConstraint. +

+Definition at line 187 of file constraint_stack_component.cpp. +

+

00188         {
+00189                 return _Id;
+00190         }
+
+

+ + + + +
+ + + + + + + + + + +
virtual void NLAIC::IPointerGestion::getDebugString std::string &  t  )  const [inline, virtual, inherited]
+
+ + + + + +
+   + + +

+ +

+Reimplemented in NLAILINK::IOTrace, NLAIAGENT::CActor, NLAIAGENT::CActorScript, NLAIAGENT::IAgent, NLAIAGENT::VectorType, NLAIAGENT::DigitalType, NLAIAGENT::BorneDigitalType, NLAIAGENT::DDigitalType, NLAIAGENT::BorneDDigitalType, NLAIAGENT::IntegerType, NLAIAGENT::ShortIntegerType, NLAIAGENT::CharType, NLAIAGENT::UInt8Type, NLAIAGENT::UInt16Type, NLAIAGENT::UInt32Type, NLAIAGENT::UInt64Type, NLAIAGENT::CLocalAgentMail, NLAIAGENT::CStringType, NLAIAGENT::CPairType, NLAIAGENT::CGroupType, NLAIAGENT::CVectorGroupType, NLAIAGENT::CProxyAgentMail, NLAIAGENT::CAgentScript, NLAIAGENT::CStringVarName, NLAIAGENT::CIndexedVarName, NLAIAGENT::CAgentManagerTimer, NLAIAGENT::CLibTimerManager, NLAIAGENT::CAgentWatchTimer, NLAIAGENT::CAgentTimerHandle, NLAILOGIC::CGoalStack, NLAIAGENT::CLocWordNumRef, NLAIAGENT::IListBasicManager, NLAIAGENT::CLocalMailBox, NLAIAGENT::CMessageScript, NLAIAGENT::IMessageBase, NLAIAGENT::CSuccessMsg, NLAIAGENT::CFailureMsg, NLAIAGENT::CFactMsg, NLAIAGENT::CGetValueMsg, NLAIAGENT::CGoalMsg, NLAIAGENT::CCancelGoalMsg, NLAIAGENT::CMessageGroup, NLAIAGENT::CNotifyParentScript, NLAIAGENT::COnChangeMsg, NLAIAGENT::CSetValueMsg, NLAIAGENT::CObjectIdent, NLAIAGENT::CObjectType, NLAIAGENT::CAgentOperation, NLAIAGENT::CHashTimerManager, NLAIAGENT::CVolatilMemmory, NLAIC::IBasicType, NLAIC::CSelfClassFactory, NLAIC::CBinaryType, NLAICHARACTER::CCharacterChild, NLAIFUZZY::CSimpleFuzzyCond, NLAIFUZZY::CFuzzyFact, NLAIFUZZY::CFuzzyRule, NLAIFUZZY::CFuzzyRuleSet, NLAIFUZZY::CFuzzyInterval, NLAIFUZZY::CRightFuzzySet, NLAIFUZZY::CTriangleFuzzySet, NLAIFUZZY::CTrapezeFuzzySet, NLAIFUZZY::CLeftFuzzySet, NLAIFUZZY::FuzzyType, NLAIFUZZY::CFuzzyVar, NLAILOGIC::CBoolAssert, NLAILOGIC::CBoolOperator, NLAILOGIC::CBoolType, NLAILOGIC::CClause, NLAILOGIC::CFact, NLAILOGIC::CFactBase, NLAILOGIC::CFirstOrderAssert, NLAILOGIC::CFirstOrderOperator, NLAIAGENT::CFsmScript, NLAIAGENT::CSeqFsmScript, NLAILOGIC::CGoal, NLAILOGIC::CInternalGoal, NLAILOGIC::CGoalStack, NLAISCRIPT::COperatorClass, NLAIAGENT::COperatorScript, NLAILOGIC::CRule, NLAILOGIC::CValueSet, NLAILOGIC::CVar, NLAILOGIC::CVarSet, NLAILOGIC::CFactPattern, NLAISCRIPT::CCodeContext, NLAISCRIPT::CCodeBrancheRun, NLAISCRIPT::CContextDebug, NLAISCRIPT::CActorClass, NLAISCRIPT::CFsmClass, NLAISCRIPT::CParam, NLAISCRIPT::CMethodeName, NLAISCRIPT::CClassInterpretFactory, NLAISCRIPT::CAgentClass, NLAISCRIPT::CManagerClass, NLAISCRIPT::CMessageClass, NLAISCRIPT::CCallPrint, NLAISCRIPT::IBlock, NLAISCRIPT::ILoadObject, NLAISCRIPT::CObjectUnknown, NLAISCRIPT::CTellOpCode, NLAISCRIPT::CLdbOpCode, NLAISCRIPT::CLdbMemberOpCode, NLAISCRIPT::CLdbMemberiOpCode, NLAISCRIPT::CLdbStackMemberiOpCode, NLAISCRIPT::CLdbHeapMemberiOpCode, NLAISCRIPT::CScriptDebugSourceFile, NLAISCRIPT::CScriptDebugSourceMemory, NLAISCRIPT::CLibTest, NLAISCRIPT::CVarPStack, NLAISCRIPT::CVarPStackParam, and NLAISCRIPT::IOpRunCode. +

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

+References t. +

+

00105                 {
+00106                         t += "None";
+00107                 }
+
+

+ + + + +
+ + + + + + + + + + +
void NLAISCRIPT::CConstraintStackComp::getError char *   )  const [virtual]
+
+ + + + + +
+   + + +

+get an error string when the constraint is'nt stisfied. +

+ +

+Reimplemented from NLAISCRIPT::IOpType. +

+Definition at line 173 of file constraint_stack_component.cpp. +

+References NLAIC::stringGetBuild(). +

+

00174         {
+00175                 std::string text;
+00176                 text = NLAIC::stringGetBuild("can't %s",_TxtInfo);
+00177                 strcpy(txt, (char *)text.c_str());
+00178         }
+
+

+ + + + +
+ + + + + + + + + +
const char* NLAISCRIPT::CConstraintStackComp::getInfo  )  [inline, virtual]
+
+ + + + + +
+   + + +

+Get a string info. +

+ +

+Implements NLAISCRIPT::IConstraint. +

+Definition at line 78 of file constraint_stack_component.h. +

+

00079                 {
+00080                         return _TxtInfo;
+00081                 }
+
+

+ + + + +
+ + + + + + + + + +
int NLAISCRIPT::CConstraintStackComp::getLine  )  const [inline, virtual]
+
+ + + + + +
+   + + +

+get the line of the expression that it have to be resolve by constraint in the code source. +

+ +

+Reimplemented from NLAISCRIPT::IOpType. +

+Definition at line 102 of file constraint_stack_component.h. +

+

00103                 {
+00104                         return _Lin;
+00105                 }
+
+

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

+ + + + +
+ + + + + + + + + +
virtual ConstraintTypeEnum NLAISCRIPT::CConstraintStackComp::getTypeOfClass  )  const [inline, virtual]
+
+ + + + + +
+   + + +

+get the type of class. the type must be in the ConstraintTypeEnum enumeration. +

+ +

+Implements NLAISCRIPT::IConstraint. +

+Definition at line 96 of file constraint_stack_component.h. +

+Referenced by operator==(). +

+

00097                 {
+00098                         return constraintStackComp;
+00099                 }
+
+

+ + + + +
+ + + + + + + + + +
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(), 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                 }
+
+

+ + + + +
+ + + + + + + + + + +
const IOpType * NLAISCRIPT::IOpType::loadIOpType NLMISC::IStream f  )  [inline, static, inherited]
+
+ + + + + +
+   + + +

+Loader for IOpType. Not that we save and load an know type. +

+ +

+Definition at line 982 of file type_def.h. +

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

+

00983         {
+00984                 IConstraint::ConstraintTypeEnum k = constraintMethode;
+00985                 IOpType *x;
+00986 
+00987                 f.serial((sint32 &)k);
+00988         
+00989                 switch(k)
+00990                 {
+00991                 case operandAnyObject:
+00992                         x = new  COperandAnyObject();
+00993                         return x;
+00994 
+00995                 case operandVoid:
+00996                         x = new COperandVoid();
+00997                         return x;
+00998 
+00999                 case operandSimple:
+01000                         x = new COperandSimple(f);
+01001                         return x;
+01002 
+01003                 case operandSimpleListOr:
+01004                         x = new COperandSimpleListOr(f);
+01005                         return x;
+01006                 default: break;
+01007                 }
+01008                 return NULL;
+01009         }
+
+

+ + + + +
+ + + + + + + + + + +
bool NLAISCRIPT::CConstraintStackComp::operator== const IConstraint c  )  const [virtual]
+
+ + + + + +
+   + + +

+ +

+Implements NLAISCRIPT::IConstraint. +

+Definition at line 162 of file constraint_stack_component.cpp. +

+References _MemberName, _OpCodeType, _StackPos, _TypeStack, NLAISCRIPT::IConstraint::getTypeOfClass(), and getTypeOfClass(). +

+

00163         {
+00164                 if((getTypeOfClass() == c.getTypeOfClass()) && *((const CConstraintStackComp &)c)._TypeStack == *_TypeStack)
+00165                 {
+00166                         return  ((const CConstraintStackComp &)c)._MemberName == _MemberName && 
+00167                                         ((const CConstraintStackComp &)c)._OpCodeType == _OpCodeType && 
+00168                                         ((const CConstraintStackComp &)c)._StackPos == _StackPos;
+00169                 }
+00170                 return false;
+00171         }
+
+

+ + + + +
+ + + + + + + + + + +
void NLAISCRIPT::IConstraint::popConstraint IConstraint c  )  [inherited]
+
+ + + + + +
+   + + +

+pop the last constaint dependency. +

+ +

+Definition at line 32 of file constraint.cpp. +

+References NLAISCRIPT::IConstraint::_ConstraintList. +

+Referenced by NLAISCRIPT::COperandUnknown::~COperandUnknown(). +

+

00033         {
+00034                 std::list<IConstraint *>::iterator it = _ConstraintList.begin();
+00035                 while(it != _ConstraintList.end())
+00036                 {                       
+00037                         if(*it == c)
+00038                         {
+00039                                 _ConstraintList.erase(it);
+00040                                 break;
+00041                         }
+00042                         it ++ ;
+00043                 }               
+00044         }
+
+

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

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

+ +

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

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

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

+

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

+ + + + +
+ + + + + + + + + + +
void NLAISCRIPT::CConstraintStackComp::run IConstraint  )  [virtual]
+
+ + + + + +
+   + + +

+Run with a IConstraint dependency. +

+ +

+Reimplemented from NLAISCRIPT::IOpType. +

+Definition at line 153 of file constraint_stack_component.cpp. +

+

00154         {               
+00155         }
+
+

+ + + + +
+ + + + + + + + + + +
void NLAISCRIPT::CConstraintStackComp::run CCompilateur  )  [virtual]
+
+ + + + + +
+   + + +

+Run with a CCompilateur dependency. +

+ +

+Reimplemented from NLAISCRIPT::IOpType. +

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

+References _MemberName, _OpCodeType, _StackPos, _TypeStack, NLAISCRIPT::IConstraint::getConstraintTypeOf(), NLAIC::CIdentType::getFactory(), NLAIAGENT::IObjectIA::getStaticMemberIndex(), heapAffectation, NLAISCRIPT::CCompilateur::isValidateVarName(), NLAIC::IPointerGestion::release(), NLAISCRIPT::IOpType::run(), NLAISCRIPT::IConstraint::satisfied(), sint32, and x. +

+

00068         {
+00069                 if(_Satisfied) return;
+00070                 _TypeStack->run(comp);
+00071                 if(_TypeStack->satisfied())
+00072                 {
+00073                         if(_MemberName.size() == 1)
+00074                         {
+00075                                 const NLAIAGENT::IObjectIA *c = (NLAIAGENT::IObjectIA *)((NLAIC::IClassFactory *)_TypeStack->getConstraintTypeOf()->getFactory())->getClass();
+00076                                 sint32 i = c->getStaticMemberIndex(NLAIAGENT::CStringVarName(_MemberName.front().data()));
+00077                                 if(i >= 0)
+00078                                 {                                       
+00079                                         /*if((const NLAIC::CTypeOfObject &)c->getType() & NLAIC::CTypeOfObject::tAgentInterpret) 
+00080                                         {
+00081                                                 i += comp.getCompementShift((IClassInterpret *)c);
+00082                                         }*/                                     
+00083 
+00084                                         std::list<sint32> b;
+00085                                         b.push_back(i);
+00086                                         IOpCode *x=0;
+00087                                         switch(_OpCodeType)
+00088                                         {
+00089                                         case stackCall:
+00090                                                 x = new CLdbStackMemberiOpCode(b);
+00091                                                 break;
+00092                                         case heapCall:
+00093                                                 x = new CLdbHeapMemberiOpCode(b,_StackPos);
+00094                                                 break;
+00095 
+00096                                         case heapAffectation:
+00097                                                 x = new CAffHeapMemberiOpCode(b,_StackPos);
+00098                                                 break;
+00099                                                 
+00100                                         }
+00101 
+00102                                         std::pair<sint32, CCodeBrancheRun *> &p = _Code.back();
+00103                                         IOpCode *op = (*p.second)[p.first];//
+00104                                         op->release();
+00105                                         (*p.second)[p.first] = x;
+00106                                         _Code.pop_back();       
+00107                                         _Satisfied = true;
+00108                                 }
+00109                                 else
+00110                                 {                                       
+00111                                         return;
+00112                                 }                                                               
+00113                         }
+00114                         else
+00115                         {
+00116                                 std::list<sint32> b;
+00117                                 IOpType *c;
+00118                                 NLAIAGENT::IObjectIA *cl = (NLAIAGENT::IObjectIA *)((NLAIC::IClassFactory *)_TypeStack->getConstraintTypeOf()->getFactory())->getClass();
+00119                                 if(!comp.isValidateVarName(cl,b,_MemberName,c) && c->getConstraintTypeOf() != NULL)
+00120                                 {
+00121                                         c->release();
+00122                                         return;
+00123                                 }
+00124                                 _Id = new NLAIC::CIdentType (*c->getConstraintTypeOf());
+00125                                 c->release();
+00126                                 IOpCode *x=0;
+00127 
+00128                                 switch(_OpCodeType)
+00129                                 {
+00130                                 case stackCall:
+00131                                         x = new CLdbStackMemberiOpCode(b);
+00132                                         break;
+00133                                 case heapCall:
+00134                                         x = new CLdbHeapMemberiOpCode(b,_StackPos);
+00135                                         break;
+00136 
+00137                                 case heapAffectation:
+00138                                         x = new CAffHeapMemberiOpCode(b,_StackPos);
+00139                                         break;
+00140                                 }
+00141 
+00142                                 std::pair<sint32, CCodeBrancheRun *> &p = _Code.back();
+00143                                 IOpCode *op = (*p.second)[p.first];//
+00144                                 op->release();
+00145                                 (*p.second)[p.first] = x;
+00146                                 _Code.pop_back();       
+00147                                 _Satisfied = true;
+00148                                 
+00149                         }
+00150                 }
+00151         }
+
+

+ + + + +
+ + + + + + + + + +
void NLAISCRIPT::IConstraint::runConnexcion  )  [inline, inherited]
+
+ + + + + +
+   + + +

+When a constraint is resoved,we call all dependency. +

+ +

+Definition at line 214 of file constraint.h. +

+References NLAISCRIPT::IConstraint::_ConstraintList, and NLAISCRIPT::IConstraint::run(). +

+Referenced by NLAISCRIPT::CConstraintChkMethodeType::run(), NLAISCRIPT::CConstraintFindRun::setOpCode(), and NLAISCRIPT::CConstraintMethode::setOpCode(). +

+

00215                 {
+00216                         while(_ConstraintList.size())
+00217                         {
+00218                                 IConstraint *a = _ConstraintList.back();
+00219                                 _ConstraintList.pop_back();
+00220                                 a->run(this);
+00221                         }               
+00222                 }
+
+

+ + + + +
+ + + + + + + + + +
bool NLAISCRIPT::CConstraintStackComp::satisfied  )  [inline, virtual]
+
+ + + + + +
+   + + +

+If the constraint is resolved. +

+ +

+Implements NLAISCRIPT::IConstraint. +

+Definition at line 84 of file constraint_stack_component.h. +

+

00085                 {
+00086                         return _Satisfied;
+00087                 }
+
+

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

+ +

+Implements NLMISC::IStreamable. +

+Reimplemented in NLAIC::CIdentType, NLAIC::IBasicInterface, NLAISCRIPT::COperandVoid, NLAISCRIPT::COperandAnyObject, NLAISCRIPT::COperandSimple, NLAISCRIPT::COperandSimpleListOr, NLAISCRIPT::COperandUnknown, NLAISCRIPT::COperationType, NLAISCRIPT::COperationTypeGD, and NLAISCRIPT::COperandListType. +

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

+Referenced by NLAISCRIPT::CFindRunMsg::save(). +

+

00121                 {
+00122                 }
+
+


Field Documentation

+

+ + + + +
+ + +
std::list<std::pair<sint32, CCodeBrancheRun *> > NLAISCRIPT::CConstraintStackComp::_Code [private] +
+
+ + + + + +
+   + + +

+ +

+Definition at line 64 of file constraint_stack_component.h.

+

+ + + + +
+ + +
sint32 NLAISCRIPT::CConstraintStackComp::_Col [private] +
+
+ + + + + +
+   + + +

+ +

+Definition at line 61 of file constraint_stack_component.h.

+

+ + + + +
+ + +
NLAIC::CIdentType* NLAISCRIPT::CConstraintStackComp::_Id [private] +
+
+ + + + + +
+   + + +

+The type of compoment when it resolve. +

+ +

+Definition at line 68 of file constraint_stack_component.h.

+

+ + + + +
+ + +
sint32 NLAISCRIPT::CConstraintStackComp::_Lin [private] +
+
+ + + + + +
+   + + +

+ +

+Definition at line 60 of file constraint_stack_component.h.

+

+ + + + +
+ + +
std::list<NLAISCRIPT::CStringType > NLAISCRIPT::CConstraintStackComp::_MemberName [private] +
+
+ + + + + +
+   + + +

+Set herarchy name (a hierarchy name is some thing like classBaseName.className.component). +

+ +

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

+Referenced by CConstraintStackComp(), clone(), operator==(), and run().

+

+ + + + +
+ + +
OpCodeType NLAISCRIPT::CConstraintStackComp::_OpCodeType [private] +
+
+ + + + + +
+   + + +

+Type of load. +

+ +

+Definition at line 70 of file constraint_stack_component.h. +

+Referenced by CConstraintStackComp(), clone(), operator==(), and run().

+

+ + + + +
+ + +
bool NLAISCRIPT::CConstraintStackComp::_Satisfied [private] +
+
+ + + + + +
+   + + +

+ +

+Definition at line 62 of file constraint_stack_component.h.

+

+ + + + +
+ + +
sint32 NLAISCRIPT::CConstraintStackComp::_StackPos [private] +
+
+ + + + + +
+   + + +

+It used when the type is a heapCall and define the heap position. +

+ +

+Definition at line 72 of file constraint_stack_component.h. +

+Referenced by CConstraintStackComp(), operator==(), and run().

+

+ + + + +
+ + +
char* NLAISCRIPT::CConstraintStackComp::_TxtInfo [private] +
+
+ + + + + +
+   + + +

+ +

+Definition at line 63 of file constraint_stack_component.h.

+

+ + + + +
+ + +
IOpType* NLAISCRIPT::CConstraintStackComp::_TypeStack [private] +
+
+ + + + + +
+   + + +

+Set the type of component, it can be an unresolved constraint. +

+ +

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

+Referenced by clone(), dependOn(), operator==(), run(), and ~CConstraintStackComp().

+


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