Skip to content
Snippets Groups Projects
Commit 593bd2d4 authored by armar-user's avatar armar-user
Browse files

Revert "add locking commit method for memory interface" 

This reverts commit 18db5c8a.
parent db22944f
No related branches found
No related tags found
No related merge requests found
Hide whitespace changes
Inline Side-by-side
Showing
with 149 additions and 193 deletions
source/RobotAPI/interface/armem/server/WritingMemoryInterface.ice
+ 0
− 3
View file @ 593bd2d4
......@@ -19,9 +19,6 @@ module armarx
/// Commit data to the memory.
data::CommitResult commit(data::Commit commit);
/// Commit data to the memory and ensure locking.
data::CommitResult commitLocking(data::Commit commit);
};
};
};
......
source/RobotAPI/libraries/armem/server/MemoryToIceAdapter.cpp
+ 65
− 80
View file @ 593bd2d4
#include "MemoryToIceAdapter.h"
#include <ArmarXCore/core/exceptions/local/ExpressionException.h>
#include <ArmarXCore/core/ice_conversions/ice_conversions_templates.h>
#include <ArmarXCore/core/logging/Logging.h>
#include <ArmarXCore/core/time/ice_conversions.h>
#include "query_proc/wm/wm.h"
#include "query_proc/ltm/disk/ltm.h"
#include <RobotAPI/libraries/armem/client/query/Builder.h>
#include <RobotAPI/libraries/aron/core/Exception.h>
#include <RobotAPI/libraries/armem/core/error.h>
#include <RobotAPI/libraries/armem/core/ice_conversions.h>
#include <RobotAPI/libraries/armem/core/wm/ice_conversions.h>
#include <RobotAPI/libraries/armem/client/query/Builder.h>
#include <RobotAPI/libraries/armem/server/wm/ice_conversions.h>
#include <RobotAPI/libraries/aron/core/Exception.h>
#include "query_proc/ltm/disk/ltm.h"
#include "query_proc/wm/wm.h"
#include <ArmarXCore/core/exceptions/local/ExpressionException.h>
#include <ArmarXCore/core/ice_conversions/ice_conversions_templates.h>
#include <ArmarXCore/core/logging/Logging.h>
#include <ArmarXCore/core/time/ice_conversions.h>
namespace armarx::armem::server
{
MemoryToIceAdapter::MemoryToIceAdapter(wm::Memory* workingMemory,
server::ltm::disk::Memory* longtermMemory) :
MemoryToIceAdapter::MemoryToIceAdapter(wm::Memory* workingMemory, server::ltm::disk::Memory* longtermMemory) :
workingMemory(workingMemory), longtermMemory(longtermMemory)
{
}
void
MemoryToIceAdapter::setMemoryListener(client::MemoryListenerInterfacePrx memoryListener)
{
this->memoryListenerTopic = memoryListener;
}
// WRITING
data::AddSegmentResult
MemoryToIceAdapter::addSegment(const data::AddSegmentInput& input, bool addCoreSegments)
......@@ -61,24 +64,22 @@ namespace armarx::armem::server
if (input.providerSegmentName.size() > 0)
{
coreSegment->doLocked(
[&coreSegment, &input]()
coreSegment->doLocked([&coreSegment, &input]()
{
try
{
try
{
coreSegment->addProviderSegment(input.providerSegmentName);
}
catch (const armem::error::ContainerEntryAlreadyExists&)
coreSegment->addProviderSegment(input.providerSegmentName);
}
catch (const armem::error::ContainerEntryAlreadyExists&)
{
// This is ok.
if (input.clearWhenExists)
{
// This is ok.
if (input.clearWhenExists)
{
server::wm::ProviderSegment& provider =
coreSegment->getProviderSegment(input.providerSegmentName);
provider.clear();
}
server::wm::ProviderSegment& provider = coreSegment->getProviderSegment(input.providerSegmentName);
provider.clear();
}
});
}
});
}
armem::MemoryID segmentID;
......@@ -91,6 +92,7 @@ namespace armarx::armem::server
return output;
}
data::AddSegmentsResult
MemoryToIceAdapter::addSegments(const data::AddSegmentsInput& input, bool addCoreSegments)
{
......@@ -105,12 +107,13 @@ namespace armarx::armem::server
return output;
}
data::CommitResult
MemoryToIceAdapter::commit(const data::Commit& commitIce, Time timeArrived, bool locking)
MemoryToIceAdapter::commit(const data::Commit& commitIce, Time timeArrived)
{
ARMARX_TRACE;
ARMARX_CHECK_NOT_NULL(workingMemory);
auto handleException = [](const std::string& what)
auto handleException = [](const std::string & what)
{
data::CommitResult result;
data::EntityUpdateResult& r = result.results.emplace_back();
......@@ -135,47 +138,38 @@ namespace armarx::armem::server
return handleException(e.what());
}
armem::CommitResult result = this->commit(commit, locking);
armem::CommitResult result = this->commit(commit);
data::CommitResult resultIce;
toIce(resultIce, result);
return resultIce;
}
data::CommitResult
MemoryToIceAdapter::commit(const data::Commit& commitIce, bool locking)
MemoryToIceAdapter::commit(const data::Commit& commitIce)
{
ARMARX_TRACE;
return commit(commitIce, armem::Time::Now(), locking);
return commit(commitIce, armem::Time::Now());
}
armem::CommitResult
MemoryToIceAdapter::commit(const armem::Commit& commit, bool locking)
MemoryToIceAdapter::commit(const armem::Commit& commit)
{
ARMARX_TRACE;
return this->_commit(commit, locking);
return this->_commit(commit, false);
}
data::CommitResult
MemoryToIceAdapter::commitLocking(const data::Commit& commitIce, Time timeArrived)
{
return this->commit(commitIce, timeArrived, true);
}
data::CommitResult
MemoryToIceAdapter::commitLocking(const data::Commit& commit)
armem::CommitResult MemoryToIceAdapter::commitLocking(const armem::Commit& commit)
{
return this->commit(commit, true);
ARMARX_TRACE;
return this->_commit(commit, true);
}
armem::CommitResult
MemoryToIceAdapter::commitLocking(const armem::Commit& commit)
{
return this->commit(commit, true);
}
armem::CommitResult
MemoryToIceAdapter::_commit(const armem::Commit& commit, bool locking)
armem::CommitResult MemoryToIceAdapter::_commit(const armem::Commit& commit, bool locking)
{
ARMARX_TRACE;
std::vector<data::MemoryID> updatedIDs;
......@@ -187,8 +181,9 @@ namespace armarx::armem::server
EntityUpdateResult& result = commitResult.results.emplace_back();
try
{
auto updateResult =
locking ? workingMemory->updateLocking(update) : workingMemory->update(update);
auto updateResult = locking
? workingMemory->updateLocking(update)
: workingMemory->update(update);
result.success = true;
result.snapshotID = updateResult.id;
......@@ -264,6 +259,7 @@ namespace armarx::armem::server
return commitResult;
}
// READING
armem::query::data::Result
MemoryToIceAdapter::query(const armem::query::data::Input& input)
......@@ -273,8 +269,7 @@ namespace armarx::armem::server
ARMARX_CHECK_NOT_NULL(longtermMemory);
// Core segment processors will aquire the core segment locks.
query_proc::wm_server::MemoryQueryProcessor wmServerProcessor(
armem::query::boolToDataMode(input.withData));
query_proc::wm_server::MemoryQueryProcessor wmServerProcessor(armem::query::boolToDataMode(input.withData));
armem::wm::Memory wmResult = wmServerProcessor.process(input, *workingMemory);
armem::query::data::Result result;
......@@ -324,15 +319,14 @@ namespace armarx::armem::server
return result;
}
client::QueryResult
MemoryToIceAdapter::query(const client::QueryInput& input)
client::QueryResult MemoryToIceAdapter::query(const client::QueryInput& input)
{
ARMARX_TRACE;
return client::QueryResult::fromIce(query(input.toIce()));
}
armem::structure::data::GetServerStructureResult
MemoryToIceAdapter::getServerStructure()
armem::structure::data::GetServerStructureResult MemoryToIceAdapter::getServerStructure()
{
ARMARX_TRACE;
ARMARX_CHECK_NOT_NULL(workingMemory);
......@@ -361,11 +355,11 @@ namespace armarx::armem::server
return ret;
}
// LTM LOADING FROM LTM
// LTM STORING AND RECORDING
dto::DirectlyStoreResult
MemoryToIceAdapter::directlyStore(const dto::DirectlyStoreInput& directlStoreInput)
dto::DirectlyStoreResult MemoryToIceAdapter::directlyStore(const dto::DirectlyStoreInput& directlStoreInput)
{
ARMARX_TRACE;
ARMARX_CHECK_NOT_NULL(longtermMemory);
......@@ -379,8 +373,7 @@ namespace armarx::armem::server
return output;
}
dto::StartRecordResult
MemoryToIceAdapter::startRecord(const dto::StartRecordInput& startRecordInput)
dto::StartRecordResult MemoryToIceAdapter::startRecord(const dto::StartRecordInput& startRecordInput)
{
ARMARX_TRACE;
ARMARX_CHECK_NOT_NULL(longtermMemory);
......@@ -393,8 +386,7 @@ namespace armarx::armem::server
return ret;
}
dto::StopRecordResult
MemoryToIceAdapter::stopRecord()
dto::StopRecordResult MemoryToIceAdapter::stopRecord()
{
ARMARX_TRACE;
ARMARX_CHECK_NOT_NULL(longtermMemory);
......@@ -407,30 +399,24 @@ namespace armarx::armem::server
return ret;
}
dto::RecordStatusResult
MemoryToIceAdapter::getRecordStatus()
dto::RecordStatusResult MemoryToIceAdapter::getRecordStatus()
{
dto::RecordStatusResult ret;
ret.success = true;
long savedSnapshots;
long totalSnapshots;
longtermMemory->forEachCoreSegment(
[&savedSnapshots, &totalSnapshots](const auto& c)
{
c.forEachProviderSegment(
[&savedSnapshots, &totalSnapshots](const auto& p)
{
p.forEachEntity(
[&savedSnapshots, &totalSnapshots](const auto& e)
{
savedSnapshots += e.getStatistics().recordedSnapshots;
e.forEachSnapshot([&totalSnapshots](const auto&)
{ totalSnapshots++; });
});
longtermMemory->forEachCoreSegment([&savedSnapshots, &totalSnapshots](const auto& c){
c.forEachProviderSegment([&savedSnapshots, &totalSnapshots](const auto& p){
p.forEachEntity([&savedSnapshots, &totalSnapshots](const auto& e){
savedSnapshots += e.getStatistics().recordedSnapshots;
e.forEachSnapshot([&totalSnapshots](const auto&){
totalSnapshots++;
});
});
});
});
ret.status.savedSnapshots = savedSnapshots;
ret.status.totalSnapshots = totalSnapshots;
......@@ -447,8 +433,7 @@ namespace armarx::armem::server
return armarx::toIce<prediction::data::PredictionResultSeq>(res);
}
prediction::data::EngineSupportMap
MemoryToIceAdapter::getAvailableEngines()
prediction::data::EngineSupportMap MemoryToIceAdapter::getAvailableEngines()
{
prediction::data::EngineSupportMap result;
armarx::toIce(result, workingMemory->getAllPredictionEngines());
......@@ -477,4 +462,4 @@ namespace armarx::armem::server
return result;
}
} // namespace armarx::armem::server
}
source/RobotAPI/libraries/armem/server/MemoryToIceAdapter.h
+ 16
− 14
View file @ 593bd2d4
#pragma once
#include <RobotAPI/interface/armem/client/MemoryListenerInterface.h>
#include <RobotAPI/interface/armem/server/MemoryInterface.h>
#include <RobotAPI/libraries/armem/client/Query.h>
#include <RobotAPI/interface/armem/client/MemoryListenerInterface.h>
#include <RobotAPI/libraries/armem/core/wm/memory_definitions.h>
#include <RobotAPI/libraries/armem/server/ltm/disk/Memory.h>
#include <RobotAPI/libraries/armem/client/Query.h>
#include <RobotAPI/libraries/armem/server/wm/memory_definitions.h>
namespace armarx::armem::server
{
......@@ -19,6 +21,7 @@ namespace armarx::armem::server
class MemoryToIceAdapter
{
public:
/// Construct an MemoryToIceAdapter from an existing Memory.
MemoryToIceAdapter(server::wm::Memory* workingMemory = nullptr,
server::ltm::disk::Memory* longtermMemory = nullptr);
......@@ -27,20 +30,16 @@ namespace armarx::armem::server
// WRITING
data::AddSegmentResult addSegment(const data::AddSegmentInput& input,
bool addCoreSegments = false);
data::AddSegmentsResult addSegments(const data::AddSegmentsInput& input,
bool addCoreSegments = false);
data::AddSegmentResult addSegment(
const data::AddSegmentInput& input, bool addCoreSegments = false);
data::AddSegmentsResult addSegments(
const data::AddSegmentsInput& input, bool addCoreSegments = false);
data::CommitResult
commit(const data::Commit& commitIce, Time timeArrived, bool locking = false);
data::CommitResult commit(const data::Commit& commitIce, bool locking = false);
armem::CommitResult commit(const armem::Commit& commit, bool locking = false);
data::CommitResult commitLocking(const data::Commit& commitIce, Time timeArrived);
data::CommitResult commitLocking(const data::Commit& commit);
data::CommitResult commit(const data::Commit& commitIce, Time timeArrived);
data::CommitResult commit(const data::Commit& commitIce);
armem::CommitResult commit(const armem::Commit& commit);
armem::CommitResult commitLocking(const armem::Commit& commit);
......@@ -64,6 +63,7 @@ namespace armarx::armem::server
prediction::data::EngineSupportMap getAvailableEngines();
public:
server::wm::Memory* workingMemory;
server::ltm::disk::Memory* longtermMemory;
......@@ -71,8 +71,10 @@ namespace armarx::armem::server
private:
armem::CommitResult _commit(const armem::Commit& commit, bool locking);
};
} // namespace armarx::armem::server
}
source/RobotAPI/libraries/armem/server/plugins/ReadWritePluginUser.cpp
+ 37
− 50
View file @ 593bd2d4
#include "ReadWritePluginUser.h"
#include "Plugin.h"
#include <RobotAPI/libraries/armem/core/error.h>
#include <RobotAPI/libraries/armem/core/Prediction.h>
#include <RobotAPI/libraries/armem/server/MemoryToIceAdapter.h>
#include <ArmarXCore/core/Component.h>
#include <ArmarXCore/core/exceptions/local/ExpressionException.h>
#include <RobotAPI/libraries/armem/core/Prediction.h>
#include <RobotAPI/libraries/armem/core/error.h>
#include <RobotAPI/libraries/armem/server/MemoryToIceAdapter.h>
#include "Plugin.h"
namespace armarx::armem::server::plugins
{
......@@ -17,140 +18,126 @@ namespace armarx::armem::server::plugins
addPlugin(plugin);
}
ReadWritePluginUser::~ReadWritePluginUser()
{
}
void
ReadWritePluginUser::setMemoryName(const std::string& memoryName)
void ReadWritePluginUser::setMemoryName(const std::string& memoryName)
{
plugin->setMemoryName(memoryName);
}
// WRITING
data::AddSegmentsResult
ReadWritePluginUser::addSegments(const data::AddSegmentsInput& input, const Ice::Current&)
data::AddSegmentsResult ReadWritePluginUser::addSegments(const data::AddSegmentsInput& input, const Ice::Current&)
{
ARMARX_TRACE;
bool addCoreSegmentOnUsage = false;
return addSegments(input, addCoreSegmentOnUsage);
}
data::AddSegmentsResult
ReadWritePluginUser::addSegments(const data::AddSegmentsInput& input, bool addCoreSegments)
data::AddSegmentsResult ReadWritePluginUser::addSegments(const data::AddSegmentsInput& input, bool addCoreSegments)
{
ARMARX_TRACE;
data::AddSegmentsResult result = iceAdapter().addSegments(input, addCoreSegments);
return result;
}
data::CommitResult
ReadWritePluginUser::commit(const data::Commit& commitIce, const Ice::Current&)
data::CommitResult ReadWritePluginUser::commit(const data::Commit& commitIce, const Ice::Current&)
{
ARMARX_TRACE;
return iceAdapter().commit(commitIce);
}
data::CommitResult
ReadWritePluginUser::commitLocking(const data::Commit& commitIce, const Ice::Current&)
{
ARMARX_TRACE;
return iceAdapter().commitLocking(commitIce);
}
// READING
armem::query::data::Result
ReadWritePluginUser::query(const armem::query::data::Input& input, const Ice::Current&)
armem::query::data::Result ReadWritePluginUser::query(const armem::query::data::Input& input, const Ice::Current&)
{
ARMARX_TRACE;
return iceAdapter().query(input);
}
structure::data::GetServerStructureResult
ReadWritePluginUser::getServerStructure(const Ice::Current&)
structure::data::GetServerStructureResult ReadWritePluginUser::getServerStructure(const Ice::Current&)
{
ARMARX_TRACE;
return iceAdapter().getServerStructure();
}
// LTM STORING AND RECORDING
dto::DirectlyStoreResult
ReadWritePluginUser::directlyStore(const dto::DirectlyStoreInput& input, const Ice::Current&)
dto::DirectlyStoreResult ReadWritePluginUser::directlyStore(const dto::DirectlyStoreInput& input, const Ice::Current&)
{
ARMARX_TRACE;
return iceAdapter().directlyStore(input);
}
dto::StartRecordResult
ReadWritePluginUser::startRecord(const dto::StartRecordInput& startRecordInput,
const Ice::Current&)
dto::StartRecordResult ReadWritePluginUser::startRecord(const dto::StartRecordInput& startRecordInput, const Ice::Current&)
{
ARMARX_TRACE;
return iceAdapter().startRecord(startRecordInput);
}
dto::StopRecordResult
ReadWritePluginUser::stopRecord(const Ice::Current&)
dto::StopRecordResult ReadWritePluginUser::stopRecord(const Ice::Current&)
{
ARMARX_TRACE;
return iceAdapter().stopRecord();
}
dto::RecordStatusResult
ReadWritePluginUser::getRecordStatus(const Ice::Current&)
dto::RecordStatusResult ReadWritePluginUser::getRecordStatus(const Ice::Current&)
{
ARMARX_TRACE;
return iceAdapter().getRecordStatus();
}
Plugin&
ReadWritePluginUser::memoryServerPlugin()
Plugin& ReadWritePluginUser::memoryServerPlugin()
{
return *plugin;
}
wm::Memory&
ReadWritePluginUser::workingMemory()
wm::Memory& ReadWritePluginUser::workingMemory()
{
return plugin->workingMemory;
}
MemoryToIceAdapter&
ReadWritePluginUser::iceAdapter()
MemoryToIceAdapter& ReadWritePluginUser::iceAdapter()
{
return plugin->iceAdapter;
}
ltm::disk::Memory&
ReadWritePluginUser::longtermMemory()
ltm::disk::Memory& ReadWritePluginUser::longtermMemory()
{
return plugin->longtermMemory;
}
// ACTIONS
armem::actions::GetActionsOutputSeq
ReadWritePluginUser::getActions(const armem::actions::GetActionsInputSeq& inputs,
const ::Ice::Current& /*unused*/)
armem::actions::GetActionsOutputSeq ReadWritePluginUser::getActions(
const armem::actions::GetActionsInputSeq& inputs, const ::Ice::Current& /*unused*/)
{
return getActions(inputs);
}
armem::actions::GetActionsOutputSeq
ReadWritePluginUser::getActions(const armem::actions::GetActionsInputSeq& inputs)
armem::actions::GetActionsOutputSeq ReadWritePluginUser::getActions(
const armem::actions::GetActionsInputSeq& inputs)
{
(void)inputs;
(void) inputs;
return {};
}
armem::actions::ExecuteActionOutputSeq
ReadWritePluginUser::executeActions(const armem::actions::ExecuteActionInputSeq& inputs,
const ::Ice::Current& /*unused*/)
armem::actions::ExecuteActionOutputSeq ReadWritePluginUser::executeActions(
const armem::actions::ExecuteActionInputSeq& inputs, const ::Ice::Current& /*unused*/)
{
return executeActions(inputs);
}
armem::actions::ExecuteActionOutputSeq
ReadWritePluginUser::executeActions(const armem::actions::ExecuteActionInputSeq& inputs)
armem::actions::ExecuteActionOutputSeq ReadWritePluginUser::executeActions(
const armem::actions::ExecuteActionInputSeq& inputs)
{
return {};
}
......
source/RobotAPI/libraries/armem/server/plugins/ReadWritePluginUser.h
+ 31
− 46
View file @ 593bd2d4
#pragma once
#include <ArmarXCore/core/ManagedIceObject.h>
#include <RobotAPI/libraries/armem/server/forward_declarations.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>
#include <RobotAPI/interface/armem/server/MemoryInterface.h>
#include <ArmarXCore/core/ManagedIceObject.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
virtual public ManagedIceObject
, virtual public MemoryInterface
, virtual public client::plugins::ListeningPluginUser
{
public:
ReadWritePluginUser();
virtual ~ReadWritePluginUser() override;
......@@ -31,65 +35,43 @@ namespace armarx::armem::server::plugins
// 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::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;
virtual data::CommitResult commitLocking(const data::Commit& commit,
const Ice::Current& = Ice::emptyCurrent) override;
virtual data::CommitResult commit(const data::Commit& commit, 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;
virtual armem::structure::data::GetServerStructureResult
getServerStructure(const Ice::Current& = Ice::emptyCurrent) override;
virtual armem::query::data::Result query(const armem::query::data::Input& input, 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::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;
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;
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);
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;
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;
public:
Plugin& memoryServerPlugin();
server::wm::Memory& workingMemory();
......@@ -99,12 +81,15 @@ namespace armarx::armem::server::plugins
private:
plugins::Plugin* plugin = nullptr;
};
} // namespace armarx::armem::server::plugins
}
namespace armarx::armem::server
{
using plugins::ReadWritePluginUser;
}
0% or .
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment