PersistentEntitySegment.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)
* @date       2013
* @copyright  http://www.gnu.org/licenses/gpl-2.0.txt
*             GNU General Public License
*/
 
#pragma once
 
#include "SegmentUtilImplementations.h"
 
#include <MemoryX/interface/core/MemoryInterface.h>
#include <MemoryX/interface/components/CommonStorageInterface.h>
 
#include <mutex>
 
namespace memoryx
{
    class MongoSerializer;
    using MongoSerializerPtr = IceUtil::Handle<MongoSerializer>;
 
    class PersistentEntitySegment :
        public virtual PersistentEntitySegmentBase,
        public virtual SegmentUtilImplementations
    {
    public:
        PersistentEntitySegment(CollectionInterfacePrx entityCollection, Ice::CommunicatorPtr ic, bool useMongoIds = true);
        ~PersistentEntitySegment() override;
 
        NameList getReadCollectionsNS(const ::Ice::Current& = Ice::emptyCurrent) const override;
        void clearReadCollections(const ::Ice::Current& = Ice::emptyCurrent) override;
        void addReadCollection(const CollectionInterfacePrx& coll, const ::Ice::Current& = Ice::emptyCurrent) override;
        std::string getWriteCollectionNS(const ::Ice::Current& = Ice::emptyCurrent) const override;
        void setWriteCollection(const CollectionInterfacePrx& coll, const ::Ice::Current& = Ice::emptyCurrent) override;
        void setSingleRWCollection(const CollectionInterfacePrx& coll, const ::Ice::Current& = Ice::emptyCurrent) override;
 
        std::string getObjectTypeId(const ::Ice::Current& = Ice::emptyCurrent) const override;
 
        std::string addEntity(const EntityBasePtr& entity, const ::Ice::Current& c = Ice::emptyCurrent) override;
        virtual std::string addEntityThreadUnsafe(const EntityBasePtr& entity);
        std::string upsertEntity(const std::string& entityId, const EntityBasePtr& entity, const ::Ice::Current& = Ice::emptyCurrent) override;
        virtual std::string upsertEntityThreadUnsafe(const std::string& entityId, const EntityBasePtr& entity);
        std::string upsertEntityByName(const std::string& entityName, const EntityBasePtr& entity, const ::Ice::Current& = Ice::emptyCurrent) override;
        virtual std::string upsertEntityByNameThreadUnsafe(const std::string& entityName, const EntityBasePtr& entity);
        EntityIdList addEntityList(const EntityBaseList& entityList, const Ice::Current& = Ice::emptyCurrent) override;
        virtual EntityIdList addEntityListThreadUnsafe(const EntityBaseList& entityList);
 
        EntityIdList upsertEntityList(const EntityBaseList& entityList, const Ice::Current& = Ice::emptyCurrent) override;
        virtual EntityIdList upsertEntityListThreadUnsafe(const EntityBaseList& entityList);
 
        void updateEntity(const ::std::string& entityId, const EntityBasePtr& update, const ::Ice::Current& = Ice::emptyCurrent) override;
        virtual void updateEntityThreadUnsafe(const ::std::string& entityId, const EntityBasePtr& update);
 
        void removeEntity(const ::std::string& entityId, const ::Ice::Current& = Ice::emptyCurrent) override;
        virtual void removeEntityThreadUnsafe(const ::std::string& entityId);
        void removeAllEntities(const ::Ice::Current& c = Ice::emptyCurrent) override;
 
        bool hasEntityById(const std::string& entityId, const Ice::Current& = Ice::emptyCurrent) const override;
        bool hasEntityByIdThreadUnsafe(const std::string& entityId) const;
        bool hasEntityByName(const std::string& entityName, const Ice::Current& = Ice::emptyCurrent) const override;
        bool hasEntityByNameThreadUnsafe(const std::string& entityName) const;
 
        EntityBasePtr getEntityById(const ::std::string& entityId, const ::Ice::Current& = Ice::emptyCurrent) const override;
        virtual EntityBasePtr getEntityByIdThreadUnsafe(const ::std::string& entityId) const;
        EntityBasePtr getEntityByName(const ::std::string& name, const ::Ice::Current& = Ice::emptyCurrent) const override;
        virtual EntityBasePtr getEntityByNameThreadUnsafe(const ::std::string& name) const;
        EntityBaseList getEntitiesByAttrValue(const ::std::string& attrName, const ::std::string& attrValue, const ::Ice::Current& = Ice::emptyCurrent) const override;
        EntityBaseList getEntitiesByAttrValueList(const ::std::string& attrName, const NameList& attrValueList, const ::Ice::Current& = Ice::emptyCurrent) const override;
        EntityIdList getAllEntityIds(const ::Ice::Current& = Ice::emptyCurrent) const override;
        virtual EntityIdList getAllEntityIdsThreadUnsafe() const;
        EntityBaseList getAllEntities(const ::Ice::Current& = Ice::emptyCurrent) const override;
        IdEntityMap getIdEntityMap(const ::Ice::Current& = Ice::emptyCurrent) const override;
 
        Ice::Int size(const ::Ice::Current& = Ice::emptyCurrent) const override;
        void print(const ::Ice::Current& = Ice::emptyCurrent) const override;
        void clear(const ::Ice::Current& = Ice::emptyCurrent) override;
 
        ::Ice::Identity getIceId(const ::Ice::Current& = Ice::emptyCurrent) const override;
        std::string getSegmentName(const ::Ice::Current& = Ice::emptyCurrent) const override;
 
        // EntityMemorySegmentInterface interface
    public:
        EntityRefBasePtr getEntityRefById(const std::string& id, const Ice::Current&) const override;
        EntityRefBasePtr getEntityRefByName(const std::string& name, const Ice::Current& c) const override;
 
        void setEntityAttribute(const std::string& entityId, const EntityAttributeBasePtr& attribute, const Ice::Current&) override;
        void setEntityAttributes(const std::string& entityId, const EntityAttributeList& attributeMap, const Ice::Current&) override;
 
        // AbstractMemorySegment interface
    public:
        void setParentMemory(const MemoryInterfacePtr& memory, const Ice::Current&) override;
 
        // PersistentEntitySegmentBase interface
    public:
        EntityRefList findRefsByQuery(const std::string& query, const Ice::Current& c) override;
 
    protected:
        // set segment name
        void setSegmentName(const std::string& segmentName, const ::Ice::Current& = Ice::emptyCurrent) override;
 
        MemoryInterfacePtr parentMemory;
 
        CollectionPrxList readCollections;
        //        mutable boost::mutex readCollectionsMutex;
 
        CollectionInterfacePrx writeCollection;
        MongoSerializerPtr dbSerializer;
        mutable std::recursive_mutex dbSerializerMutex;
 
        bool useMongoIds;
 
        EntityBasePtr deserializeEntity(const DBStorableData& dbEntity) const;
        std::string segmentName;
 
 
    };
 
 
    using PersistentEntitySegmentPtr = IceUtil::Handle<PersistentEntitySegment>;
 
}