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