Operation.h

// This file may be redistributed and modified only under the terms of
// the GNU Lesser General Public License (See COPYING for details).
// Copyright 2000-2001 Stefanus Du Toit and Aloril.
// Copyright 2001-2005 Alistair Riddoch.
// Automatically generated using gen_cpp.py.
 
#ifndef ATLAS_OBJECTS_OPERATION_OPERATION_H
#define ATLAS_OBJECTS_OPERATION_OPERATION_H
 
#include <Atlas/Objects/RootOperation.h>
#include <Atlas/Objects/Generic.h>
 
 
namespace Atlas { namespace Objects { namespace Operation { 
 
class ActionData;
typedef SmartPtr<ActionData> Action;
 
static const int ACTION_NO = 10;
 
 
class ActionData : public RootOperationData
{
protected:
    ActionData(ActionData *defaults = NULL) : 
        RootOperationData((RootOperationData*)defaults)
    {
        m_class_no = ACTION_NO;
    }
    virtual ~ActionData();
 
public:
    virtual ActionData * copy() const;
 
    virtual bool instanceOf(int classNo) const;
 
 
    virtual void iterate(int& current_class, std::string& attr) const
        {if(current_class == ACTION_NO) current_class = -1; RootOperationData::iterate(current_class, attr);}
 
    //freelist related things
public:
    static ActionData *alloc();
    virtual void free();
 
    virtual ActionData *getDefaultObject();
 
    static ActionData *getDefaultObjectInstance();
private:
    static ActionData *defaults_ActionData;
    static ActionData *begin_ActionData;
};
 
 
class CreateData;
typedef SmartPtr<CreateData> Create;
 
static const int CREATE_NO = 11;
 
 
class CreateData : public ActionData
{
protected:
    CreateData(CreateData *defaults = NULL) : 
        ActionData((ActionData*)defaults)
    {
        m_class_no = CREATE_NO;
    }
    virtual ~CreateData();
 
public:
    virtual CreateData * copy() const;
 
    virtual bool instanceOf(int classNo) const;
 
 
    virtual void iterate(int& current_class, std::string& attr) const
        {if(current_class == CREATE_NO) current_class = -1; ActionData::iterate(current_class, attr);}
 
    //freelist related things
public:
    static CreateData *alloc();
    virtual void free();
 
    virtual CreateData *getDefaultObject();
 
    static CreateData *getDefaultObjectInstance();
private:
    static CreateData *defaults_CreateData;
    static CreateData *begin_CreateData;
};
 
 
class CombineData;
typedef SmartPtr<CombineData> Combine;
 
static const int COMBINE_NO = 12;
 
 
class CombineData : public CreateData
{
protected:
    CombineData(CombineData *defaults = NULL) : 
        CreateData((CreateData*)defaults)
    {
        m_class_no = COMBINE_NO;
    }
    virtual ~CombineData();
 
public:
    virtual CombineData * copy() const;
 
    virtual bool instanceOf(int classNo) const;
 
 
    virtual void iterate(int& current_class, std::string& attr) const
        {if(current_class == COMBINE_NO) current_class = -1; CreateData::iterate(current_class, attr);}
 
    //freelist related things
public:
    static CombineData *alloc();
    virtual void free();
 
    virtual CombineData *getDefaultObject();
 
    static CombineData *getDefaultObjectInstance();
private:
    static CombineData *defaults_CombineData;
    static CombineData *begin_CombineData;
};
 
 
class DivideData;
typedef SmartPtr<DivideData> Divide;
 
static const int DIVIDE_NO = 13;
 
 
class DivideData : public CreateData
{
protected:
    DivideData(DivideData *defaults = NULL) : 
        CreateData((CreateData*)defaults)
    {
        m_class_no = DIVIDE_NO;
    }
    virtual ~DivideData();
 
public:
    virtual DivideData * copy() const;
 
    virtual bool instanceOf(int classNo) const;
 
 
    virtual void iterate(int& current_class, std::string& attr) const
        {if(current_class == DIVIDE_NO) current_class = -1; CreateData::iterate(current_class, attr);}
 
    //freelist related things
public:
    static DivideData *alloc();
    virtual void free();
 
