# Home    # nevrax.com   
Nevrax
Nevrax.org
#News
#Mailing-list
#Documentation
#CVS
#Bugs
#License
Docs
 
Documentation  
Main Page   Namespace List   Class Hierarchy   Alphabetical List   Compound List   File List   Namespace Members   Compound Members   File Members   Related Pages   Search  

object_load.h

Go to the documentation of this file.
00001 
00007 /* Copyright, 2000 Nevrax Ltd.
00008  *
00009  * This file is part of NEVRAX NEL.
00010  * NEVRAX NEL is free software; you can redistribute it and/or modify
00011  * it under the terms of the GNU General Public License as published by
00012  * the Free Software Foundation; either version 2, or (at your option)
00013  * any later version.
00014 
00015  * NEVRAX NEL is distributed in the hope that it will be useful, but
00016  * WITHOUT ANY WARRANTY; without even the implied warranty of
00017  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
00018  * General Public License for more details.
00019 
00020  * You should have received a copy of the GNU General Public License
00021  * along with NEVRAX NEL; see the file COPYING. If not, write to the
00022  * Free Software Foundation, Inc., 59 Temple Place - Suite 330, Boston,
00023  * MA 02111-1307, USA.
00024  */
00025 
00026 #ifndef NL_OBJECT_LOAD_H
00027 #define NL_OBJECT_LOAD_H
00028 
00029 namespace NLAISCRIPT
00030 {
00040         class ILoadObject: public NLAIC::IBasicInterface
00041         {
00042         public:
00043                 ILoadObject()
00044                 {
00045 
00046                 }
00047 
00049 
00050 
00051                 virtual const NLAIAGENT::IObjectIA *getObject(CCodeContext &context) const = 0;
00053                 virtual const NLAIAGENT::IBaseGroupType *getParam(CCodeContext &context) const = 0;
00055 
00056                 virtual void getDebugString(std::string &) const{}
00057                 virtual ~ILoadObject()
00058                 {
00059                 }
00060         };
00061 
00071         class CLoadSelfObject: public ILoadObject
00072         {               
00073         public:
00074                 static const NLAIC::CIdentType IdLoadSelfObject;
00075         private:
00076                 std::list<sint32> _I;
00077         public:
00078                 CLoadSelfObject()
00079                 {
00080                 }
00081 
00082                 CLoadSelfObject(const std::list<sint32> &i):_I(i)
00083                 {
00084                 }
00085 
00086 
00088                 virtual const NLAIAGENT::IObjectIA *getObject(CCodeContext &context) const;
00090                 virtual const NLAIAGENT::IBaseGroupType *getParam(CCodeContext &context) const;
00091 
00092 
00094 
00095                 virtual const NLAIC::CIdentType &getType() const
00096                 {
00097                         return IdLoadSelfObject;
00098                 }
00099 
00100                 virtual const NLAIC::IBasicType *clone() const 
00101                 {
00102                         NLAIC::IBasicType *x= new CLoadSelfObject(_I);
00103                         return x;
00104                 }               
00105 
00106                 virtual const NLAIC::IBasicType *newInstance() const 
00107                 {
00108                         NLAIC::IBasicType *x= new CLoadSelfObject();
00109                         return x;
00110                 }
00111 
00112                 virtual void save(NLMISC::IStream &os)
00113                 {
00114                         std::list<sint32> &i = (std::list<sint32> &) _I;
00115                         os.serialCont(i);                       
00116                 }
00117                 virtual void load(NLMISC::IStream &is) 
00118                 {
00119                         is.serialCont(_I);                      
00120                 }
00122         };
00123 
00124         class CLoadStackObject: public ILoadObject
00125         {               
00126         public:
00127                 static const NLAIC::CIdentType IdLoadSelfObject;
00128         private:
00129                 std::list<sint32> _I;
00130 
00131         public:
00132                 CLoadStackObject(){}
00133                 CLoadStackObject(const std::list<sint32> &i):_I(i)
00134                 {
00135                 }
00136 
00138                 virtual const NLAIAGENT::IObjectIA *getObject(CCodeContext &context) const;
00140                 virtual const NLAIAGENT::IBaseGroupType *getParam(CCodeContext &context) const;
00141 
00143 
00144                 virtual const NLAIC::CIdentType &getType() const
00145                 {
00146                         return IdLoadSelfObject;
00147                 }
00148 
00149                 virtual const NLAIC::IBasicType *clone() const 
00150                 {
00151                         NLAIC::IBasicType *x= new CLoadStackObject(_I);
00152                         return x;
00153                 }               
00154 
00155                 virtual const NLAIC::IBasicType *newInstance() const 
00156                 {
00157                         NLAIC::IBasicType *x= new CLoadStackObject();
00158                         return x;
00159                 }
00160 
00161                 virtual void save(NLMISC::IStream &os)
00162                 {
00163                         std::list<sint32> &i = (std::list<sint32> &) _I;
00164                         os.serialCont(i);                       
00165                 }
00166                 virtual void load(NLMISC::IStream &is) 
00167                 {
00168                         is.serialCont(_I);                      
00169                 }
00171         };
00172 
00173         class CLoadHeapObject: public ILoadObject
00174         {
00175         public:
00176                 static const NLAIC::CIdentType IdLoadHeapObject;
00177         private:
00178                 std::list<sint32> _I;
00179                 sint32 _N;
00180         public:
00181                 CLoadHeapObject(){}
00182                 CLoadHeapObject(const std::list<sint32> &i,int n):_I(i),_N(n)
00183                 {
00184                 }
00185 
00187                 virtual const NLAIAGENT::IObjectIA *getObject(CCodeContext &context) const;
00189                 virtual const NLAIAGENT::IBaseGroupType *getParam(CCodeContext &context) const;
00190 
00192 
00193                 virtual const NLAIC::CIdentType &getType() const
00194                 {
00195                         return IdLoadHeapObject;
00196                 }
00197 
00198                 virtual const NLAIC::IBasicType *clone() const 
00199                 {
00200                         NLAIC::IBasicType *x= new CLoadHeapObject(_I,_N);
00201                         return x;
00202                 }               
00203 
00204                 virtual const NLAIC::IBasicType *newInstance() const 
00205                 {
00206                         NLAIC::IBasicType *x= new CLoadHeapObject();
00207                         return x;
00208                 }
00209 
00210                 virtual void save(NLMISC::IStream &os)
00211                 {
00212                         std::list<sint32> &i = (std::list<sint32> &) _I;
00213                         os.serialCont(i);
00214                         sint32 n = _N;
00215                         os.serial(n);
00216                 }
00217                 virtual void load(NLMISC::IStream &is) 
00218                 {
00219                         is.serialCont(_I);
00220                         is.serial(_N);
00221                 }
00223         };
00224 }
00225 
00226 #endif