NeL: NLAISCRIPT::COperandSimple class Reference

00232                 {
+00233                         _Ident = new NLAIC::CIdentType(f);                      
+00234                 }
+

00235                                                    : _Ident(i)
+00236                 {                       
+00237                 }
+

00301                 {
+00302                         _Ident->release();                      
+00303                 }
+

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

00273                 {
+00274                         IConstraint *x = new COperandSimple(new NLAIC::CIdentType(*_Ident));
+00275                         return x;
+00276                 }               
+

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

00268                 {
+00269                         return false;
+00270                 }
+

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

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

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

00249                 {
+00250                         return _Ident;
+00251                 }
+

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

00240                 {
+00241                         if(_TxtInfo.begin() == _TxtInfo.end())
+00242                         {
+00243                                 _TxtInfo = NLAIC::stringGetBuild("constraint<COperandSimple> for %s",(const char *)*_Ident);                            
+00244                         }
+00245                         return _TxtInfo.c_str();
+00246                 }
+

00057 { return 0;}
+

00100                 {
+00101                         return _Ref;
+00102                 }
+

00254                 {
+00255                         return operandSimple;
+00256                 }
+

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

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

00259                 {
+00260                         if(getTypeOfClass() == c.getTypeOfClass() && *((const COperandSimple &)c)._Ident == *_Ident)
+00261                         {
+00262                                 return true;
+00263                         }
+00264                         return false;
+00265                 }
+

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

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

00279                 {
+00280                         return true;
+00281                 }
+

00284                 {
+00285                         if ( f.isReading() )
+00286                         {
+00287                                 if(_Ident) _Ident->release();
+00288                                 _Ident = new NLAIC::CIdentType(f);
+00289                                 _TxtInfo.clear();
+00290                                 
+00291                         }
+00292                         else
+00293                         {
+00294                                 sint32 n =  (sint32)getTypeOfClass();
+00295                                 f.serial(n);
+00296                                 _Ident->serial(f);
+00297                         }
+00298                 }
+


Redefinition of base class method
virtual void	addIndex (int i, CCodeBrancheRun *)
virtual double	eval (IOpType *)
double	evalParam (IOpType *)
virtual int	getColone () const
	get the colone of the expression that it have to be resolve by constraint in the code source.
virtual void	getError (char *) const
	get an error string when the constraint is'nt stisfied.
virtual int	getLine () const
	get the line of the expression that it have to be resolve by constraint in the code source.
virtual void	run (CCompilateur &)
	Run with a CCompilateur dependency.
virtual void	run (IConstraint *)
	Run with a IConstraint dependency.
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.
const IConstraint *	clone () const
	Get a clone pointer memory.
	COperandSimple (NLAIC::CIdentType *i)
	COperandSimple (NLMISC::IStream &f)
sint32	decRef ()
	Decrement the reference of an object.
bool	dependOn (const IConstraint *) const
	If this constraint depond on other constraint.
const NLAIC::CIdentType *	getConstraintTypeOf ()
	Type of the expression that it have to be resolve by constraint.
virtual void	getDebugString (std::string &t) const
const char *	getInfo ()
	Get a string info.
const sint32 &	getRef () const
	get the refence count.
virtual ConstraintTypeEnum	getTypeOfClass () const
	get the type of class. the type must be in the ConstraintTypeEnum enumeration.
void	incRef ()
	Inc a reference. We use this when we have to conserve a pointer memeory for exemple in a list.
bool	operator== (const IConstraint &c) const
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.
bool	satisfied ()
	If the constraint is resolved.
virtual void	serial (NLMISC::IStream &f) throw (NLMISC::EStream)
virtual	~COperandSimple ()
Static Public Member Functions
const IOpType *	loadIOpType (NLMISC::IStream &f)
	Loader for IOpType. Not that we save and load an know type.
Private Attributes
NLAIC::CIdentType *	_Ident
std::string	_TxtInfo

NLAISCRIPT::COperandSimple Class Reference

Detailed Description

Redefinition of base class method

Public Types

Public Member Functions

Static Public Member Functions

Private Attributes

Member Enumeration Documentation

Constructor & Destructor Documentation

Member Function Documentation

Field Documentation