BaseObject.h

// This file may be redistributed and modified only under the terms of
// the GNU Lesser General Public License (See COPYING for details).
// Copyright (C) 2000-2004 Stefanus Du Toit, Aloril and Al Riddoch
 
// $Id$
 
#ifndef ATLAS_OBJECTS_BASEOBJECT_H
#define ATLAS_OBJECTS_BASEOBJECT_H
 
#include <Atlas/Message/MEncoder.h>
#include <Atlas/Message/Element.h>
#include <Atlas/Bridge.h>
#include <Atlas/Exception.h>
 
#include <map>
#include <list>
#include <string>
 
#include <assert.h>
 
namespace Atlas {
 
namespace Objects {
 
class NoSuchAttrException : public Atlas::Exception
{
    std::string m_name;
  public:
    NoSuchAttrException(const std::string& name) :
             Atlas::Exception("No such attribute"), m_name(name) {}
    virtual ~NoSuchAttrException();
    const std::string & getName() const {
        return m_name;
    }
};
 
static const int BASE_OBJECT_NO = 0;
 
class BaseObjectData
{
public:
    BaseObjectData(BaseObjectData *defaults);
 
    virtual ~BaseObjectData();
 
    int getClassNo() const 
    {
        return m_class_no;
    }
 
    int getAttrFlags() const
    {
        return m_attrFlags;
    }
 
    virtual BaseObjectData * copy() const = 0;
 
    virtual bool instanceOf(int classNo) const;
    
    bool hasAttr(const std::string& name) const;
    bool hasAttrFlag(int flag) const;
    const Atlas::Message::Element getAttr(const std::string& name)
        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 removeAttrFlag(int flag);
 
    const Atlas::Message::MapType asMessage() const;
 
    virtual void addToMessage(Atlas::Message::MapType &) const;
 
    virtual void sendContents(Atlas::Bridge & b) const;
 
    //move to protected once SmartPtr <-> BaseObject order established
    inline void incRef();
    inline void decRef();
 
    static BaseObjectData *alloc() {assert(0); return NULL;} //not callable
    virtual void free() = 0;
 
    class const_iterator;
 
    // FIXME should this hold a reference to the object it's
    // iterating over?
 
    class iterator
    {
    public:
        friend class BaseObjectData;
        friend class const_iterator;
 
        iterator() : m_obj(0), m_val("", *this) {}
        iterator(const iterator& I) : m_obj(I.m_obj),
            m_current_class(I.m_current_class),
            m_I(I.m_I), m_val(I.m_val.first, *this) {}
        iterator(BaseObjectData& obj, int current_class);
 
        // default destructor is fine unless we hold a reference to m_obj
 
        iterator& operator=(const iterator& I);
 
        iterator& operator++(); // preincrement
 
        inline iterator operator++(int); // postincrement
 
        bool operator==(const iterator& I) const;
 
        bool operator!=(const iterator& I) const {return !operator==(I);}
 
        class PsuedoElement
        {
            public:
                PsuedoElement(const iterator& I) : m_I(I) {}
 
                operator Message::Element() const;
                // this acts on const PsuedoElement instead of PsuedoElement
                // so that we can assign to attributes refered to by
                // a const iterator& (as opposed to a const_iterator, where
                // we can't, but that's done later)
                const PsuedoElement& operator=(const Message::Element& val) const;
 
            private:
                const iterator& m_I;
        };
 
        friend class PsuedoElement;
 
        typedef std::pair<std::string,PsuedoElement> value_type;
 
        const value_type& operator*() const {return m_val;}
        const value_type* operator->() const {return &m_val;}
 
    private:
        BaseObjectData *m_obj; // pointer to object whose args we're iterating
        int m_current_class; // m_class_no for current class in the iteration
        Message::MapType::iterator m_I; // iterator in m_obj->m_attributes
        value_type m_val;
    };
    friend class iterator;
 
    // FIXME should this hold a reference to the object it's
    // iterating over?
    class const_iterator
    {
    public:
        friend class BaseObjectData;
 
        const_iterator() : m_obj(0), m_val("", *this) {}
        const_iterator(const const_iterator& I) : m_obj(I.m_obj),
            m_current_class(I.m_current_class),
            m_I(I.m_I), m_val(I.m_val.first, *this) {}
        const_iterator(const iterator& I) : m_obj(I.m_obj),
            m_current_class(I.m_current_class),
            m_I(I.m_I), m_val(I.m_val.first, *this) {}
        const_iterator(const BaseObjectData& obj, int current_class);
 
        // default destructor is fine unless we hold a reference to m_obj
 
        const_iterator& operator=(const const_iterator& I);
 
        const_iterator& operator++(); // preincrement
 
        inline const_iterator operator++(int); // postincrement
 
        bool operator==(const const_iterator& I) const;
 
        bool operator!=(const const_iterator& I) const {return !operator==(I);}
 
        class PsuedoElement
        {
            public:
                PsuedoElement(const const_iterator& I) : m_I(I) {}
 
                operator Message::Element() const;
 
            private:
                const const_iterator& m_I;
        };
 
        friend class PsuedoElement;
 
        typedef std::pair<std::string,PsuedoElement> value_type;
 
        const value_type& operator*() const {return m_val;}
        const value_type* operator->() const {return &m_val;}
 
    private:
        const BaseObjectData *m_obj; // pointer to object whose args we're iterating
        int m_current_class; // m_class_no for current class in the iteration
        Message::MapType::const_iterator m_I; // const_iterator in m_obj->m_attributes
        value_type m_val;
    };
 
    friend class const_iterator;
 
    iterator begin() {return iterator(*this, -1);}
    iterator end() {return iterator(*this, BASE_OBJECT_NO);}
    iterator find(const std::string&);
 
    const_iterator begin() const {return const_iterator(*this, -1);}
    const_iterator end() const {return const_iterator(*this, BASE_OBJECT_NO);}
    const_iterator find(const std::string&) const;
 
protected:
 
    virtual int getAttrClass(const std::string& name) const;
 
    virtual int getAttrFlag(const std::string& name) const;
 
    virtual void iterate(int& current_class, std::string& attr) const;
 
    int m_class_no; //each class has different enum
    int m_refCount; //how many instances 
    BaseObjectData *m_defaults;
    //this will be defined in each subclass separately, so no need here for it
    //static BaseObjectData *begin; 
    BaseObjectData *m_next;
    std::map<std::string, Atlas::Message::Element> m_attributes;
    // is attribute in this object or in default object?
    int m_attrFlags;
};
 
void BaseObjectData::incRef() {
    m_refCount++;
}
 
void BaseObjectData::decRef() {
    //why zero based refCount? avoids one m_refCount-- ;-)
    assert( m_refCount >= 0 );
    if(!m_refCount) {
        free();
        return;
    }
    m_refCount--;
}
 
BaseObjectData::iterator BaseObjectData::iterator::operator++(int) // postincrement
{
    iterator tmp = *this;
    operator++();
    return tmp;
}
 
BaseObjectData::const_iterator BaseObjectData::const_iterator::operator++(int) // postincrement
{
    const_iterator tmp = *this;
    operator++();
    return tmp;
}
 
 
} } // namespace Atlas::Objects
 
#endif