Root.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_ROOT_H
#define ATLAS_OBJECTS_ROOT_H
 
#include <Atlas/Objects/BaseObject.h>
 
#include <Atlas/Message/Element.h>
 
namespace Atlas { namespace Objects { 
 
template <class T> class SmartPtr;
 
class RootData;
typedef SmartPtr<RootData> Root;
 
static const int ROOT_NO = 1;
 
 
class RootData : public BaseObjectData
{
protected:
    RootData(RootData *defaults = NULL) : 
        BaseObjectData((BaseObjectData*)defaults)
    {
        m_class_no = ROOT_NO;
    }
    virtual ~RootData();
 
public:
    virtual RootData * 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 setId(const std::string& val);
    inline void setParents(const std::list<std::string>& val);
    inline void setParentsAsList(const Atlas::Message::ListType& val);
    inline void setStamp(double val);
    inline void setObjtype(const std::string& val);
    inline void setName(const std::string& val);
 
    inline const std::string& getId() const;
    inline std::string& modifyId();
    inline const std::list<std::string>& getParents() const;
    inline std::list<std::string>& modifyParents();
    inline const Atlas::Message::ListType getParentsAsList() const;
    inline double getStamp() const;
    inline double& modifyStamp();
    inline const std::string& getObjtype() const;
    inline std::string& modifyObjtype();
    inline const std::string& getName() const;
    inline std::string& modifyName();
 
    inline bool isDefaultId() const;
    inline bool isDefaultParents() const;
    inline bool isDefaultStamp() const;
    inline bool isDefaultObjtype() const;
    inline bool isDefaultName() const;
 
protected:
    virtual int getAttrClass(const std::string& name)const;
    virtual int getAttrFlag(const std::string& name)const;
    std::string attr_id;
    std::list<std::string> attr_parents;
    double attr_stamp;
    std::string attr_objtype;
    std::string attr_name;
 
    void sendId(Atlas::Bridge&) const;
    void sendParents(Atlas::Bridge&) const;
    void sendStamp(Atlas::Bridge&) const;
    void sendObjtype(Atlas::Bridge&) const;
    void sendName(Atlas::Bridge&) const;
 
    virtual void iterate(int& current_class, std::string& attr) const;
 
    //freelist related things
public:
    static RootData *alloc();
    virtual void free();
 
    virtual RootData *getDefaultObject();
 
    static RootData *getDefaultObjectInstance();
private:
    static RootData *defaults_RootData;
    static RootData *begin_RootData;
 
    static std::map<std::string, int> * attr_flags_RootData;
};
 
//
// Attribute name strings follow.
//
 
extern const std::string ID_ATTR;
extern const std::string PARENTS_ATTR;
extern const std::string STAMP_ATTR;
extern const std::string OBJTYPE_ATTR;
extern const std::string NAME_ATTR;
 
//
// Inlined member functions follow.
//
 
const int ID_FLAG = 1 << 1;
 
void RootData::setId(const std::string& val)
{
    attr_id = val;
    m_attrFlags |= ID_FLAG;
}
 
const int PARENTS_FLAG = 1 << 2;
 
void RootData::setParents(const std::list<std::string>& val)
{
    attr_parents = val;
    m_attrFlags |= PARENTS_FLAG;
}
 
void RootData::setParentsAsList(const Atlas::Message::ListType& val)
{
    m_attrFlags |= PARENTS_FLAG;
    attr_parents.resize(0);
    for(Atlas::Message::ListType::const_iterator I = val.begin();
        I != val.end();
        I++)
    {
        if((*I).isString()) {
            attr_parents.push_back((*I).asString());
        }
    }
}
 
const int STAMP_FLAG = 1 << 3;
 
void RootData::setStamp(double val)
{
    attr_stamp = val;
    m_attrFlags |= STAMP_FLAG;
}
 
const int OBJTYPE_FLAG = 1 << 4;
 
void RootData::setObjtype(const std::string& val)
{
    attr_objtype = val;
    m_attrFlags |= OBJTYPE_FLAG;
}
 
const int NAME_FLAG = 1 << 5;
 
void RootData::setName(const std::string& val)
{
    attr_name = val;
    m_attrFlags |= NAME_FLAG;
}
 
const std::string& RootData::getId() const
{
    if(m_attrFlags & ID_FLAG)
        return attr_id;
    else
        return ((RootData*)m_defaults)->attr_id;
}
 
std::string& RootData::modifyId()
{
    if(!(m_attrFlags & ID_FLAG))
        setId(((RootData*)m_defaults)->attr_id);
    return attr_id;
}
 
const std::list<std::string>& RootData::getParents() const
{
    if(m_attrFlags & PARENTS_FLAG)
        return attr_parents;
    else
        return ((RootData*)m_defaults)->attr_parents;
}
 
std::list<std::string>& RootData::modifyParents()
{
    if(!(m_attrFlags & PARENTS_FLAG))
        setParents(((RootData*)m_defaults)->attr_parents);
    return attr_parents;
}
 
const Atlas::Message::ListType RootData::getParentsAsList() const
{
    const std::list<std::string>& lst_in = getParents();
    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;
}
 
double RootData::getStamp() const
{
    if(m_attrFlags & STAMP_FLAG)
        return attr_stamp;
    else
        return ((RootData*)m_defaults)->attr_stamp;
}
 
double& RootData::modifyStamp()
{
    if(!(m_attrFlags & STAMP_FLAG))
        setStamp(((RootData*)m_defaults)->attr_stamp);
    return attr_stamp;
}
 
const std::string& RootData::getObjtype() const
{
    if(m_attrFlags & OBJTYPE_FLAG)
        return attr_objtype;
    else
        return ((RootData*)m_defaults)->attr_objtype;
}
 
std::string& RootData::modifyObjtype()
{
    if(!(m_attrFlags & OBJTYPE_FLAG))
        setObjtype(((RootData*)m_defaults)->attr_objtype);
    return attr_objtype;
}
 
const std::string& RootData::getName() const
{
    if(m_attrFlags & NAME_FLAG)
        return attr_name;
    else
        return ((RootData*)m_defaults)->attr_name;
}
 
std::string& RootData::modifyName()
{
    if(!(m_attrFlags & NAME_FLAG))
        setName(((RootData*)m_defaults)->attr_name);
    return attr_name;
}
 
bool RootData::isDefaultId() const
{
    return (m_attrFlags & ID_FLAG) == 0;
}
 
bool RootData::isDefaultParents() const
{
    return (m_attrFlags & PARENTS_FLAG) == 0;
}
 
bool RootData::isDefaultStamp() const
{
    return (m_attrFlags & STAMP_FLAG) == 0;
}
 
bool RootData::isDefaultObjtype() const
{
    return (m_attrFlags & OBJTYPE_FLAG) == 0;
}
 
bool RootData::isDefaultName() const
{
    return (m_attrFlags & NAME_FLAG) == 0;
}
 
 
} } // namespace Atlas::Objects
 
#endif // ATLAS_OBJECTS_ROOT_H