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 loads data from a specified LTM export into the currently running WM (needs to already have the CoreSegments)
         * 
         * This function loads an LTM specified by export_path and memoryName into the current WM.
         * It handles if the path is not a correct LTM export.
         * If you do this multiple times the LTM is always appended to the WM ,meaning you can load several LTM exports into the same WM.
         * This does not exclude the maxHistory size from working! If you load to much snapshots they will still be discarded.
         * 
         * @param export_path path to the export folder (needs to be a string with '/' as delimiter)
         * @param memoryName name of the memory server (e.g. 'Object', 'Skill')
         * @param coreSegmentNames list (std::vector) of names of core segments which should be loaded, keep empty or do not provide if you want to load all core segments
         * @param addNonExistingCoreSegments (not yet supported)
         * @param amountOfSnapshotsPerSegmentToLoad amount of snapshots loaded (per core segment); is the same for all core segments
         * 
         * @return bool true if everything worked fine, false if some error arose permitting the LTM to be loaded
         */
        bool loadExportIntoWM(const std::string& export_path,
                              const std::string& memoryName,
                              const std::vector<std::string>& coreSegmentName = {},
                              bool addNonExistingCoreSegments = false,
                              int amountOfSnapshotsPerSegmentToLoad = -1,
                              const ::Ice::Current& = Ice::emptyCurrent) override;
 
        /**
         * @brief loads data from a specified LTM export into the currently running WM (needs to already have the CoreSegments)
         * 
         * This function loads an LTM specified by directory, exportName and memoryName into the current WM.
         * It handles if the path is not a correct LTM export.
         * If you do this multiple times the LTM is always appended to the WM ,meaning you can load several LTM exports into the same WM.
         * This does not exclude the maxHistory size from working! If you load to much snapshots they will still be discarded.
         * 
         * @param directory path (as string) to the export directory
         * @param exportName name of the export folder (often 'MemoryExport')
         * @param memoryName name of the memory server (e.g. 'Object', 'Skill')
         * @param coreSegmentNames list (std::vector) of names of core segments which should be loaded, keep empty or do not provide if you want to load all core segments
         * @param addNonExistingCoreSegments (not yet supported)
         * @param amountOfSnapshotsPerSegmentToLoad amount of snapshots loaded (per core segment); is the same for all core segments
         * 
         * @return bool true if everything worked fine, false if some error arose permitting the LTM to be loaded
         */
        bool loadExportIntoWM(const std::string& directory,
                              const std::string& exportName,
                              const std::string& memoryName,
                              const std::vector<std::string>& coreSegmentName = {},
                              bool addNonExistingCoreSegments = false,
                              int amountOfSnapshotsPerSegmentToLoad = -1);
 
        /**
         * @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;
}