LongtermMemory.cpp

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::LongtermMemory
* @author     Alexey Kozlov ( kozlov at kit dot edu)
* @date       2012
* @copyright  http://www.gnu.org/licenses/gpl-2.0.txt
*             GNU General Public License
*/
 
// core
#include "LongtermMemory.h"
 
#include <ArmarXCore/core/util/StringHelpers.h>
#include <ArmarXCore/libraries/DecoupledSingleComponent/Decoupled.h>
 
#include "../../libraries/longtermmemory/WorkingMemorySnapshotListSegment.h"
#include "../../libraries/memorytypes/segment/KBMSegment.h"
#include "../../libraries/memorytypes/segment/OacMemorySegment.h"
#include "../../libraries/memorytypes/segment/PersistentDMPDataSegment.h"
#include "../../libraries/memorytypes/segment/PersistentObjectClassSegment.h"
#include "../../libraries/memorytypes/segment/PersistentObjectInstanceSegment.h"
#include "../../libraries/memorytypes/segment/PersistentPredictionDataSegment.h"
#include "../../libraries/memorytypes/segment/PersistentProfilerDataSegment.h"
#include "../../libraries/memorytypes/segment/PersistentResourceProfileSegment.h"
#include <MemoryX/interface/core/EntityBase.h>
#include <MemoryX/interface/memorytypes/MemoryEntities.h>
 
namespace memoryx
{
    std::string
    LongtermMemory::getDefaultName() const
    {
        return "LongtermMemory";
    }
 
    std::string
    LongtermMemory::GetDefaultName()
    {
        return "LongtermMemory";
    }
 
    void
    LongtermMemory::onInitLongtermMemory()
    {
        usingProxy("PriorKnowledge");
 
        const std::string clsCollNamesStr = getProperty<std::string>("ClassCollections").getValue();
        classCollNames = armarx::Split(clsCollNamesStr, ",");
    }
 
    void
    LongtermMemory::onConnectLongtermMemory()
    {
        ARMARX_INFO << "connecting long term memory";
        priorKnowledgePrx = getProxy<PriorKnowledgeInterfacePrx>("PriorKnowledge");
        const std::string snaplistCollectionName =
            getProperty<std::string>("SnapshotListCollection").getValue();
        const std::string oacCollectionName = getProperty<std::string>("OacCollection").getValue();
        const std::string kbmCollectionName = getProperty<std::string>("KbmCollection").getValue();
        const std::string dmpCollectionName = getProperty<std::string>("DmpCollection").getValue();
        const std::string profilerCollectionName =
            getProperty<std::string>("ProfilerDataCollection").getValue();
        const std::string resourceProfileCollectionName =
            getProperty<std::string>("ResourceProfileCollection").getValue();
        const std::string predictionDataCollectionName =
            getProperty<std::string>("PredictionDataCollection").getValue();
        const std::string selfLocalisationCollectionName =
            getProperty<std::string>("SelfLocalisationCollection").getValue();
 
        databaseInterfacePrx = storagePrx->requestDatabase(dbName);
 
        CollectionInterfacePrx snapshotListCollection =
            databaseInterfacePrx->requestCollection(snaplistCollectionName);
        CollectionInterfacePrx oacCollection =
            databaseInterfacePrx->requestCollection(oacCollectionName);
        CollectionInterfacePrx kbmCollection =
            databaseInterfacePrx->requestCollection(kbmCollectionName);
        CollectionInterfacePrx dmpCollection =
            databaseInterfacePrx->requestCollection(dmpCollectionName);
 
        WorkingMemorySnapshotListSegmentPtr snapshotListSegment =
            new WorkingMemorySnapshotListSegment(databaseInterfacePrx, snapshotListCollection, ic);
        addSegment(LTM::SegmentNames::SNAPSHOTS, snapshotListSegment);
 
        OacMemorySegmentPtr oacSegment =
            new OacMemorySegment(priorKnowledgePrx->getObjectClassesSegment(), oacCollection, ic);
        addSegment(LTM::SegmentNames::OACS, oacSegment);
 
        PersistentEntitySegmentBasePtr kbmSegment = new KBMSegment(kbmCollection, ic);
        addSegment(LTM::SegmentNames::KBM, kbmSegment);
 
        CollectionInterfacePrx profilerCollection =
            databaseInterfacePrx->requestCollection(profilerCollectionName);
        addSegment(LTM::SegmentNames::PROFILER,
                   new PersistentProfilerDataSegment(profilerCollection, ic));
 
        CollectionInterfacePrx resourceProfileCollection =
            databaseInterfacePrx->requestCollection(resourceProfileCollectionName);
        addSegment(LTM::SegmentNames::RESOURCE_PROFILES,
                   new PersistentResourceProfileSegment(resourceProfileCollection, ic));
 
        CollectionInterfacePrx predictionDataCollection =
            databaseInterfacePrx->requestCollection(predictionDataCollectionName);
        addSegment(LTM::SegmentNames::PREDICTION_DATA,
                   new PersistentPredictionDataSegment(predictionDataCollection, ic));
 
        CollectionInterfacePrx classColl = storagePrx->requestCollection(classCollNames[0]);
        PersistentObjectClassSegmentPtr classesSegment =
            new PersistentObjectClassSegment(classColl, ic);
        addSegment(LTM::SegmentNames::OBJECTCLASSES, classesSegment);
 
        PersistentDMPDataSegmentPtr dmpSegment = new PersistentDMPDataSegment(dmpCollection, ic);
        addSegment(LTM::SegmentNames::DMP, dmpSegment);
 
        CollectionInterfacePrx selfLocalisationCollection =
            databaseInterfacePrx->requestCollection(selfLocalisationCollectionName);
        PersistentEntitySegmentPtr selfLocalisationSegment =
            new PersistentEntitySegment(selfLocalisationCollection, ic);
        addSegment(LTM::SegmentNames::SELF_LOCALISATION, selfLocalisationSegment);
 
        ARMARX_INFO << "successfully connected long term memory";
    }
 
