nevrax.org : docs

00001 
+00006 /* Copyright, 2000 Nevrax Ltd.
+00007  *
+00008  * This file is part of NEVRAX NEL.
+00009  * NEVRAX NEL is free software; you can redistribute it and/or modify
+00010  * it under the terms of the GNU General Public License as published by
+00011  * the Free Software Foundation; either version 2, or (at your option)
+00012  * any later version.
+00013 
+00014  * NEVRAX NEL is distributed in the hope that it will be useful, but
+00015  * WITHOUT ANY WARRANTY; without even the implied warranty of
+00016  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+00017  * General Public License for more details.
+00018 
+00019  * You should have received a copy of the GNU General Public License
+00020  * along with NEVRAX NEL; see the file COPYING. If not, write to the
+00021  * Free Software Foundation, Inc., 59 Temple Place - Suite 330, Boston,
+00022  * MA 02111-1307, USA.
+00023  */
+00024 #ifndef NL_INTERPRET_OBJECT_AGENT_H
+00025 #define NL_INTERPRET_OBJECT_AGENT_H
+00026 #include "nel/ai/script/interpret_object.h"
+00027 #include "nel/ai/agent/msg.h"
+00028 #include "nel/ai/script/codage.h"
+00029 
+00030 namespace NLAIAGENT {
+00031         class CAgentScript;
+00032 };
+00033 
+00034 namespace NLAISCRIPT
+00035 {
+00046         class IAgentMultiClass: public IClassInterpret
+00047         {
+00048         private:
+00050                 sint32  _BaseMethodCount;
+00052                 NLAIAGENT::IObjectIA *_BaseObjectInstance;
+00053         public:
+00054 
+00055                 //IAgentMultiClass(NLAIAGENT::IObjectIA *b);
+00056                 
+00057 
+00058                 IAgentMultiClass()
+00059                 {
+00060                 }
+00061                 virtual ~IAgentMultiClass()
+00062                 {
+00063                 }
+00065                 sint32 getBaseMethodCount() const
+00066                 {
+00067                         return _BaseMethodCount;
+00068                 }
+00069 
+00071                 void setBaseMethodCount(sint32 n)
+00072                 {
+00073                         _BaseMethodCount = n;
+00074                 }
+00075 
+00077                 NLAIAGENT::IObjectIA *getBaseObjectInstance() const
+00078                 {
+00079                         return _BaseObjectInstance;
+00080                 }
+00081 
+00083                 void setBaseObjectInstance(NLAIAGENT::IObjectIA *o)
+00084                 {
+00085                         _BaseObjectInstance = o;
+00086                 }
+00087         };
+00088 
+00089         
+00101         class CAgentClass: public IAgentMultiClass
+00102         {
+00103         public:
+00104                 struct CMethodType
+00105                 {
+00106                         CMethodeName    *Method;
+00107                         bool                    DefineInBaseClass;
+00108                         
+00109                         CMethodType()
+00110                         {
+00111                                 Method = NULL;
+00112                                 DefineInBaseClass = true;
+00113                         }
+00114 
+00115                         CMethodType(const CMethodType &m)
+00116                         {
+00117                                 Method = m.Method;
+00118                                 if(Method != NULL) Method->incRef();
+00119                                 DefineInBaseClass = m.DefineInBaseClass;
+00120                         }
+00121 
+00122                         CMethodType &operator = (const CMethodType &m)
+00123                         {
+00124                                 Method = m.Method;
+00125                                 if(Method != NULL) Method->incRef();
+00126                                 DefineInBaseClass = m.DefineInBaseClass;
+00127                                 return *this;
+00128                         }
+00129 
+00130                         CMethodType(CMethodeName *m)
+00131                         {
+00132                                 Method = m;
+00133                                 DefineInBaseClass = true;
+00134                         }
+00135 
+00136                         virtual ~CMethodType()
+00137                         {
+00138                                 if(Method != NULL) Method->release();
+00139                         }
+00140 
+00141                         const bool &isBasedOnBaseClass() const
+00142                         {
+00143                                 return DefineInBaseClass;
+00144                         }
+00145 
+00146                         void setMethodBasedOnBaseClassState(bool b)
+00147                         {
+00148                                 DefineInBaseClass = b;
+00149                         }
+00150                 };
+00151         public:
+00152                 static const NLAIC::CIdentType IdAgentClass;
+00153         private:
+00154                 std::vector<CComponent *> _Components;
+00155                 std::vector<NLAIAGENT::IObjectIA *> _StaticComponents;
+00156 
+00157                 typedef std::vector<CMethodType>        tVectorMethode;
+00158                 tVectorMethode                                          _Methode;
+00159                 std::vector<const CAgentClass  *>       _VTable;
+00160                 std::vector<sint32 *>                           _MsgIndirectTable;
+00161                 sint32 _lastRef;                
+00162                 sint32 _RunIndex;
+00163                 const IClassInterpret                                           *_Base_class;
+00164 //              sint32 _NbScriptedComponents;           // Number of static components which are interpreted object (which means derived from CAgentScript)
+00165         private:                        
+00166                 NLAIAGENT::IVarName *_Inheritance;              
+00167 
+00168                 bool isMessageFunc(const CParam &) const;
+00169                 void clearIndirectMsgTable();
+00170         public:
+00171 
+00172                 CAgentClass(const NLAIAGENT::IVarName &);
+00173                 CAgentClass(const NLAIAGENT::IVarName &, const NLAIAGENT::IVarName &);
+00174                 CAgentClass(const CAgentClass &);
+00175                 CAgentClass(const NLAIC::CIdentType &);
+00176                 CAgentClass();
+00177                 virtual ~CAgentClass();
+00178 
+00179                 virtual NLAIAGENT::IObjectIA *buildNewInstance() const;
+00180                 virtual const NLAIC::IBasicType *clone() const;
+00181                 virtual const NLAIC::IBasicType *newInstance() const;
+00182                 virtual void getDebugString(std::string &) const;
+00183                 virtual void save(NLMISC::IStream &);
+00184                 virtual void load(NLMISC::IStream &);
+00185                 virtual const NLAIAGENT::IObjectIA::CProcessResult &run();
+00186                 virtual bool isEqual(const NLAIAGENT::IBasicObjectIA &a) const;
+00187 
+00188 
+00190                 virtual sint32 registerComponent(const NLAIAGENT::IVarName &type_name);
+00191                 virtual sint32 registerComponent(const NLAIAGENT::IVarName &type_name, const NLAIAGENT::CStringVarName &field_name);
+00194                 virtual CComponent *getComponent(sint32 i) const;
+00197                 virtual CComponent *getComponent(const NLAIAGENT::IVarName &name) const;
+00198                 virtual sint32 getComponentIndex(const NLAIAGENT::IVarName &) const;
+00199 //              virtual sint32 getInheritedComponentIndex(const NLAIAGENT::IVarName &name) const;
+00200 
+00203                 virtual sint32 getStaticMemberIndex(const NLAIAGENT::IVarName &) const;         
+00204                 virtual const NLAIAGENT::IObjectIA *getStaticMember(sint32) const; //throw Exc::IException &
+00206                 virtual sint32 getStaticMemberSize() const;
+00207                 sint32 getInheritedStaticMemberIndex(const NLAIAGENT::IVarName &) const;
+00208                 
+00209 
+00211                 virtual void createComponents(std::list<NLAIAGENT::IObjectIA *> &) const;
+00213                 virtual void createBaseClassComponents(std::list<NLAIAGENT::IObjectIA *> &) const;
+00215                 virtual const char *getComponentName(sint32) const;
+00216                 
+00218 
+00219                 virtual sint32 addBrancheCode(const NLAIAGENT::IVarName &,const CParam &);
+00220                 virtual CMethodeName &getBrancheCode() const; 
+00221                 virtual CMethodeName &getBrancheCode(sint32) const;
+00222                 virtual CMethodeName &getBrancheCode(sint32, sint32) const;
+00223                 virtual sint32 getBrancheCodeSize() const;
+00224                 virtual NLAIAGENT::tQueue isMember(const NLAIAGENT::IVarName *className,const NLAIAGENT::IVarName *methodName,const NLAIAGENT::IObjectIA &param) const;
+00225                 virtual NLAIAGENT::tQueue getPrivateMember(const NLAIAGENT::IVarName *,const NLAIAGENT::IVarName *,const NLAIAGENT::IObjectIA &) const;
+00226                 virtual sint32 getMethodIndexSize() const;              
+00227                 virtual sint32 getRunMethod() const;
+00228                 virtual void setRunMethod(sint32 index);
+00230                                 
+00232 
+00233                 virtual void buildVTable();
+00234                 virtual void buildVMethode();           
+00235                 virtual sint32 sizeVTable() const;
+00236                 void buildChildsMessageMap();
+00237 //              void buildChildsMessageMap(CAgentClass *);
+00238 //              void buildChildMsgPath( CAgentClass *father_class = NULL );
+00239 
+00241                 
+00243 
+00244                 virtual sint32 isClassInheritedFrom(const NLAIAGENT::IVarName &) const;
+00245                 const NLAIAGENT::IVarName *getInheritanceName() const;                                  
+00246                 void setInheritanceName(const NLAIAGENT::IVarName &name);                               
+00247                 virtual const IClassInterpret *getBaseClass() const;                                    
+00248                 const CAgentClass *getSuperClass() const;                                                               
+00249                 const void getClassPath(std::vector<const CAgentClass *> &path) const;  
+00250                 sint32 getNbBaseClass() const;                                                                                  
+00251                 virtual const IClassInterpret *getComputeBaseClass();
+00253 
+00255                 virtual const IClassInterpret *getInheritance(sint32 n) const;
+00256 
+00257                 sint32 findMethod(const NLAIAGENT::IVarName &name,const CParam &CParam) const;
+00258 
+00259                 virtual sint32 getChildMessageIndex(const NLAIAGENT::IMessageBase *, sint32);
+00260 
+00261                 // Static components 
+00262                 virtual void initStatics();
+00263                 virtual bool setStaticMember(sint32, NLAIAGENT::IObjectIA *);
+00264                 virtual void updateStaticMember(sint32, NLAIAGENT::IObjectIA *);
+00265                 virtual NLAIAGENT::IObjectIA *getStaticComponentValue(std::string &);
+00266 
+00267                 virtual NLAIC::CTypeOfObject getTypeClass() const               
+00268                 {
+00269                         uint b = NLAIC::CTypeOfObject::tObject | NLAIC::CTypeOfObject::tAgent;
+00270                         return NLAIC::CTypeOfObject((uint)IClassInterpret::getTypeClass() | b);
+00271                 }
+00272         };
+00273 }
+00274 #endif
+
interpret_object_agent.h