    virtual DivideData *getDefaultObject();
 
    static DivideData *getDefaultObjectInstance();
private:
    static DivideData *defaults_DivideData;
    static DivideData *begin_DivideData;
};
 
 
class CommunicateData;
typedef SmartPtr<CommunicateData> Communicate;
 
static const int COMMUNICATE_NO = 14;
 
 
class CommunicateData : public CreateData
{
protected:
    CommunicateData(CommunicateData *defaults = NULL) : 
        CreateData((CreateData*)defaults)
    {
        m_class_no = COMMUNICATE_NO;
    }
    virtual ~CommunicateData();
 
public:
    virtual CommunicateData * copy() const;
 
    virtual bool instanceOf(int classNo) const;
 
 
    virtual void iterate(int& current_class, std::string& attr) const
        {if(current_class == COMMUNICATE_NO) current_class = -1; CreateData::iterate(current_class, attr);}
 
    //freelist related things
public:
    static CommunicateData *alloc();
    virtual void free();
 
    virtual CommunicateData *getDefaultObject();
 
    static CommunicateData *getDefaultObjectInstance();
private:
    static CommunicateData *defaults_CommunicateData;
    static CommunicateData *begin_CommunicateData;
};
 
 
class TalkData;
typedef SmartPtr<TalkData> Talk;
 
static const int TALK_NO = 15;
 
 
class TalkData : public CommunicateData
{
protected:
    TalkData(TalkData *defaults = NULL) : 
        CommunicateData((CommunicateData*)defaults)
    {
        m_class_no = TALK_NO;
    }
    virtual ~TalkData();
 
public:
    virtual TalkData * copy() const;
 
    virtual bool instanceOf(int classNo) const;
 
 
    virtual void iterate(int& current_class, std::string& attr) const
        {if(current_class == TALK_NO) current_class = -1; CommunicateData::iterate(current_class, attr);}
 
    //freelist related things
public:
    static TalkData *alloc();
    virtual void free();
 
    virtual TalkData *getDefaultObject();
 
    static TalkData *getDefaultObjectInstance();
private:
    static TalkData *defaults_TalkData;
    static TalkData *begin_TalkData;
};
 
 
class DeleteData;
typedef SmartPtr<DeleteData> Delete;
 
static const int DELETE_NO = 16;
 
 
class DeleteData : public ActionData
{
protected:
    DeleteData(DeleteData *defaults = NULL) : 
        ActionData((ActionData*)defaults)
    {
        m_class_no = DELETE_NO;
    }
    virtual ~DeleteData();
 
public:
    virtual DeleteData * copy() const;
 
    virtual bool instanceOf(int classNo) const;
 
 
    virtual void iterate(int& current_class, std::string& attr) const
        {if(current_class == DELETE_NO) current_class = -1; ActionData::iterate(current_class, attr);}
 
    //freelist related things
public:
    static DeleteData *alloc();
    virtual void free();
 
    virtual DeleteData *getDefaultObject();
 
    static DeleteData *getDefaultObjectInstance();
private:
    static DeleteData *defaults_DeleteData;
    static DeleteData *begin_DeleteData;
};
 
 
class SetData;
typedef SmartPtr<SetData> Set;
 
static const int SET_NO = 17;
 
 
class SetData : public ActionData
{
protected:
    SetData(SetData *defaults = NULL) : 
        ActionData((ActionData*)defaults)
    {
        m_class_no = SET_NO;
    }
    virtual ~SetData();
 
public:
    virtual SetData * copy() const;
 
    virtual bool instanceOf(int classNo) const;
 
 
    virtual void iterate(int& current_class, std::string& attr) const
        {if(current_class == SET_NO) current_class = -1; ActionData::iterate(current_class, attr);}
 
    //freelist related things
public:
    static SetData *alloc();
    virtual void free();
 
    virtual SetData *getDefaultObject();
 
    static SetData *getDefaultObjectInstance();
private:
    static SetData *defaults_SetData;
    static SetData *begin_SetData;
};
 
 
class AffectData;
typedef SmartPtr<AffectData> Affect;
 
static const int AFFECT_NO = 18;
 
 
class AffectData : public SetData
{
protected:
    AffectData(AffectData *defaults = NULL) : 
        SetData((SetData*)defaults)
    {
        m_class_no = AFFECT_NO;
    }
    virtual ~AffectData();
 
public:
    virtual AffectData * copy() const;
 
    virtual bool instanceOf(int classNo) const;
 
 
    virtual void iterate(int& current_class, std::string& attr) const
        {if(current_class == AFFECT_NO) current_class = -1; SetData::iterate(current_class, attr);}
 
    //freelist related things
public:
    static AffectData *alloc();
    virtual void free();
 
    virtual AffectData *getDefaultObject();
 
    static AffectData *getDefaultObjectInstance();
private:
    static AffectData *defaults_AffectData;
    static AffectData *begin_AffectData;
};
 
 
class MoveData;
typedef SmartPtr<MoveData> Move;
 
static const int MOVE_NO = 19;
 
 
class MoveData : public SetData
{
protected:
    MoveData(MoveData *defaults = NULL) : 
        SetData((SetData*)defaults)
    {
        m_class_no = MOVE_NO;
    }
    virtual ~MoveData();
 
public:
    virtual MoveData * copy() const;
 
    virtual bool instanceOf(int classNo) const;
 
 
    virtual void iterate(int& current_class, std::string& attr) const
        {if(current_class == MOVE_NO) current_class = -1; SetData::iterate(current_class, attr);}
 
    //freelist related things
public:
    static MoveData *alloc();
    virtual void free();
 
    virtual MoveData *getDefaultObject();
 
    static MoveData *getDefaultObjectInstance();
private:
    static MoveData *defaults_MoveData;
    static MoveData *begin_MoveData;
};
 
 
class WieldData;
typedef SmartPtr<WieldData> Wield;
 
static const int WIELD_NO = 20;
 
 
class WieldData : public SetData
{
protected:
    WieldData(WieldData *defaults = NULL) : 
        SetData((SetData*)defaults)
    {
        m_class_no = WIELD_NO;
    }
    virtual ~WieldData();
 
public:
    virtual WieldData * copy() const;
 
    virtual bool instanceOf(int classNo) const;
 
 
    virtual void iterate(int& current_class, std::string& attr) const
        {if(current_class == WIELD_NO) current_class = -1; SetData::iterate(current_class, attr);}
 
    //freelist related things
public:
    static WieldData *alloc();
    virtual void free();
 
    virtual WieldData *getDefaultObject();
 
    static WieldData *getDefaultObjectInstance();
private:
    static WieldData *defaults_WieldData;
    static WieldData *begin_WieldData;
};
 
 
class GetData;
typedef SmartPtr<GetData> Get;
 
static const int GET_NO = 21;
 
 
class GetData : public ActionData
{
protected:
    GetData(GetData *defaults = NULL) : 
        ActionData((ActionData*)defaults)
    {
        m_class_no = GET_NO;
    }
    virtual ~GetData();
 
public:
    virtual GetData * copy() const;
 
    virtual bool instanceOf(int classNo) const;
 
 
    virtual void iterate(int& current_class, std::string& attr) const
        {if(current_class == GET_NO) current_class = -1; ActionData::iterate(current_class, attr);}
 
    //freelist related things
public:
    static GetData *alloc();
    virtual void free();
 
    virtual GetData *getDefaultObject();
 
    static GetData *getDefaultObjectInstance();
private:
    static GetData *defaults_GetData;
    static GetData *begin_GetData;
};
 
 
class PerceiveData;
typedef SmartPtr<PerceiveData> Perceive;
 
static const int PERCEIVE_NO = 22;
 
 
class PerceiveData : public GetData
{
protected:
    PerceiveData(PerceiveData *defaults = NULL) : 
        GetData((GetData*)defaults)
    {
        m_class_no = PERCEIVE_NO;
    }
    virtual ~PerceiveData();
 
public:
    virtual PerceiveData * copy() const;
 
    virtual bool instanceOf(int classNo) const;
 
 
    virtual void iterate(int& current_class, std::string& attr) const
        {if(current_class == PERCEIVE_NO) current_class = -1; GetData::iterate(current_class, attr);}
 
    //freelist related things
public:
    static PerceiveData *alloc();
    virtual void free();
 