    WorkingMemorySnapshotListSegmentBasePrx
    LongtermMemory::getWorkingMemorySnapshotListSegment(const ::Ice::Current& c)
    {
        return WorkingMemorySnapshotListSegmentBasePrx::uncheckedCast(
            getSegment(LTM::SegmentNames::SNAPSHOTS, c));
    }
 
    PersistentObjectInstanceSegmentBasePrx
    LongtermMemory::getCustomInstancesSegment(const std::string& segmentName,
                                              bool createIfMissing,
                                              const ::Ice::Current& c)
    {
        if (hasSegment(segmentName))
        {
            return PersistentObjectInstanceSegmentBasePrx::uncheckedCast(
                getSegment(segmentName, c));
        }
        else if (createIfMissing)
        {
            PersistentObjectInstanceSegmentPtr customSegment = new PersistentObjectInstanceSegment(
                databaseInterfacePrx->requestCollection(segmentName), ic);
            return PersistentObjectInstanceSegmentBasePrx::uncheckedCast(
                addSegment(segmentName, customSegment, c));
        }
        else
        {
            return PersistentObjectInstanceSegmentBasePrx();
        }
    }
 
    void
    LongtermMemory::loadWorkingMemorySnapshot(
        const std::string& snapshotName,
        const AbstractWorkingMemoryInterfacePrx& workingMemory,
        const ::Ice::Current&)
    {
        WorkingMemorySnapshotListSegmentBasePrx snapshotListSegment =
            getWorkingMemorySnapshotListSegment();
 
        if (snapshotListSegment)
        {
            snapshotListSegment->loadSnapshot(snapshotName, workingMemory);
        }
    }
 
    bool
    LongtermMemory::saveWorkingMemorySnapshot(
        const std::string& snapshotName,
        const AbstractWorkingMemoryInterfacePrx& workingMemory,
        const ::Ice::Current&)
    {
        WorkingMemorySnapshotListSegmentBasePrx snapshotListSegment =
            getWorkingMemorySnapshotListSegment();
 
        if (snapshotListSegment)
        {
            return snapshotListSegment->createSnapshot(snapshotName, workingMemory);
        }
        else
        {
            return false;
        }
    }
 
    WorkingMemorySnapshotInterfacePrx
    LongtermMemory::openWorkingMemorySnapshot(const std::string& snapshotName,
                                              const ::Ice::Current&)
    {
        WorkingMemorySnapshotListSegmentBasePrx snapshotListSegment =
            getWorkingMemorySnapshotListSegment();
 
        if (snapshotListSegment)
        {
            return snapshotListSegment->openSnapshot(snapshotName);
        }
        else
        {
            return WorkingMemorySnapshotInterfacePrx();
        }
    }
 
