Entity.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_ENTITY_ENTITY_H
#define ATLAS_OBJECTS_ENTITY_ENTITY_H

#include <Atlas/Objects/RootEntity.h>
#include <Atlas/Objects/Anonymous.h>


namespace Atlas { namespace Objects { namespace Entity { 

class AdminEntityData;
typedef SmartPtr<AdminEntityData> AdminEntity;

static const int ADMIN_ENTITY_NO = 3;


class AdminEntityData : public RootEntityData
{
protected:
    AdminEntityData(AdminEntityData *defaults = NULL) : 
        RootEntityData((RootEntityData*)defaults)
    {
        m_class_no = ADMIN_ENTITY_NO;
    }
    virtual ~AdminEntityData();

public:
    virtual AdminEntityData * copy() const;

    virtual bool instanceOf(int classNo) const;


    virtual void iterate(int& current_class, std::string& attr) const
        {if(current_class == ADMIN_ENTITY_NO) current_class = -1; RootEntityData::iterate(current_class, attr);}

    //freelist related things
public:
    static AdminEntityData *alloc();
    virtual void free();

    virtual AdminEntityData *getDefaultObject();

    static AdminEntityData *getDefaultObjectInstance();
private:
    static AdminEntityData *defaults_AdminEntityData;
    static AdminEntityData *begin_AdminEntityData;
};


class AccountData;
typedef SmartPtr<AccountData> Account;

static const int ACCOUNT_NO = 4;


class AccountData : public AdminEntityData
{
protected:
    AccountData(AccountData *defaults = NULL) : 
        AdminEntityData((AdminEntityData*)defaults)
    {
        m_class_no = ACCOUNT_NO;
    }
    virtual ~AccountData();

public:
    virtual AccountData * copy() const;

    virtual bool instanceOf(int classNo) const;

    virtual int copyAttr(const std::string& name, Atlas::Message::Element & attr) const;
    virtual void setAttr(const std::string& name,
                         const Atlas::Message::Element& attr);
    virtual void removeAttr(const std::string& name);

    virtual void sendContents(Atlas::Bridge & b) const;

    virtual void addToMessage(Atlas::Message::MapType &) const;

    inline void setUsername(const std::string& val);
    inline void setPassword(const std::string& val);
    inline void setCharacters(const std::list<std::string>& val);
    inline void setCharactersAsList(const Atlas::Message::ListType& val);

    inline const std::string& getUsername() const;
    inline std::string& modifyUsername();
    inline const std::string& getPassword() const;
    inline std::string& modifyPassword();
    inline const std::list<std::string>& getCharacters() const;
    inline std::list<std::string>& modifyCharacters();
    inline const Atlas::Message::ListType getCharactersAsList() const;

    inline bool isDefaultUsername() const;
    inline bool isDefaultPassword() const;
    inline bool isDefaultCharacters() const;

protected:
    virtual int getAttrClass(const std::string& name)const;
    virtual int getAttrFlag(const std::string& name)const;
    std::string attr_username;
    std::string attr_password;
    std::list<std::string> attr_characters;

    void sendUsername(Atlas::Bridge&) const;
    void sendPassword(Atlas::Bridge&) const;
    void sendCharacters(Atlas::Bridge&) const;

    virtual void iterate(int& current_class, std::string& attr) const;

    //freelist related things
public:
    static AccountData *alloc();
    virtual void free();

    virtual AccountData *getDefaultObject();

    static AccountData *getDefaultObjectInstance();
private:
    static AccountData *defaults_AccountData;
    static AccountData *begin_AccountData;