    virtual PerceiveData *getDefaultObject();
 
    static PerceiveData *getDefaultObjectInstance();
private:
    static PerceiveData *defaults_PerceiveData;
    static PerceiveData *begin_PerceiveData;
};
 
 
class LookData;
typedef SmartPtr<LookData> Look;
 
static const int LOOK_NO = 23;
 
 
class LookData : public PerceiveData
{
protected:
    LookData(LookData *defaults = NULL) : 
        PerceiveData((PerceiveData*)defaults)
    {
        m_class_no = LOOK_NO;
    }
    virtual ~LookData();
 
public:
    virtual LookData * copy() const;
 
    virtual bool instanceOf(int classNo) const;
 
 
    virtual void iterate(int& current_class, std::string& attr) const
        {if(current_class == LOOK_NO) current_class = -1; PerceiveData::iterate(current_class, attr);}
 
    //freelist related things
public:
    static LookData *alloc();
    virtual void free();
 
    virtual LookData *getDefaultObject();
 
    static LookData *getDefaultObjectInstance();
private:
    static LookData *defaults_LookData;
    static LookData *begin_LookData;
};
 
 
class ListenData;
typedef SmartPtr<ListenData> Listen;
 
static const int LISTEN_NO = 24;
 
 
class ListenData : public PerceiveData
{
protected:
    ListenData(ListenData *defaults = NULL) : 
        PerceiveData((PerceiveData*)defaults)
    {
        m_class_no = LISTEN_NO;
    }
    virtual ~ListenData();
 
public:
    virtual ListenData * copy() const;
 
    virtual bool instanceOf(int classNo) const;
 
 
    virtual void iterate(int& current_class, std::string& attr) const
        {if(current_class == LISTEN_NO) current_class = -1; PerceiveData::iterate(current_class, attr);}
 
    //freelist related things
public:
    static ListenData *alloc();
    virtual void free();
 
    virtual ListenData *getDefaultObject();
 
    static ListenData *getDefaultObjectInstance();
private:
    static ListenData *defaults_ListenData;
    static ListenData *begin_ListenData;
};
 
 
class SniffData;
typedef SmartPtr<SniffData> Sniff;
 
static const int SNIFF_NO = 25;
 
 
class SniffData : public PerceiveData
{
protected:
    SniffData(SniffData *defaults = NULL) : 
        PerceiveData((PerceiveData*)defaults)
    {
        m_class_no = SNIFF_NO;
    }
    virtual ~SniffData();
 
public:
    virtual SniffData * copy() const;
 
    virtual bool instanceOf(int classNo) const;
 
 
    virtual void iterate(int& current_class, std::string& attr) const
        {if(current_class == SNIFF_NO) current_class = -1; PerceiveData::iterate(current_class, attr);}
 
    //freelist related things
public:
    static SniffData *alloc();
    virtual void free();
 
    virtual SniffData *getDefaultObject();
 
    static SniffData *getDefaultObjectInstance();
private:
    static SniffData *defaults_SniffData;
    static SniffData *begin_SniffData;
};
 
 
class TouchData;
typedef SmartPtr<TouchData> Touch;
 
static const int TOUCH_NO = 26;
 
 
class TouchData : public PerceiveData
{
protected:
    TouchData(TouchData *defaults = NULL) : 
        PerceiveData((PerceiveData*)defaults)
    {
        m_class_no = TOUCH_NO;
    }
    virtual ~TouchData();
 
public:
    virtual TouchData * copy() const;
 
    virtual bool instanceOf(int classNo) const;
 
 
    virtual void iterate(int& current_class, std::string& attr) const
        {if(current_class == TOUCH_NO) current_class = -1; PerceiveData::iterate(current_class, attr);}
 
    //freelist related things
public:
    static TouchData *alloc();
    virtual void free();
 
    virtual TouchData *getDefaultObject();
 
    static TouchData *getDefaultObjectInstance();
private:
    static TouchData *defaults_TouchData;
    static TouchData *begin_TouchData;
};
 
 
class LoginData;
typedef SmartPtr<LoginData> Login;
 
static const int LOGIN_NO = 27;
 
 
class LoginData : public GetData
{
protected:
    LoginData(LoginData *defaults = NULL) : 
        GetData((GetData*)defaults)
    {
        m_class_no = LOGIN_NO;
    }
    virtual ~LoginData();
 
public:
    virtual LoginData * copy() const;
 
