NeL: NLAISCRIPT::CConstraintChkMethodeType class Reference

00029                                                                                                    :
00030                                         _Constraint(constraint),_Satisfied(false),_Lin(lin),_Col(col)
00031         {
00032                 _Ident = NULL;
00033                 ((CConstraintMethode *)constraint)->addConstraint(this);
00034                 std::string text;
00035                 text = NLAIC::stringGetBuild("constraint<CConstraintChkMethodeType> for %s",((IConstraint *)_Constraint)->getInfo());
00036                 _TxtInfo = new char [strlen(text.c_str()) + 1];
00037                 strcpy(_TxtInfo,text.c_str());
00038                 _RunIsDone = false;
00039         }

00086         {                                                       
00087                 if(!_RunIsDone) ((CConstraintMethode *)_Constraint)->popConstraint(this);               
00088                 _Constraint->release();
00089                 delete _TxtInfo;
00090         }

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

00042         {
00043                 IConstraint *x = new CConstraintChkMethodeType(_Constraint,_Lin,_Col);
00044                 return x;
00045         }

00094                 {
00095                         return --_Ref;
00096                 }

00084                 {
00085                         return c == _Constraint || _Constraint->dependOn(c);
00086                 }

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

00079                 {
00080                         return _Col;
00081                 }

00093                 {
00094                         return _Ident;
00095                 }

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

00081         {                       
00082                 strcpy(txt,_TxtInfo);
00083         }

00066                 {
00067                         return _TxtInfo;
00068                 }

00075                 {
00076                         return _Lin;
00077                 }

00100                 {
00101                         return _Ref;
00102                 }

00100                 {
00101                         return constraintChkMethodeType;
00102                 }

00081                 {
00082                         _Ref ++;
00083                 }

00068         {
00069                 if(getTypeOfClass() == c.getTypeOfClass() && *((const CConstraintChkMethodeType &)c)._Constraint == *_Constraint)
00070                 {
00071                         return true;
00072                 }
00073                 return false;
00074         }

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         }

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

00058         {
00059                 if(c == _Constraint)
00060                 {
00061                         //_Constraint = NULL;
00062                         _RunIsDone = true;
00063                         _Ident = (NLAIC::CIdentType *)((CConstraintMethode *)c)->getConstraintTypeOf();
00064                 }                               
00065         }

00048         {
00049                 if(_Ident == NULL)
00050                 {
00051                         _Constraint->run(c);
00052                         _Ident = (NLAIC::CIdentType *)((CConstraintMethode *)_Constraint)->getConstraintTypeOf();
00053                 }
00054                 runConnexcion();
00055         }

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

00061                 {                       
00062                         return _Satisfied;
00063                 }


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 }
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.
	CConstraintChkMethodeType (IConstraint *constraint, int lin, int col)
sint32	decRef ()
	Decrement the reference of an object.
virtual void	getDebugString (std::string &t) const
const sint32 &	getRef () 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	~CConstraintChkMethodeType ()
IConstraint method.
void	addIndex (int i, CCodeBrancheRun *c)
const IConstraint *	clone () const
	Get a clone pointer memory.
bool	dependOn (const IConstraint *c) 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::CIdentType *	getConstraintTypeOf ()
	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.
ConstraintTypeEnum	getTypeOfClass () const
	get the type of class. the type must be in the ConstraintTypeEnum enumeration.
bool	operator== (const IConstraint &) const
void	run (IConstraint *)
	Run with a IConstraint dependency.
void	run (CCompilateur &)
	Run with a CCompilateur dependency.
bool	satisfied ()
	If the constraint is resolved.
Private Attributes
IConstraint *	_Constraint
	Type of unresolving expression.
NLAIC::CIdentType *	_Ident
	Type of expression after the constraint is resolve.
bool	_RunIsDone
Attribut need for IConstraint method.
int	_Col
int	_Lin
bool	_Satisfied
char *	_TxtInfo

NLAISCRIPT::CConstraintChkMethodeType Class Reference

Detailed Description

NLMISC::IStreamable method.

Public Types

Public Member Functions

Private Attributes

Member Enumeration Documentation

Constructor & Destructor Documentation

Member Function Documentation

Field Documentation