ReadWritePluginUser.h

Go to the documentation of this file.

#pragma once
 
#include <ArmarXCore/core/ManagedIceObject.h>
 
#include <RobotAPI/interface/armem/server/MemoryInterface.h>
#include <RobotAPI/libraries/armem/client/plugins/ListeningPluginUser.h>
#include <RobotAPI/libraries/armem/core/actions.h>
#include <RobotAPI/libraries/armem/server/forward_declarations.h>
 
 
namespace armarx::armem::server::plugins
{
 
    class Plugin;
 
    /**
     * @brief Base class of memory server components.
     *
     * Implements the server ice interfaces using the ice adapter of the plugin.
     */
    class ReadWritePluginUser :
        virtual public ManagedIceObject,
        virtual public MemoryInterface,
        virtual public client::plugins::ListeningPluginUser
    {
    public:
        ReadWritePluginUser();
        virtual ~ReadWritePluginUser() override;
 
 
        void setMemoryName(const std::string& memoryName);
 
 
        // WritingInterface interface
        virtual data::AddSegmentsResult
        addSegments(const data::AddSegmentsInput& input,
                    const Ice::Current& = Ice::emptyCurrent) override;
        data::AddSegmentsResult addSegments(const data::AddSegmentsInput& input,
                                            bool addCoreSegments);
 
        virtual data::CommitResult commit(const data::Commit& commit,
                                          const Ice::Current& = Ice::emptyCurrent) override;
        
        /**
         * Clears the working memory usings its clear feature.
         */
        virtual void clearWorkingMemory(const Ice::Current& = Ice::emptyCurrent) override;
 
        // ReadingInterface interface
        virtual armem::query::data::Result query(const armem::query::data::Input& input,
                                                 const Ice::Current& = Ice::emptyCurrent) override;
        
        /**
         * Queries only the LTMs of the memory server.
         * @param storeIntoWM if set, the result is also stored into the working memory 
         *                    no matter how the recording mode is set.
         */
        virtual armem::query::data::Result queryLTM(const armem::query::data::Input& input,
                                                    bool storeIntoWM,
                                                    const Ice::Current& = Ice::emptyCurrent) override;
 
        virtual armem::structure::data::GetServerStructureResult
        getServerStructure(const Ice::Current& = Ice::emptyCurrent) override;
 
 
        // StoringInterface interface
        virtual dto::DirectlyStoreResult
        directlyStore(const dto::DirectlyStoreInput&,
                      const Ice::Current& = Ice::emptyCurrent) override;
        virtual dto::StartRecordResult
        startRecord(const dto::StartRecordInput& startRecordInput,
                    const Ice::Current& = Ice::emptyCurrent) override;
        virtual dto::StopRecordResult stopRecord(const Ice::Current& = Ice::emptyCurrent) override;
        virtual dto::RecordStatusResult
        getRecordStatus(const Ice::Current& = Ice::emptyCurrent) override;
 
        // ActionsInterface interface
        virtual armem::actions::GetActionsOutputSeq
        getActions(const armem::actions::GetActionsInputSeq& inputs);
        virtual armem::actions::ExecuteActionOutputSeq
        executeActions(const armem::actions::ExecuteActionInputSeq& inputs);
 
        virtual armem::actions::GetActionsOutputSeq
        getActions(const armem::actions::GetActionsInputSeq& inputs,
                   const ::Ice::Current&) override;
        virtual armem::actions::ExecuteActionOutputSeq
        executeActions(const armem::actions::ExecuteActionInputSeq& inputs,
                       const ::Ice::Current&) override;
 
        // PredictingInterface interface
        virtual armem::prediction::data::PredictionResultSeq
        predict(const armem::prediction::data::PredictionRequestSeq& requests);
 
        // Unless you need very unusual behavior from this method for your memory server,
        // it is better to set the available prediction engines in the memory itself
        // and let it handle the requests than to override this.
        virtual armem::prediction::data::EngineSupportMap getAvailableEngines();
 
        virtual armem::prediction::data::PredictionResultSeq
        predict(const armem::prediction::data::PredictionRequestSeq& requests,
                const ::Ice::Current&) override;
        virtual armem::prediction::data::EngineSupportMap
        getAvailableEngines(const ::Ice::Current&) override;
 
        //ReloadFromLTMOnStartup
        armem::CommitResult reloadFromLTM();
        
        /**
         * Loads the data of the LTMs into the WM.
         */
        virtual void loadLTMintoWM(bool complete, const ::Ice::Current&) override;
        
        /**
         * @brief Use a rest persistence strategy for storing the wm as ltm
         * Uses a rest server as ltm sink.
         *
         * @param identifier unique strategy name
         * @param exportName memory export name
         * @param host name of the host where the rest server is running
         * @param port network port at which the rest server is running
         * @param overwritePrevStrategy if set the ltm only contains this new strategy, if false it will be appended to the other(s)
         */
        virtual void useRestPersistenceStrategy(const std::string& identifier, const std::string& exportName, const std::string& host, int port, bool overwritePrevStrategy, const ::Ice::Current&) override;
 
        /**
         * @brief Use a disk persistence strategy for storing the wm as ltm
         * Uses the disk as ltm sink.
         *
         * @param identifier unique strategy name
         * @param exportName memory export name
         * @param exportPath path where the export is stored on disk
         * @param overwritePrevStrategy if set the ltm only contains this new strategy, if false it will be appended to the other(s)
         */
        virtual void useDiskPersistenceStrategy(const std::string& identifier, const std::string& exportName, const std::string& exportPath, bool overwritePrevStrategy, const ::Ice::Current&) override;
 
        /**
         * @brief Use a mongodb persistence strategy for storing the wm as ltm
         * Uses a mongodb as ltm sink.
         * 
         * NOTE (TODO): Not implemented
         */
        virtual void useMongoDbPersistenceStrategy(const std::string& identifier, const std::string& exportName, bool overwritePrevStrategy, const ::Ice::Current&) override;
 
    public:
        Plugin& memoryServerPlugin();
 
        server::wm::Memory& workingMemory();
        MemoryToIceAdapter& iceAdapter();
 
        server::ltm::Memory& longtermMemory();
 
 
    private:
        plugins::Plugin* plugin = nullptr;
    };
 
} // namespace armarx::armem::server::plugins
 
namespace armarx::armem::server
{
    using plugins::ReadWritePluginUser;
}