    static std::map<std::string, int> * attr_flags_AccountData;
};

//
// Attribute name strings follow.
//

extern const std::string USERNAME_ATTR;
extern const std::string PASSWORD_ATTR;
extern const std::string CHARACTERS_ATTR;

//
// Inlined member functions follow.
//

const int USERNAME_FLAG = 1 << 11;

void AccountData::setUsername(const std::string& val)
{
    attr_username = val;
    m_attrFlags |= USERNAME_FLAG;
}

const int PASSWORD_FLAG = 1 << 12;

void AccountData::setPassword(const std::string& val)
{
    attr_password = val;
    m_attrFlags |= PASSWORD_FLAG;
}

const int CHARACTERS_FLAG = 1 << 13;

void AccountData::setCharacters(const std::list<std::string>& val)
{
    attr_characters = val;
    m_attrFlags |= CHARACTERS_FLAG;
}

void AccountData::setCharactersAsList(const Atlas::Message::ListType& val)
{
    m_attrFlags |= CHARACTERS_FLAG;
    attr_characters.resize(0);
    for(Atlas::Message::ListType::const_iterator I = val.begin();
        I != val.end();
        I++)
    {
        if((*I).isString()) {
            attr_characters.push_back((*I).asString());
        }
    }
}

const std::string& AccountData::getUsername() const
{
    if(m_attrFlags & USERNAME_FLAG)
        return attr_username;
    else
        return ((AccountData*)m_defaults)->attr_username;
}

std::string& AccountData::modifyUsername()
{
    if(!(m_attrFlags & USERNAME_FLAG))
        setUsername(((AccountData*)m_defaults)->attr_username);
    return attr_username;
}

const std::string& AccountData::getPassword() const
{
    if(m_attrFlags & PASSWORD_FLAG)
        return attr_password;
    else
        return ((AccountData*)m_defaults)->attr_password;
}

std::string& AccountData::modifyPassword()
{
    if(!(m_attrFlags & PASSWORD_FLAG))
        setPassword(((AccountData*)m_defaults)->attr_password);
    return attr_password;
}

const std::list<std::string>& AccountData::getCharacters() const
{
    if(m_attrFlags & CHARACTERS_FLAG)
        return attr_characters;
    else
        return ((AccountData*)m_defaults)->attr_characters;
}

std::list<std::string>& AccountData::modifyCharacters()
{
    if(!(m_attrFlags & CHARACTERS_FLAG))
        setCharacters(((AccountData*)m_defaults)->attr_characters);
    return attr_characters;
}

const Atlas::Message::ListType AccountData::getCharactersAsList() const
{
    const std::list<std::string>& lst_in = getCharacters();
    Atlas::Message::ListType lst_out;
    for(std::list<std::string>::const_iterator I = lst_in.begin();
        I != lst_in.end();
        I++)
    {
        lst_out.push_back(std::string(*I));
    }
    return lst_out;
}

bool AccountData::isDefaultUsername() const
{
    return (m_attrFlags & USERNAME_FLAG) == 0;
}

bool AccountData::isDefaultPassword() const
{
    return (m_attrFlags & PASSWORD_FLAG) == 0;
}

bool AccountData::isDefaultCharacters() const
{
    return (m_attrFlags & CHARACTERS_FLAG) == 0;
}



class PlayerData;
typedef SmartPtr<PlayerData> Player;

static const int PLAYER_NO = 5;


class PlayerData : public AccountData
{
protected:
    PlayerData(PlayerData *defaults = NULL) : 
        AccountData((AccountData*)defaults)
    {
        m_class_no = PLAYER_NO;
    }
    virtual ~PlayerData();

public:
    virtual PlayerData * copy() const;

    virtual bool instanceOf(int classNo) const;


    virtual void iterate(int& current_class, std::string& attr) const
        {if(current_class == PLAYER_NO) current_class = -1; AccountData::iterate(current_class, attr);}

    //freelist related things
public:
    static PlayerData *alloc();
    virtual void free();

    virtual PlayerData *getDefaultObject();

    static PlayerData *getDefaultObjectInstance();
private:
    static PlayerData *defaults_PlayerData;
    static PlayerData *begin_PlayerData;
};


class AdminData;
typedef SmartPtr<AdminData> Admin;

static const int ADMIN_NO = 6;


class AdminData : public AccountData
{
protected:
    AdminData(AdminData *defaults = NULL) : 
        AccountData((AccountData*)defaults)
    {
        m_class_no = ADMIN_NO;
    }
    virtual ~AdminData();

public:
    virtual AdminData * copy() const;

    virtual bool instanceOf(int classNo) const;


    virtual void iterate(int& current_class, std::string& attr) const
        {if(current_class == ADMIN_NO) current_class = -1; AccountData::iterate(current_class, attr);}

    //freelist related things
public:
    static AdminData *alloc();
    virtual void free();

    virtual AdminData *getDefaultObject();

    static AdminData *getDefaultObjectInstance();
private:
    static AdminData *defaults_AdminData;
    static AdminData *begin_AdminData;
};


class GameData;
typedef SmartPtr<GameData> Game;

static const int GAME_NO = 7;


class GameData : public AdminEntityData
{
protected:
    GameData(GameData *defaults = NULL) : 
        AdminEntityData((AdminEntityData*)defaults)
    {
        m_class_no = GAME_NO;
    }
    virtual ~GameData();

public:
    virtual GameData * copy() const;

    virtual bool instanceOf(int classNo) const;


    virtual void iterate(int& current_class, std::string& attr) const
        {if(current_class == GAME_NO) current_class = -1; AdminEntityData::iterate(current_class, attr);}

    //freelist related things
public:
    static GameData *alloc();
    virtual void free();

    virtual GameData *getDefaultObject();

    static GameData *getDefaultObjectInstance();
private:
    static GameData *defaults_GameData;
    static GameData *begin_GameData;
};


class GameEntityData;
typedef SmartPtr<GameEntityData> GameEntity;

static const int GAME_ENTITY_NO = 8;


class GameEntityData : public RootEntityData
{
protected:
    GameEntityData(GameEntityData *defaults = NULL) : 
        RootEntityData((RootEntityData*)defaults)
    {
        m_class_no = GAME_ENTITY_NO;
    }
    virtual ~GameEntityData();

public:
    virtual GameEntityData * copy() const;

    virtual bool instanceOf(int classNo) const;


    virtual void iterate(int& current_class, std::string& attr) const
        {if(current_class == GAME_ENTITY_NO) current_class = -1; RootEntityData::iterate(current_class, attr);}

    //freelist related things
public:
    static GameEntityData *alloc();
    virtual void free();

    virtual GameEntityData *getDefaultObject();

    static GameEntityData *getDefaultObjectInstance();
private:
    static GameEntityData *defaults_GameEntityData;
    static GameEntityData *begin_GameEntityData;
};

} } } // namespace Atlas::Objects::Entity

#endif // ATLAS_OBJECTS_ENTITY_ENTITY_H