Loader.h

Go to the documentation of this file.

#pragma once
 
#include <RobotAPI/interface/armem/server/LoadingMemoryInterface.h>
 
namespace armarx::armem::client
{
 
    /**
     * @brief Load LTMs into WM
     */
    class Loader
    {
 
    public:
        /**
         * @brief Construct a memory reader.
         * @param memory The memory proxy.
         */
        Loader(const Loader&) = default;
 
        Loader(server::LoadingMemoryInterfacePrx loadingMemory = nullptr) :
            loadingPrx(loadingMemory)
        {
        }
 
        /**
         * Loads all entries of potential multiple ltms into the wm (i.e. if a RedundantPersistenceStrategy is used with multiple strategies inside)
         */
        void loadLTMintoWM(bool complete = true);
 
        /**
         * @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 coreSegmentName (not yet supported)
         * @param addNonExistingCoreSegments (not yet supported)
         * @param amountOfSnapshotsPerSegmentToLoad (not yet supported)
         * 
         * @return bool true if everything worked fine, false if some error arose permitting the LTM to be loaded
         */
        bool loadExportIntoWM(std::string export_path,
                              std::string memoryName,
                              std::vector<std::string> coreSegmentNames,
                              bool addNonExistingCoreSegments,
                              int amountOfSnapshotsPerSegmentToLoad);
 
        void setLoadingMemory(server::LoadingMemoryInterfacePrx configuringMemory);
 
        inline operator bool() const
        {
            return bool(loadingPrx);
        }
 
    private:
    public:
        server::LoadingMemoryInterfacePrx loadingPrx;
    };
 
} // namespace armarx::armem::client