    virtual bool instanceOf(int classNo) const;
 
 
    virtual void iterate(int& current_class, std::string& attr) const
        {if(current_class == LOGIN_NO) current_class = -1; GetData::iterate(current_class, attr);}
 
    //freelist related things
public:
    static LoginData *alloc();
    virtual void free();
 
    virtual LoginData *getDefaultObject();
 
    static LoginData *getDefaultObjectInstance();
private:
    static LoginData *defaults_LoginData;
    static LoginData *begin_LoginData;
};
 
 
class LogoutData;
typedef SmartPtr<LogoutData> Logout;
 
static const int LOGOUT_NO = 28;
 
 
class LogoutData : public LoginData
{
protected:
    LogoutData(LogoutData *defaults = NULL) : 
        LoginData((LoginData*)defaults)
    {
        m_class_no = LOGOUT_NO;
    }
    virtual ~LogoutData();
 
public:
    virtual LogoutData * copy() const;
 
    virtual bool instanceOf(int classNo) const;
 
 
    virtual void iterate(int& current_class, std::string& attr) const
        {if(current_class == LOGOUT_NO) current_class = -1; LoginData::iterate(current_class, attr);}
 
    //freelist related things
public:
    static LogoutData *alloc();
    virtual void free();
 
    virtual LogoutData *getDefaultObject();
 
    static LogoutData *getDefaultObjectInstance();
private:
    static LogoutData *defaults_LogoutData;
    static LogoutData *begin_LogoutData;
};
 
 
class ImaginaryData;
typedef SmartPtr<ImaginaryData> Imaginary;
 
static const int IMAGINARY_NO = 29;
 
 
class ImaginaryData : public ActionData
{
protected:
    ImaginaryData(ImaginaryData *defaults = NULL) : 
        ActionData((ActionData*)defaults)
    {
        m_class_no = IMAGINARY_NO;
    }
    virtual ~ImaginaryData();
 
public:
    virtual ImaginaryData * copy() const;
 
    virtual bool instanceOf(int classNo) const;
 
 
    virtual void iterate(int& current_class, std::string& attr) const
        {if(current_class == IMAGINARY_NO) current_class = -1; ActionData::iterate(current_class, attr);}
 
    //freelist related things
public:
    static ImaginaryData *alloc();
    virtual void free();
 
    virtual ImaginaryData *getDefaultObject();
 
    static ImaginaryData *getDefaultObjectInstance();
private:
    static ImaginaryData *defaults_ImaginaryData;
    static ImaginaryData *begin_ImaginaryData;
};
 
 
class UseData;
typedef SmartPtr<UseData> Use;
 
static const int USE_NO = 30;
 
 
class UseData : public ActionData
{
protected:
    UseData(UseData *defaults = NULL) : 
        ActionData((ActionData*)defaults)
    {
        m_class_no = USE_NO;
    }
    virtual ~UseData();
 
public:
    virtual UseData * copy() const;
 
    virtual bool instanceOf(int classNo) const;
 
 
    virtual void iterate(int& current_class, std::string& attr) const
        {if(current_class == USE_NO) current_class = -1; ActionData::iterate(current_class, attr);}
 
    //freelist related things
public:
    static UseData *alloc();
    virtual void free();
 
    virtual UseData *getDefaultObject();
 
    static UseData *getDefaultObjectInstance();
private:
    static UseData *defaults_UseData;
    static UseData *begin_UseData;
};
 
 
class InfoData;
typedef SmartPtr<InfoData> Info;
 
static const int INFO_NO = 31;
 
 
class InfoData : public RootOperationData
{
protected:
    InfoData(InfoData *defaults = NULL) : 
        RootOperationData((RootOperationData*)defaults)
    {
        m_class_no = INFO_NO;
    }
    virtual ~InfoData();
 
public:
    virtual InfoData * copy() const;
 
