Atlas-C++
Operation.h
00001 // This file may be redistributed and modified only under the terms of
00002 // the GNU Lesser General Public License (See COPYING for details).
00003 // Copyright 2000-2001 Stefanus Du Toit and Aloril.
00004 // Copyright 2001-2005 Alistair Riddoch.
00005 // Automatically generated using gen_cpp.py.
00006 
00007 #ifndef ATLAS_OBJECTS_OPERATION_OPERATION_H
00008 #define ATLAS_OBJECTS_OPERATION_OPERATION_H
00009 
00010 #include <Atlas/Objects/RootOperation.h>
00011 #include <Atlas/Objects/Generic.h>
00012 
00013 
00014 namespace Atlas { namespace Objects { namespace Operation { 
00015 
00026 class ActionData;
00027 typedef SmartPtr<ActionData> Action;
00028 
00029 static const int ACTION_NO = 10;
00030 
00033 
00039 class ActionData : public RootOperationData
00040 {
00041 protected:
00043     ActionData(ActionData *defaults = NULL) : 
00044         RootOperationData((RootOperationData*)defaults)
00045     {
00046         m_class_no = ACTION_NO;
00047     }
00049     virtual ~ActionData();
00050 
00051 public:
00053     virtual ActionData * copy() const;
00054 
00056     virtual bool instanceOf(int classNo) const;
00057 
00058 
00059     virtual void iterate(int& current_class, std::string& attr) const
00060         {if(current_class == ACTION_NO) current_class = -1; RootOperationData::iterate(current_class, attr);}
00061 
00062     //freelist related things
00063 public:
00064     static ActionData *alloc();
00065     virtual void free();
00066 
00071     virtual ActionData *getDefaultObject();
00072 
00077     static ActionData *getDefaultObjectInstance();
00078 private:
00079     static ActionData *defaults_ActionData;
00080     static ActionData *begin_ActionData;
00081 };
00082 
00083 
00090 class CreateData;
00091 typedef SmartPtr<CreateData> Create;
00092 
00093 static const int CREATE_NO = 11;
00094 
00097 
00099 class CreateData : public ActionData
00100 {
00101 protected:
00103     CreateData(CreateData *defaults = NULL) : 
00104         ActionData((ActionData*)defaults)
00105     {
00106         m_class_no = CREATE_NO;
00107     }
00109     virtual ~CreateData();
00110 
00111 public:
00113     virtual CreateData * copy() const;
00114 
00116     virtual bool instanceOf(int classNo) const;
00117 
00118 
00119     virtual void iterate(int& current_class, std::string& attr) const
00120         {if(current_class == CREATE_NO) current_class = -1; ActionData::iterate(current_class, attr);}
00121 
00122     //freelist related things
00123 public:
00124     static CreateData *alloc();
00125     virtual void free();
00126 
00131     virtual CreateData *getDefaultObject();
00132 
00137     static CreateData *getDefaultObjectInstance();
00138 private:
00139     static CreateData *defaults_CreateData;
00140     static CreateData *begin_CreateData;
00141 };
00142 
00143 
00150 class CombineData;
00151 typedef SmartPtr<CombineData> Combine;
00152 
00153 static const int COMBINE_NO = 12;
00154 
00157 
00159 class CombineData : public CreateData
00160 {
00161 protected:
00163     CombineData(CombineData *defaults = NULL) : 
00164         CreateData((CreateData*)defaults)
00165     {
00166         m_class_no = COMBINE_NO;
00167     }
00169     virtual ~CombineData();
00170 
00171 public:
00173     virtual CombineData * copy() const;
00174 
00176     virtual bool instanceOf(int classNo) const;
00177 
00178 
00179     virtual void iterate(int& current_class, std::string& attr) const
00180         {if(current_class == COMBINE_NO) current_class = -1; CreateData::iterate(current_class, attr);}
00181 
00182     //freelist related things
00183 public:
00184     static CombineData *alloc();
00185     virtual void free();
00186 
00191     virtual CombineData *getDefaultObject();
00192 
00197     static CombineData *getDefaultObjectInstance();
00198 private:
00199     static CombineData *defaults_CombineData;
00200     static CombineData *begin_CombineData;
00201 };
00202 
00203 
00210 class DivideData;
00211 typedef SmartPtr<DivideData> Divide;
00212 
00213 static const int DIVIDE_NO = 13;
00214 
00217 
00219 class DivideData : public CreateData
00220 {
00221 protected:
00223     DivideData(DivideData *defaults = NULL) : 
00224         CreateData((CreateData*)defaults)
00225     {
00226         m_class_no = DIVIDE_NO;
00227     }
00229     virtual ~DivideData();
00230 
00231 public:
00233     virtual DivideData * copy() const;
00234 
00236     virtual bool instanceOf(int classNo) const;
00237 
00238 
00239     virtual void iterate(int& current_class, std::string& attr) const
00240         {if(current_class == DIVIDE_NO) current_class = -1; CreateData::iterate(current_class, attr);}
00241 
00242     //freelist related things
00243 public:
00244     static DivideData *alloc();
00245     virtual void free();
00246 
00251     virtual DivideData *getDefaultObject();
00252 
00257     static DivideData *getDefaultObjectInstance();
00258 private:
00259     static DivideData *defaults_DivideData;
00260     static DivideData *begin_DivideData;
00261 };
00262 
00263 
00270 class CommunicateData;
00271 typedef SmartPtr<CommunicateData> Communicate;
00272 
00273 static const int COMMUNICATE_NO = 14;
00274 
00277 
00279 class CommunicateData : public CreateData
00280 {
00281 protected:
00283     CommunicateData(CommunicateData *defaults = NULL) : 
00284         CreateData((CreateData*)defaults)
00285     {
00286         m_class_no = COMMUNICATE_NO;
00287     }
00289     virtual ~CommunicateData();
00290 
00291 public:
00293     virtual CommunicateData * copy() const;
00294 
00296     virtual bool instanceOf(int classNo) const;
00297 
00298 
00299     virtual void iterate(int& current_class, std::string& attr) const
00300         {if(current_class == COMMUNICATE_NO) current_class = -1; CreateData::iterate(current_class, attr);}
00301 
00302     //freelist related things
00303 public:
00304     static CommunicateData *alloc();
00305     virtual void free();
00306 
00311     virtual CommunicateData *getDefaultObject();
00312 
00317     static CommunicateData *getDefaultObjectInstance();
00318 private:
00319     static CommunicateData *defaults_CommunicateData;
00320     static CommunicateData *begin_CommunicateData;
00321 };
00322 
00323 
00330 class TalkData;
00331 typedef SmartPtr<TalkData> Talk;
00332 
00333 static const int TALK_NO = 15;
00334 
00337 
00339 class TalkData : public CommunicateData
00340 {
00341 protected:
00343     TalkData(TalkData *defaults = NULL) : 
00344         CommunicateData((CommunicateData*)defaults)
00345     {
00346         m_class_no = TALK_NO;
00347     }
00349     virtual ~TalkData();
00350 
00351 public:
00353     virtual TalkData * copy() const;
00354 
00356     virtual bool instanceOf(int classNo) const;
00357 
00358 
00359     virtual void iterate(int& current_class, std::string& attr) const
00360         {if(current_class == TALK_NO) current_class = -1; CommunicateData::iterate(current_class, attr);}
00361 
00362     //freelist related things
00363 public:
00364     static TalkData *alloc();
00365     virtual void free();
00366 
00371     virtual TalkData *getDefaultObject();
00372 
00377     static TalkData *getDefaultObjectInstance();
00378 private:
00379     static TalkData *defaults_TalkData;
00380     static TalkData *begin_TalkData;
00381 };
00382 
00383 
00394 class DeleteData;
00395 typedef SmartPtr<DeleteData> Delete;
00396 
00397 static const int DELETE_NO = 16;
00398 
00401 
00407 class DeleteData : public ActionData
00408 {
00409 protected:
00411     DeleteData(DeleteData *defaults = NULL) : 
00412         ActionData((ActionData*)defaults)
00413     {
00414         m_class_no = DELETE_NO;
00415     }
00417     virtual ~DeleteData();
00418 
00419 public:
00421     virtual DeleteData * copy() const;
00422 
00424     virtual bool instanceOf(int classNo) const;
00425 
00426 
00427     virtual void iterate(int& current_class, std::string& attr) const
00428         {if(current_class == DELETE_NO) current_class = -1; ActionData::iterate(current_class, attr);}
00429 
00430     //freelist related things
00431 public:
00432     static DeleteData *alloc();
00433     virtual void free();
00434 
00439     virtual DeleteData *getDefaultObject();
00440 
00445     static DeleteData *getDefaultObjectInstance();
00446 private:
00447     static DeleteData *defaults_DeleteData;
00448     static DeleteData *begin_DeleteData;
00449 };
00450 
00451 
00462 class SetData;
00463 typedef SmartPtr<SetData> Set;
00464 
00465 static const int SET_NO = 17;
00466 
00469 
00475 class SetData : public ActionData
00476 {
00477 protected:
00479     SetData(SetData *defaults = NULL) : 
00480         ActionData((ActionData*)defaults)
00481     {
00482         m_class_no = SET_NO;
00483     }
00485     virtual ~SetData();
00486 
00487 public:
00489     virtual SetData * copy() const;
00490 
00492     virtual bool instanceOf(int classNo) const;
00493 
00494 
00495     virtual void iterate(int& current_class, std::string& attr) const
00496         {if(current_class == SET_NO) current_class = -1; ActionData::iterate(current_class, attr);}
00497 
00498     //freelist related things
00499 public:
00500     static SetData *alloc();
00501     virtual void free();
00502 
00507     virtual SetData *getDefaultObject();
00508 
00513     static SetData *getDefaultObjectInstance();
00514 private:
00515     static SetData *defaults_SetData;
00516     static SetData *begin_SetData;
00517 };
00518 
00519 
00530 class AffectData;
00531 typedef SmartPtr<AffectData> Affect;
00532 
00533 static const int AFFECT_NO = 18;
00534 
00537 
00543 class AffectData : public SetData
00544 {
00545 protected:
00547     AffectData(AffectData *defaults = NULL) : 
00548         SetData((SetData*)defaults)
00549     {
00550         m_class_no = AFFECT_NO;
00551     }
00553     virtual ~AffectData();
00554 
00555 public:
00557     virtual AffectData * copy() const;
00558 
00560     virtual bool instanceOf(int classNo) const;
00561 
00562 
00563     virtual void iterate(int& current_class, std::string& attr) const
00564         {if(current_class == AFFECT_NO) current_class = -1; SetData::iterate(current_class, attr);}
00565 
00566     //freelist related things
00567 public:
00568     static AffectData *alloc();
00569     virtual void free();
00570 
00575     virtual AffectData *getDefaultObject();
00576 
00581     static AffectData *getDefaultObjectInstance();
00582 private:
00583     static AffectData *defaults_AffectData;
00584     static AffectData *begin_AffectData;
00585 };
00586 
00587 
00594 class MoveData;
00595 typedef SmartPtr<MoveData> Move;
00596 
00597 static const int MOVE_NO = 19;
00598 
00601 
00603 class MoveData : public SetData
00604 {
00605 protected:
00607     MoveData(MoveData *defaults = NULL) : 
00608         SetData((SetData*)defaults)
00609     {
00610         m_class_no = MOVE_NO;
00611     }
00613     virtual ~MoveData();
00614 
00615 public:
00617     virtual MoveData * copy() const;
00618 
00620     virtual bool instanceOf(int classNo) const;
00621 
00622 
00623     virtual void iterate(int& current_class, std::string& attr) const
00624         {if(current_class == MOVE_NO) current_class = -1; SetData::iterate(current_class, attr);}
00625 
00626     //freelist related things
00627 public:
00628     static MoveData *alloc();
00629     virtual void free();
00630 
00635     virtual MoveData *getDefaultObject();
00636 
00641     static MoveData *getDefaultObjectInstance();
00642 private:
00643     static MoveData *defaults_MoveData;
00644     static MoveData *begin_MoveData;
00645 };
00646 
00647 
00658 class WieldData;
00659 typedef SmartPtr<WieldData> Wield;
00660 
00661 static const int WIELD_NO = 20;
00662 
00665 
00671 class WieldData : public SetData
00672 {
00673 protected:
00675     WieldData(WieldData *defaults = NULL) : 
00676         SetData((SetData*)defaults)
00677     {
00678         m_class_no = WIELD_NO;
00679     }
00681     virtual ~WieldData();
00682 
00683 public:
00685     virtual WieldData * copy() const;
00686 
00688     virtual bool instanceOf(int classNo) const;
00689 
00690 
00691     virtual void iterate(int& current_class, std::string& attr) const
00692         {if(current_class == WIELD_NO) current_class = -1; SetData::iterate(current_class, attr);}
00693 
00694     //freelist related things
00695 public:
00696     static WieldData *alloc();
00697     virtual void free();
00698 
00703     virtual WieldData *getDefaultObject();
00704 
00709     static WieldData *getDefaultObjectInstance();
00710 private:
00711     static WieldData *defaults_WieldData;
00712     static WieldData *begin_WieldData;
00713 };
00714 
00715 
00726 class GetData;
00727 typedef SmartPtr<GetData> Get;
00728 
00729 static const int GET_NO = 21;
00730 
00733 
00739 class GetData : public ActionData
00740 {
00741 protected:
00743     GetData(GetData *defaults = NULL) : 
00744         ActionData((ActionData*)defaults)
00745     {
00746         m_class_no = GET_NO;
00747     }
00749     virtual ~GetData();
00750 
00751 public:
00753     virtual GetData * copy() const;
00754 
00756     virtual bool instanceOf(int classNo) const;
00757 
00758 
00759     virtual void iterate(int& current_class, std::string& attr) const
00760         {if(current_class == GET_NO) current_class = -1; ActionData::iterate(current_class, attr);}
00761 
00762     //freelist related things
00763 public:
00764     static GetData *alloc();
00765     virtual void free();
00766 
00771     virtual GetData *getDefaultObject();
00772 
00777     static GetData *getDefaultObjectInstance();
00778 private:
00779     static GetData *defaults_GetData;
00780     static GetData *begin_GetData;
00781 };
00782 
00783 
00794 class PerceiveData;
00795 typedef SmartPtr<PerceiveData> Perceive;
00796 
00797 static const int PERCEIVE_NO = 22;
00798 
00801 
00807 class PerceiveData : public GetData
00808 {
00809 protected:
00811     PerceiveData(PerceiveData *defaults = NULL) : 
00812         GetData((GetData*)defaults)
00813     {
00814         m_class_no = PERCEIVE_NO;
00815     }
00817     virtual ~PerceiveData();
00818 
00819 public:
00821     virtual PerceiveData * copy() const;
00822 
00824     virtual bool instanceOf(int classNo) const;
00825 
00826 
00827     virtual void iterate(int& current_class, std::string& attr) const
00828         {if(current_class == PERCEIVE_NO) current_class = -1; GetData::iterate(current_class, attr);}
00829 
00830     //freelist related things
00831 public:
00832     static PerceiveData *alloc();
00833     virtual void free();
00834 
00839     virtual PerceiveData *getDefaultObject();
00840 
00845     static PerceiveData *getDefaultObjectInstance();
00846 private:
00847     static PerceiveData *defaults_PerceiveData;
00848     static PerceiveData *begin_PerceiveData;
00849 };
00850 
00851 
00862 class LookData;
00863 typedef SmartPtr<LookData> Look;
00864 
00865 static const int LOOK_NO = 23;
00866 
00869 
00875 class LookData : public PerceiveData
00876 {
00877 protected:
00879     LookData(LookData *defaults = NULL) : 
00880         PerceiveData((PerceiveData*)defaults)
00881     {
00882         m_class_no = LOOK_NO;
00883     }
00885     virtual ~LookData();
00886 
00887 public:
00889     virtual LookData * copy() const;
00890 
00892     virtual bool instanceOf(int classNo) const;
00893 
00894 
00895     virtual void iterate(int& current_class, std::string& attr) const
00896         {if(current_class == LOOK_NO) current_class = -1; PerceiveData::iterate(current_class, attr);}
00897 
00898     //freelist related things
00899 public:
00900     static LookData *alloc();
00901     virtual void free();
00902 
00907     virtual LookData *getDefaultObject();
00908 
00913     static LookData *getDefaultObjectInstance();
00914 private:
00915     static LookData *defaults_LookData;
00916     static LookData *begin_LookData;
00917 };
00918 
00919 
00930 class ListenData;
00931 typedef SmartPtr<ListenData> Listen;
00932 
00933 static const int LISTEN_NO = 24;
00934 
00937 
00943 class ListenData : public PerceiveData
00944 {
00945 protected:
00947     ListenData(ListenData *defaults = NULL) : 
00948         PerceiveData((PerceiveData*)defaults)
00949     {
00950         m_class_no = LISTEN_NO;
00951     }
00953     virtual ~ListenData();
00954 
00955 public:
00957     virtual ListenData * copy() const;
00958 
00960     virtual bool instanceOf(int classNo) const;
00961 
00962 
00963     virtual void iterate(int& current_class, std::string& attr) const
00964         {if(current_class == LISTEN_NO) current_class = -1; PerceiveData::iterate(current_class, attr);}
00965 
00966     //freelist related things
00967 public:
00968     static ListenData *alloc();
00969     virtual void free();
00970 
00975     virtual ListenData *getDefaultObject();
00976 
00981     static ListenData *getDefaultObjectInstance();
00982 private:
00983     static ListenData *defaults_ListenData;
00984     static ListenData *begin_ListenData;
00985 };
00986 
00987 
00998 class SniffData;
00999 typedef SmartPtr<SniffData> Sniff;
01000 
01001 static const int SNIFF_NO = 25;
01002 
01005 
01011 class SniffData : public PerceiveData
01012 {
01013 protected:
01015     SniffData(SniffData *defaults = NULL) : 
01016         PerceiveData((PerceiveData*)defaults)
01017     {
01018         m_class_no = SNIFF_NO;
01019     }
01021     virtual ~SniffData();
01022 
01023 public:
01025     virtual SniffData * copy() const;
01026 
01028     virtual bool instanceOf(int classNo) const;
01029 
01030 
01031     virtual void iterate(int& current_class, std::string& attr) const
01032         {if(current_class == SNIFF_NO) current_class = -1; PerceiveData::iterate(current_class, attr);}
01033 
01034     //freelist related things
01035 public:
01036     static SniffData *alloc();
01037     virtual void free();
01038 
01043     virtual SniffData *getDefaultObject();
01044 
01049     static SniffData *getDefaultObjectInstance();
01050 private:
01051     static SniffData *defaults_SniffData;
01052     static SniffData *begin_SniffData;
01053 };
01054 
01055 
01066 class TouchData;
01067 typedef SmartPtr<TouchData> Touch;
01068 
01069 static const int TOUCH_NO = 26;
01070 
01073 
01079 class TouchData : public PerceiveData
01080 {
01081 protected:
01083     TouchData(TouchData *defaults = NULL) : 
01084         PerceiveData((PerceiveData*)defaults)
01085     {
01086         m_class_no = TOUCH_NO;
01087     }
01089     virtual ~TouchData();
01090 
01091 public:
01093     virtual TouchData * copy() const;
01094 
01096     virtual bool instanceOf(int classNo) const;
01097 
01098 
01099     virtual void iterate(int& current_class, std::string& attr) const
01100         {if(current_class == TOUCH_NO) current_class = -1; PerceiveData::iterate(current_class, attr);}
01101 
01102     //freelist related things
01103 public:
01104     static TouchData *alloc();
01105     virtual void free();
01106 
01111     virtual TouchData *getDefaultObject();
01112 
01117     static TouchData *getDefaultObjectInstance();
01118 private:
01119     static TouchData *defaults_TouchData;
01120     static TouchData *begin_TouchData;
01121 };
01122 
01123 
01130 class LoginData;
01131 typedef SmartPtr<LoginData> Login;
01132 
01133 static const int LOGIN_NO = 27;
01134 
01137 
01139 class LoginData : public GetData
01140 {
01141 protected:
01143     LoginData(LoginData *defaults = NULL) : 
01144         GetData((GetData*)defaults)
01145     {
01146         m_class_no = LOGIN_NO;
01147     }
01149     virtual ~LoginData();
01150 
01151 public:
01153     virtual LoginData * copy() const;
01154 
01156     virtual bool instanceOf(int classNo) const;
01157 
01158 
01159     virtual void iterate(int& current_class, std::string& attr) const
01160         {if(current_class == LOGIN_NO) current_class = -1; GetData::iterate(current_class, attr);}
01161 
01162     //freelist related things
01163 public:
01164     static LoginData *alloc();
01165     virtual void free();
01166 
01171     virtual LoginData *getDefaultObject();
01172 
01177     static LoginData *getDefaultObjectInstance();
01178 private:
01179     static LoginData *defaults_LoginData;
01180     static LoginData *begin_LoginData;
01181 };
01182 
01183 
01190 class LogoutData;
01191 typedef SmartPtr<LogoutData> Logout;
01192 
01193 static const int LOGOUT_NO = 28;
01194 
01197 
01199 class LogoutData : public LoginData
01200 {
01201 protected:
01203     LogoutData(LogoutData *defaults = NULL) : 
01204         LoginData((LoginData*)defaults)
01205     {
01206         m_class_no = LOGOUT_NO;
01207     }
01209     virtual ~LogoutData();
01210 
01211 public:
01213     virtual LogoutData * copy() const;
01214 
01216     virtual bool instanceOf(int classNo) const;
01217 
01218 
01219     virtual void iterate(int& current_class, std::string& attr) const
01220         {if(current_class == LOGOUT_NO) current_class = -1; LoginData::iterate(current_class, attr);}
01221 
01222     //freelist related things
01223 public:
01224     static LogoutData *alloc();
01225     virtual void free();
01226 
01231     virtual LogoutData *getDefaultObject();
01232 
01237     static LogoutData *getDefaultObjectInstance();
01238 private:
01239     static LogoutData *defaults_LogoutData;
01240     static LogoutData *begin_LogoutData;
01241 };
01242 
01243 
01254 class ImaginaryData;
01255 typedef SmartPtr<ImaginaryData> Imaginary;
01256 
01257 static const int IMAGINARY_NO = 29;
01258 
01261 
01267 class ImaginaryData : public ActionData
01268 {
01269 protected:
01271     ImaginaryData(ImaginaryData *defaults = NULL) : 
01272         ActionData((ActionData*)defaults)
01273     {
01274         m_class_no = IMAGINARY_NO;
01275     }
01277     virtual ~ImaginaryData();
01278 
01279 public:
01281     virtual ImaginaryData * copy() const;
01282 
01284     virtual bool instanceOf(int classNo) const;
01285 
01286 
01287     virtual void iterate(int& current_class, std::string& attr) const
01288         {if(current_class == IMAGINARY_NO) current_class = -1; ActionData::iterate(current_class, attr);}
01289 
01290     //freelist related things
01291 public:
01292     static ImaginaryData *alloc();
01293     virtual void free();
01294 
01299     virtual ImaginaryData *getDefaultObject();
01300 
01305     static ImaginaryData *getDefaultObjectInstance();
01306 private:
01307     static ImaginaryData *defaults_ImaginaryData;
01308     static ImaginaryData *begin_ImaginaryData;
01309 };
01310 
01311 
01322 class UseData;
01323 typedef SmartPtr<UseData> Use;
01324 
01325 static const int USE_NO = 30;
01326 
01329 
01335 class UseData : public ActionData
01336 {
01337 protected:
01339     UseData(UseData *defaults = NULL) : 
01340         ActionData((ActionData*)defaults)
01341     {
01342         m_class_no = USE_NO;
01343     }
01345     virtual ~UseData();
01346 
01347 public:
01349     virtual UseData * copy() const;
01350 
01352     virtual bool instanceOf(int classNo) const;
01353 
01354 
01355     virtual void iterate(int& current_class, std::string& attr) const
01356         {if(current_class == USE_NO) current_class = -1; ActionData::iterate(current_class, attr);}
01357 
01358     //freelist related things
01359 public:
01360     static UseData *alloc();
01361     virtual void free();
01362 
01367     virtual UseData *getDefaultObject();
01368 
01373     static UseData *getDefaultObjectInstance();
01374 private:
01375     static UseData *defaults_UseData;
01376     static UseData *begin_UseData;
01377 };
01378 
01379 
01390 class InfoData;
01391 typedef SmartPtr<InfoData> Info;
01392 
01393 static const int INFO_NO = 31;
01394 
01397 
01403 class InfoData : public RootOperationData
01404 {
01405 protected:
01407     InfoData(InfoData *defaults = NULL) : 
01408         RootOperationData((RootOperationData*)defaults)
01409     {
01410         m_class_no = INFO_NO;
01411     }
01413     virtual ~InfoData();
01414 
01415 public:
01417     virtual InfoData * copy() const;
01418 
01420     virtual bool instanceOf(int classNo) const;
01421 
01422 
01423     virtual void iterate(int& current_class, std::string& attr) const
01424         {if(current_class == INFO_NO) current_class = -1; RootOperationData::iterate(current_class, attr);}
01425 
01426     //freelist related things
01427 public:
01428     static InfoData *alloc();
01429     virtual void free();
01430 
01435     virtual InfoData *getDefaultObject();
01436 
01441     static InfoData *getDefaultObjectInstance();
01442 private:
01443     static InfoData *defaults_InfoData;
01444     static InfoData *begin_InfoData;
01445 };
01446 
01447 
01454 class PerceptionData;
01455 typedef SmartPtr<PerceptionData> Perception;
01456 
01457 static const int PERCEPTION_NO = 32;
01458 
01461 
01463 class PerceptionData : public InfoData
01464 {
01465 protected:
01467     PerceptionData(PerceptionData *defaults = NULL) : 
01468         InfoData((InfoData*)defaults)
01469     {
01470         m_class_no = PERCEPTION_NO;
01471     }
01473     virtual ~PerceptionData();
01474 
01475 public:
01477     virtual PerceptionData * copy() const;
01478 
01480     virtual bool instanceOf(int classNo) const;
01481 
01482 
01483     virtual void iterate(int& current_class, std::string& attr) const
01484         {if(current_class == PERCEPTION_NO) current_class = -1; InfoData::iterate(current_class, attr);}
01485 
01486     //freelist related things
01487 public:
01488     static PerceptionData *alloc();
01489     virtual void free();
01490 
01495     virtual PerceptionData *getDefaultObject();
01496 
01501     static PerceptionData *getDefaultObjectInstance();
01502 private:
01503     static PerceptionData *defaults_PerceptionData;
01504     static PerceptionData *begin_PerceptionData;
01505 };
01506 
01507 
01514 class SightData;
01515 typedef SmartPtr<SightData> Sight;
01516 
01517 static const int SIGHT_NO = 33;
01518 
01521 
01523 class SightData : public PerceptionData
01524 {
01525 protected:
01527     SightData(SightData *defaults = NULL) : 
01528         PerceptionData((PerceptionData*)defaults)
01529     {
01530         m_class_no = SIGHT_NO;
01531     }
01533     virtual ~SightData();
01534 
01535 public:
01537     virtual SightData * copy() const;
01538 
01540     virtual bool instanceOf(int classNo) const;
01541 
01542 
01543     virtual void iterate(int& current_class, std::string& attr) const
01544         {if(current_class == SIGHT_NO) current_class = -1; PerceptionData::iterate(current_class, attr);}
01545 
01546     //freelist related things
01547 public:
01548     static SightData *alloc();
01549     virtual void free();
01550 
01555     virtual SightData *getDefaultObject();
01556 
01561     static SightData *getDefaultObjectInstance();
01562 private:
01563     static SightData *defaults_SightData;
01564     static SightData *begin_SightData;
01565 };
01566 
01567 
01574 class AppearanceData;
01575 typedef SmartPtr<AppearanceData> Appearance;
01576 
01577 static const int APPEARANCE_NO = 34;
01578 
01581 
01583 class AppearanceData : public SightData
01584 {
01585 protected:
01587     AppearanceData(AppearanceData *defaults = NULL) : 
01588         SightData((SightData*)defaults)
01589     {
01590         m_class_no = APPEARANCE_NO;
01591     }
01593     virtual ~AppearanceData();
01594 
01595 public:
01597     virtual AppearanceData * copy() const;
01598 
01600     virtual bool instanceOf(int classNo) const;
01601 
01602 
01603     virtual void iterate(int& current_class, std::string& attr) const
01604         {if(current_class == APPEARANCE_NO) current_class = -1; SightData::iterate(current_class, attr);}
01605 
01606     //freelist related things
01607 public:
01608     static AppearanceData *alloc();
01609     virtual void free();
01610 
01615     virtual AppearanceData *getDefaultObject();
01616 
01621     static AppearanceData *getDefaultObjectInstance();
01622 private:
01623     static AppearanceData *defaults_AppearanceData;
01624     static AppearanceData *begin_AppearanceData;
01625 };
01626 
01627 
01634 class DisappearanceData;
01635 typedef SmartPtr<DisappearanceData> Disappearance;
01636 
01637 static const int DISAPPEARANCE_NO = 35;
01638 
01641 
01643 class DisappearanceData : public SightData
01644 {
01645 protected:
01647     DisappearanceData(DisappearanceData *defaults = NULL) : 
01648         SightData((SightData*)defaults)
01649     {
01650         m_class_no = DISAPPEARANCE_NO;
01651     }
01653     virtual ~DisappearanceData();
01654 
01655 public:
01657     virtual DisappearanceData * copy() const;
01658 
01660     virtual bool instanceOf(int classNo) const;
01661 
01662 
01663     virtual void iterate(int& current_class, std::string& attr) const
01664         {if(current_class == DISAPPEARANCE_NO) current_class = -1; SightData::iterate(current_class, attr);}
01665 
01666     //freelist related things
01667 public:
01668     static DisappearanceData *alloc();
01669     virtual void free();
01670 
01675     virtual DisappearanceData *getDefaultObject();
01676 
01681     static DisappearanceData *getDefaultObjectInstance();
01682 private:
01683     static DisappearanceData *defaults_DisappearanceData;
01684     static DisappearanceData *begin_DisappearanceData;
01685 };
01686 
01687 
01694 class SoundData;
01695 typedef SmartPtr<SoundData> Sound;
01696 
01697 static const int SOUND_NO = 36;
01698 
01701 
01703 class SoundData : public PerceptionData
01704 {
01705 protected:
01707     SoundData(SoundData *defaults = NULL) : 
01708         PerceptionData((PerceptionData*)defaults)
01709     {
01710         m_class_no = SOUND_NO;
01711     }
01713     virtual ~SoundData();
01714 
01715 public:
01717     virtual SoundData * copy() const;
01718 
01720     virtual bool instanceOf(int classNo) const;
01721 
01722 
01723     virtual void iterate(int& current_class, std::string& attr) const
01724         {if(current_class == SOUND_NO) current_class = -1; PerceptionData::iterate(current_class, attr);}
01725 
01726     //freelist related things
01727 public:
01728     static SoundData *alloc();
01729     virtual void free();
01730 
01735     virtual SoundData *getDefaultObject();
01736 
01741     static SoundData *getDefaultObjectInstance();
01742 private:
01743     static SoundData *defaults_SoundData;
01744     static SoundData *begin_SoundData;
01745 };
01746 
01747 
01754 class SmellData;
01755 typedef SmartPtr<SmellData> Smell;
01756 
01757 static const int SMELL_NO = 37;
01758 
01761 
01763 class SmellData : public PerceptionData
01764 {
01765 protected:
01767     SmellData(SmellData *defaults = NULL) : 
01768         PerceptionData((PerceptionData*)defaults)
01769     {
01770         m_class_no = SMELL_NO;
01771     }
01773     virtual ~SmellData();
01774 
01775 public:
01777     virtual SmellData * copy() const;
01778 
01780     virtual bool instanceOf(int classNo) const;
01781 
01782 
01783     virtual void iterate(int& current_class, std::string& attr) const
01784         {if(current_class == SMELL_NO) current_class = -1; PerceptionData::iterate(current_class, attr);}
01785 
01786     //freelist related things
01787 public:
01788     static SmellData *alloc();
01789     virtual void free();
01790 
01795     virtual SmellData *getDefaultObject();
01796 
01801     static SmellData *getDefaultObjectInstance();
01802 private:
01803     static SmellData *defaults_SmellData;
01804     static SmellData *begin_SmellData;
01805 };
01806 
01807 
01814 class FeelData;
01815 typedef SmartPtr<FeelData> Feel;
01816 
01817 static const int FEEL_NO = 38;
01818 
01821 
01823 class FeelData : public PerceptionData
01824 {
01825 protected:
01827     FeelData(FeelData *defaults = NULL) : 
01828         PerceptionData((PerceptionData*)defaults)
01829     {
01830         m_class_no = FEEL_NO;
01831     }
01833     virtual ~FeelData();
01834 
01835 public:
01837     virtual FeelData * copy() const;
01838 
01840     virtual bool instanceOf(int classNo) const;
01841 
01842 
01843     virtual void iterate(int& current_class, std::string& attr) const
01844         {if(current_class == FEEL_NO) current_class = -1; PerceptionData::iterate(current_class, attr);}
01845 
01846     //freelist related things
01847 public:
01848     static FeelData *alloc();
01849     virtual void free();
01850 
01855     virtual FeelData *getDefaultObject();
01856 
01861     static FeelData *getDefaultObjectInstance();
01862 private:
01863     static FeelData *defaults_FeelData;
01864     static FeelData *begin_FeelData;
01865 };
01866 
01867 
01878 class ErrorData;
01879 typedef SmartPtr<ErrorData> Error;
01880 
01881 static const int ERROR_NO = 39;
01882 
01885 
01891 class ErrorData : public InfoData
01892 {
01893 protected:
01895     ErrorData(ErrorData *defaults = NULL) : 
01896         InfoData((InfoData*)defaults)
01897     {
01898         m_class_no = ERROR_NO;
01899     }
01901     virtual ~ErrorData();
01902 
01903 public:
01905     virtual ErrorData * copy() const;
01906 
01908     virtual bool instanceOf(int classNo) const;
01909 
01910 
01911     virtual void iterate(int& current_class, std::string& attr) const
01912         {if(current_class == ERROR_NO) current_class = -1; InfoData::iterate(current_class, attr);}
01913 
01914     //freelist related things
01915 public:
01916     static ErrorData *alloc();
01917     virtual void free();
01918 
01923     virtual ErrorData *getDefaultObject();
01924 
01929     static ErrorData *getDefaultObjectInstance();
01930 private:
01931     static ErrorData *defaults_ErrorData;
01932     static ErrorData *begin_ErrorData;
01933 };
01934 
01935 } } } // namespace Atlas::Objects::Operation
01936 
01937 #endif // ATLAS_OBJECTS_OPERATION_OPERATION_H

Copyright 2000-2004 the respective authors.

This document can be licensed under the terms of the GNU Free Documentation License or the GNU General Public License and may be freely distributed under the terms given by one of these licenses.