GraphElement.h

Go to the documentation of this file.

/*
Copyright (c) 2013,
    Neuroinformatics and Cognitive Robotics Labs at TU Ilmenau, Germany

All rights reserved.

Copying, resale, or redistribution, with or without modification, is strictly
prohibited.

THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES,
EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/

#pragma once

#include <string>

#include <platform/Types.h>
#include <factory/Factory.h>

#include <topomap/TopoMapFwd.h>

namespace viros { namespace topomap {


class GraphElement
{
public:
    virtual ~GraphElement() {}

    template<typename Reflector>
    void reflect(Reflector& r)
    {
        // nothing
    }

    virtual GraphElementPtr findElement(const std::string& predicate) {
        return GraphElementPtr();
    }

    virtual const GraphElementPtr findElement(const std::string& predicate) const {
        return findElement(predicate);
    }
};

class NamedGraphElement : public GraphElement
{
public:

    NamedGraphElement(const std::string& prefix, int);
    NamedGraphElement(const std::string& name) : mName(name) {}

    template<typename Reflector>
    void reflect(Reflector& r)
    {
        GraphElement::reflect(r);
        r.member("Name", mName, "");
    }

public:

    virtual void setName(const std::string& name) {
        mName = name;
    }

    virtual const std::string& getName() const {
        return mName;
    }

protected:
    std::string mName;

    static volatile uint32 sID;
};


class AttributedGraphElement : public NamedGraphElement
{
public:

    AttributedGraphElement(const std::string& prefix, int) : NamedGraphElement(prefix, 0) {}
    AttributedGraphElement(const std::string& name) : NamedGraphElement(name) {}

    virtual ~AttributedGraphElement();

    template<typename Reflector>
    void reflect(Reflector& r)
    {
        NamedGraphElement::reflect(r);
        r.member("Attributes", mAttributes, "");
    }

public:

    virtual void setAttribute(const std::string& name, AttributePtr attribute);

    virtual void removeAttribute(const std::string& name, const mira::Class& attrClass);

    template <typename AttributeClass>
    void removeAttribute(const std::string& name) {
        removeAttribute(name, AttributeClass::CLASS());
    }

    virtual AttributePtr getAttributeUntyped(const std::string& name, const mira::Class& clazz, bool inherited=true);

    template <typename AttributeClass>
    boost::shared_ptr<AttributeClass> getAttribute(const std::string& name, bool inherited=true) {
        return boost::dynamic_pointer_cast<AttributeClass>(getAttributeUntyped(name, AttributeClass::CLASS(), inherited));
    }

    virtual void getAllAttributesUntyped(std::map<std::string, AttributePtr>& oAttributes, const mira::Class& clazz, bool inherited=true);

    template <typename AttributeClass>
    std::map<std::string, boost::shared_ptr<AttributeClass>> getAllAttributes(bool inherited=true) {
        std::map<std::string, AttributePtr> attributes;
        typedef boost::shared_ptr<AttributeClass> AttributeClassPtr;
        std::map<std::string, AttributeClassPtr> tattributes;

        getAllAttributesUntyped(attributes, AttributeClass::CLASS(), inherited);
        foreach(auto& p, attributes)
            tattributes[p.first] = boost::dynamic_pointer_cast<AttributeClass>(p.second);
        return tattributes;
    }

    template <typename AttributeClass>
    boost::shared_ptr<AttributeClass> obtainAttribute(const std::string& name) {
        boost::shared_ptr<AttributeClass> obj = getAttribute<AttributeClass>(name,false);
        if(!obj) {
            obj = boost::make_shared<AttributeClass>();
            setAttribute(name, obj);
        }
        return obj;
    }


protected:


    struct AttributeKey
    {
        std::string name;
        std::string clazz;

        template<typename Reflector>
        void reflect(Reflector& r)
        {
            r.member("name", name, "");
            r.member("classid", clazz, "");
        }

        bool operator<(const AttributeKey& other) const {
            if(clazz == other.clazz)
                return name < other.name;
            return clazz < other.clazz;
        }
    };
    std::map<AttributeKey, AttributePtr> mAttributes;

};


} } // namespace