    virtual bool instanceOf(int classNo) const;
 
 
    virtual void iterate(int& current_class, std::string& attr) const
        {if(current_class == INFO_NO) current_class = -1; RootOperationData::iterate(current_class, attr);}
 
    //freelist related things
public:
    static InfoData *alloc();
    virtual void free();
 
    virtual InfoData *getDefaultObject();
 
    static InfoData *getDefaultObjectInstance();
private:
    static InfoData *defaults_InfoData;
    static InfoData *begin_InfoData;
};
 
 
class PerceptionData;
typedef SmartPtr<PerceptionData> Perception;
 
static const int PERCEPTION_NO = 32;
 
 
class PerceptionData : public InfoData
{
protected:
    PerceptionData(PerceptionData *defaults = NULL) : 
        InfoData((InfoData*)defaults)
    {
        m_class_no = PERCEPTION_NO;
    }
    virtual ~PerceptionData();
 
public:
    virtual PerceptionData * copy() const;
 
    virtual bool instanceOf(int classNo) const;
 
 
    virtual void iterate(int& current_class, std::string& attr) const
        {if(current_class == PERCEPTION_NO) current_class = -1; InfoData::iterate(current_class, attr);}
 
    //freelist related things
public:
    static PerceptionData *alloc();
    virtual void free();
 
    virtual PerceptionData *getDefaultObject();
 
    static PerceptionData *getDefaultObjectInstance();
private:
    static PerceptionData *defaults_PerceptionData;
    static PerceptionData *begin_PerceptionData;
};
 
 
class SightData;
typedef SmartPtr<SightData> Sight;
 
static const int SIGHT_NO = 33;
 
 
class SightData : public PerceptionData
{
protected:
    SightData(SightData *defaults = NULL) : 
        PerceptionData((PerceptionData*)defaults)
    {
        m_class_no = SIGHT_NO;
    }
    virtual ~SightData();
 
public:
    virtual SightData * copy() const;
 
    virtual bool instanceOf(int classNo) const;
 
 
    virtual void iterate(int& current_class, std::string& attr) const
        {if(current_class == SIGHT_NO) current_class = -1; PerceptionData::iterate(current_class, attr);}
 
    //freelist related things
public:
    static SightData *alloc();
    virtual void free();
 
    virtual SightData *getDefaultObject();
 
    static SightData *getDefaultObjectInstance();
private:
    static SightData *defaults_SightData;
    static SightData *begin_SightData;
};
 
 
class AppearanceData;
typedef SmartPtr<AppearanceData> Appearance;
 
static const int APPEARANCE_NO = 34;
 
 
class AppearanceData : public SightData
{
protected:
    AppearanceData(AppearanceData *defaults = NULL) : 
        SightData((SightData*)defaults)
    {
        m_class_no = APPEARANCE_NO;
    }
    virtual ~AppearanceData();
 
public:
    virtual AppearanceData * copy() const;
 
    virtual bool instanceOf(int classNo) const;
 
 
    virtual void iterate(int& current_class, std::string& attr) const
        {if(current_class == APPEARANCE_NO) current_class = -1; SightData::iterate(current_class, attr);}
 
    //freelist related things
public:
    static AppearanceData *alloc();
    virtual void free();
 
    virtual AppearanceData *getDefaultObject();
 
    static AppearanceData *getDefaultObjectInstance();
private:
    static AppearanceData *defaults_AppearanceData;
    static AppearanceData *begin_AppearanceData;
};
 
 
class DisappearanceData;
typedef SmartPtr<DisappearanceData> Disappearance;
 
static const int DISAPPEARANCE_NO = 35;
 
 
class DisappearanceData : public SightData
{
protected:
    DisappearanceData(DisappearanceData *defaults = NULL) : 
        SightData((SightData*)defaults)
    {
        m_class_no = DISAPPEARANCE_NO;
    }
    virtual ~DisappearanceData();
 
public:
    virtual DisappearanceData * copy() const;
 
    virtual bool instanceOf(int classNo) const;
 
 
    virtual void iterate(int& current_class, std::string& attr) const
        {if(current_class == DISAPPEARANCE_NO) current_class = -1; SightData::iterate(current_class, attr);}
 
    //freelist related things
public:
    static DisappearanceData *alloc();
    virtual void free();
 
