Entity.h

Go to the documentation of this file.

/*
* This file is part of ArmarX.
*
* ArmarX is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License version 2 as
* published by the Free Software Foundation.
*
* ArmarX is distributed in the hope that it will be useful, but
* WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>.
*
* @package    MemoryX::Core
* @author     Alexey Kozlov ( kozlov at kit dot edu), Kai Welke ( welke at kit dot edu )
* @date       2012
* @copyright  http://www.gnu.org/licenses/gpl-2.0.txt
*             GNU General Public License
*/
 
#pragma once
 
#include "AbstractEntityWrapper.h"
#include "EntityAttribute.h"
 
#include <MemoryX/interface/core/EntityBase.h>
#include <MemoryX/interface/core/ProbabilityMeasures.h>
 
#include <ArmarXCore/observers/variant/Variant.h>
 
#include <type_traits>
#include <shared_mutex>
#include <mutex>
#include <list>
 
namespace memoryx
{
 
    class Entity;
    class EntityRef;
    using EntityPtr = IceInternal::Handle<Entity>;
 
    class Entity :
        virtual public memoryx::EntityBase
    {
    protected:
        Entity(const Entity& source);
    public:
        static EntityPtr CreateGenericEntity();
 
        ::std::string getId(const ::Ice::Current& = Ice::emptyCurrent) const override;
 
        void setId(const ::std::string& id, const ::Ice::Current& = Ice::emptyCurrent) override;
 
        ::std::string getName(const ::Ice::Current& = Ice::emptyCurrent) const override;
 
        void setName(const ::std::string& name, const ::Ice::Current& = Ice::emptyCurrent) override;
 
        bool isMetaEntity(const ::Ice::Current& = Ice::emptyCurrent) const override;
 
        void setMetaEntity(bool isMetaEntity, const ::Ice::Current& = Ice::emptyCurrent) override;
 
        virtual EntityRefBaseList getDirectParentRefs() const;
 
        virtual EntityRefBaseList getAllParentRefs(bool includeMetaEntities = true) const;
 
        virtual std::vector<std::string> getAllParentsAsStringList() const;
 
        virtual void setDirectParentRefs(const EntityRefBaseList& entityRefs);
 
        bool hasAttribute(const ::std::string& attrName, const ::Ice::Current& = Ice::emptyCurrent) const override;
 
        EntityAttributeBasePtr getAttribute(const ::std::string& attrName, const ::Ice::Current& = Ice::emptyCurrent) const override;
 
        virtual armarx::VariantPtr getAttributeValue(const ::std::string& attrName) const;
 
        void putAttribute(const ::memoryx::EntityAttributeBasePtr& attr, const ::Ice::Current& = Ice::emptyCurrent) override;
 
        template<typename T>
        void putAttribute(const std::string& attrName, T attrValue,
                          ProbabilityMeasureBasePtr uncertainty = ProbabilityMeasureBasePtr())
        {
            const ::memoryx::EntityAttributeBasePtr attr = new EntityAttribute(attrName);
            attr->setValueWithUncertainty(armarx::VariantPtr(new armarx::Variant(attrValue)), uncertainty);
 
            putAttribute(attr);
        }
 
        void removeAttribute(const ::std::string& attrName, const ::Ice::Current& = Ice::emptyCurrent) override;
 
        memoryx::NameList getAttributeNames(const ::Ice::Current& = Ice::emptyCurrent) const override;
 
        bool equals(const EntityBasePtr& otherEntity, const ::Ice::Current& = Ice::emptyCurrent) const override;
 
        bool equalsAttributes(const EntityBasePtr& otherEntity, const ::Ice::Current& = Ice::emptyCurrent) const override;
 
        template<typename T>
        IceInternal::Handle<T> addWrapper(T* wrapper)
        {
            static_assert(!std::is_same_v<T, EntityWrappers::AbstractEntityWrapper>,
                          "The template parameter for Entity::addWrapper should not be of base class AbstractEntityWrapper");
 
            static_assert(!std::is_base_of_v<T, EntityWrappers::AbstractEntityWrapper>,
                          "The template parameter for Entity::addWrapper needs to inherit from AbstractEntityWrapper");
 
            IceInternal::Handle<T> result = getWrapper<T>();
 
            if (!result)
            {
                wrapper->setEntity(this);
                std::scoped_lock lock(wrappersMutex);
                wrappers.push_back(wrapper);
                return wrapper;
            }
 
            return result;
        }
 
 
        template<typename T>
        IceInternal::Handle<T> getWrapper()
        {
            static_assert(!std::is_same_v<T, EntityWrappers::AbstractEntityWrapper>,
                          "The template parameter for Entity::getWrapper should not be of base class AbstractEntityWrapper");
 
            static_assert(!std::is_base_of_v<T, EntityWrappers::AbstractEntityWrapper>,
                          "The template parameter for Entity::getWrapper needs to inherit from AbstractEntityWrapper");
            std::scoped_lock lock(wrappersMutex);
            AbstractEntityWrapperBaseList::iterator iter = wrappers.begin();
 
            while (iter != wrappers.end())
            {
                IceInternal::Handle<T> h = IceInternal::Handle<T>::dynamicCast(*iter);
 
                if (h)
                {
                    return h;
                }
 
                iter++;
            }
 
            //            ARMARX_ERROR_S << "No Wrapper found - " << wrappers.size() << " in list";
            return NULL;
        }
 
        // cloning
        Ice::ObjectPtr ice_clone() const override;
        EntityPtr clone(const Ice::Current& c = Ice::emptyCurrent) const;
 
        void serialize(const armarx::ObjectSerializerBasePtr& serializer, const ::Ice::Current& = Ice::emptyCurrent) const override;
 
        void deserialize(const armarx::ObjectSerializerBasePtr& serializer, const ::Ice::Current& = Ice::emptyCurrent) override;
 
 
    protected:
        template <class BaseClass, class VariantClass>
        friend class armarx::GenericFactory;
 
        Entity() {}
        ~Entity() override; // only shared pointers allowed
        void output(std::ostream& stream) const;
 
        AbstractEntityWrapperBaseList wrappers;
 
        mutable std::mutex attributesMutex;
        mutable std::shared_mutex entityMutex;
        mutable std::recursive_mutex wrappersMutex;
 
        void ice_preMarshal() override;
        void ice_postUnmarshal() override;
    private:
        void deepCopy(const Entity& source);
    public:    // streaming operator
        friend std::ostream& operator<<(std::ostream& stream, const Entity& rhs)
        {
            rhs.output(stream);
            return stream;
        }
 
        friend std::ostream& operator<<(std::ostream& stream, const EntityPtr& rhs)
        {
            rhs->output(stream);
            return stream;
        }
 
        friend std::ostream& operator<<(std::ostream& stream, const EntityBasePtr& rhs)
        {
            stream << EntityPtr::dynamicCast(rhs);
            return stream;
        }
 
        //        // Shared interface
    public:
        void __decRef() override;
    };
 
}