    bool
    LongtermMemory::removeWorkingMemorySnapshot(const std::string& snapshotName,
                                                const ::Ice::Current&)
    {
        WorkingMemorySnapshotListSegmentBasePrx snapshotListSegment =
            getWorkingMemorySnapshotListSegment();
 
        if (snapshotListSegment)
        {
            return snapshotListSegment->removeSnapshot(snapshotName);
        }
        else
        {
            return false;
        }
    }
 
    NameList
    LongtermMemory::getSnapshotNames(const ::Ice::Current& c)
    {
        WorkingMemorySnapshotListSegmentBasePrx snapshotListSegment =
            getWorkingMemorySnapshotListSegment();
 
        if (snapshotListSegment)
        {
            return snapshotListSegment->getSnapshotNames();
        }
        else
        {
            throw SnapshotNotFoundException("Snapshot segment not found!", "");
        }
    }
 
    std::string
    LongtermMemory::getMemoryName(const Ice::Current&) const
    {
        return getName();
    }
 
    PersistentProfilerDataSegmentBasePrx
    LongtermMemory::getProfilerDataSegment(const Ice::Current& c)
    {
        return PersistentProfilerDataSegmentBasePrx::uncheckedCast(
            getSegment(LTM::SegmentNames::PROFILER, c));
    }
 
    PersistentPredictionDataSegmentBasePrx
    LongtermMemory::getPredictionDataSegment(const Ice::Current& c)
    {
        return PersistentPredictionDataSegmentBasePrx::uncheckedCast(
            getSegment(LTM::SegmentNames::PREDICTION_DATA, c));
    }
 
    PersistentResourceProfileSegmentBasePrx
    LongtermMemory::getResourceProfileSegment(const Ice::Current& c)
    {
        return PersistentResourceProfileSegmentBasePrx::uncheckedCast(
            getSegment(LTM::SegmentNames::RESOURCE_PROFILES, c));
    }
 
    OacMemorySegmentBasePrx
    LongtermMemory::getOacSegment(const ::Ice::Current& c)
    {
        return OacMemorySegmentBasePrx::uncheckedCast(getSegment(LTM::SegmentNames::OACS, c));
    }
 
    KBMSegmentBasePrx
    LongtermMemory::getKBMSegment(const Ice::Current& c)
    {
        return KBMSegmentBasePrx::uncheckedCast(getSegment(LTM::SegmentNames::KBM, c));
    }
 
    CommonStorageInterfacePrx
    LongtermMemory::getCommonStorage(const ::Ice::Current&) const
    {
        return storagePrx;
    }
 
    PersistentObjectClassSegmentBasePrx
    LongtermMemory::getObjectClassesSegment(const ::Ice::Current& c) const
    {
        return PersistentObjectClassSegmentBasePrx::uncheckedCast(
            getSegment(LTM::SegmentNames::OBJECTCLASSES, c));
    }
 
    PersistentDMPDataSegmentBasePrx
    LongtermMemory::getDMPSegment(const Ice::Current& c)
    {
        return PersistentDMPDataSegmentBasePrx::uncheckedCast(
            getSegment(LTM::SegmentNames::DMP, c));
    }
 
    PersistentEntitySegmentBasePrx
    memoryx::LongtermMemory::getSelfLocalisationSegment(const Ice::Current& c)
    {
        return PersistentEntitySegmentBasePrx::uncheckedCast(
            getSegment(LTM::SegmentNames::SELF_LOCALISATION, c));
    }
 
    AbstractMemorySegmentPrx
    memoryx::LongtermMemory::addGenericSegment(const std::string& segmentName, const Ice::Current&)
    {
        PersistentEntitySegmentPtr segment =
            new PersistentEntitySegment(databaseInterfacePrx->requestCollection(segmentName),
                                        getIceManager()->getCommunicator());
        return addSegment(segmentName, segment);
    }
} // namespace memoryx
 
ARMARX_REGISTER_COMPONENT_EXECUTABLE(::memoryx::LongtermMemory,
                                     ::memoryx::LongtermMemory::GetDefaultName());