    virtual DisappearanceData *getDefaultObject();
 
    static DisappearanceData *getDefaultObjectInstance();
private:
    static DisappearanceData *defaults_DisappearanceData;
    static DisappearanceData *begin_DisappearanceData;
};
 
 
class SoundData;
typedef SmartPtr<SoundData> Sound;
 
static const int SOUND_NO = 36;
 
 
class SoundData : public PerceptionData
{
protected:
    SoundData(SoundData *defaults = NULL) : 
        PerceptionData((PerceptionData*)defaults)
    {
        m_class_no = SOUND_NO;
    }
    virtual ~SoundData();
 
public:
    virtual SoundData * copy() const;
 
    virtual bool instanceOf(int classNo) const;
 
 
    virtual void iterate(int& current_class, std::string& attr) const
        {if(current_class == SOUND_NO) current_class = -1; PerceptionData::iterate(current_class, attr);}
 
    //freelist related things
public:
    static SoundData *alloc();
    virtual void free();
 
    virtual SoundData *getDefaultObject();
 
    static SoundData *getDefaultObjectInstance();
private:
    static SoundData *defaults_SoundData;
    static SoundData *begin_SoundData;
};
 
 
class SmellData;
typedef SmartPtr<SmellData> Smell;
 
static const int SMELL_NO = 37;
 
 
class SmellData : public PerceptionData
{
protected:
    SmellData(SmellData *defaults = NULL) : 
        PerceptionData((PerceptionData*)defaults)
    {
        m_class_no = SMELL_NO;
    }
    virtual ~SmellData();
 
public:
    virtual SmellData * copy() const;
 
    virtual bool instanceOf(int classNo) const;
 
 
    virtual void iterate(int& current_class, std::string& attr) const
        {if(current_class == SMELL_NO) current_class = -1; PerceptionData::iterate(current_class, attr);}
 
    //freelist related things
public:
    static SmellData *alloc();
    virtual void free();
 
    virtual SmellData *getDefaultObject();
 
    static SmellData *getDefaultObjectInstance();
private:
    static SmellData *defaults_SmellData;
    static SmellData *begin_SmellData;
};
 
 
class FeelData;
typedef SmartPtr<FeelData> Feel;
 
static const int FEEL_NO = 38;
 
 
class FeelData : public PerceptionData
{
protected:
    FeelData(FeelData *defaults = NULL) : 
        PerceptionData((PerceptionData*)defaults)
    {
        m_class_no = FEEL_NO;
    }
    virtual ~FeelData();
 
public:
    virtual FeelData * copy() const;
 
    virtual bool instanceOf(int classNo) const;
 
 
    virtual void iterate(int& current_class, std::string& attr) const
        {if(current_class == FEEL_NO) current_class = -1; PerceptionData::iterate(current_class, attr);}
 
    //freelist related things
public:
    static FeelData *alloc();
    virtual void free();
 
    virtual FeelData *getDefaultObject();
 
    static FeelData *getDefaultObjectInstance();
private:
    static FeelData *defaults_FeelData;
    static FeelData *begin_FeelData;
};
 
 
class ErrorData;
typedef SmartPtr<ErrorData> Error;
 
static const int ERROR_NO = 39;
 
 
class ErrorData : public InfoData
{
protected:
    ErrorData(ErrorData *defaults = NULL) : 
        InfoData((InfoData*)defaults)
    {
        m_class_no = ERROR_NO;
    }
    virtual ~ErrorData();
 
public:
    virtual ErrorData * copy() const;
 
    virtual bool instanceOf(int classNo) const;
 
 
    virtual void iterate(int& current_class, std::string& attr) const
        {if(current_class == ERROR_NO) current_class = -1; InfoData::iterate(current_class, attr);}
 
    //freelist related things
public:
    static ErrorData *alloc();
    virtual void free();
 
    virtual ErrorData *getDefaultObject();
 
    static ErrorData *getDefaultObjectInstance();
private:
    static ErrorData *defaults_ErrorData;
    static ErrorData *begin_ErrorData;
};
 
} } } // namespace Atlas::Objects::Operation
 
#endif // ATLAS_OBJECTS_OPERATION_OPERATION_H