TaskOutcomeWriter.cpp

Go to the documentation of this file.

#include "TaskOutcomeWriter.h"
 
#include <ArmarXCore/core/logging/Logging.h>
 
#include <RobotAPI/libraries/armem/client/Writer.h>
#include <RobotAPI/libraries/armem/core/Commit.h>
 
#include <RobotAPI/libraries/armem_task_outcome/aron/TaskOutcome.aron.generated.h>
#include <RobotAPI/libraries/armem_task_outcome/aron_conversions.h>
#include <RobotAPI/libraries/armem_task_outcome/memory_ids.h>
 
namespace armarx::armem::task_outcome::client
{
 
    TaskOutcomeWriter::TaskOutcomeWriter() : armem::client::util::SimpleWriterBase()
    {
    }
 
    TaskOutcomeWriter::~TaskOutcomeWriter() = default;
 
    void
    TaskOutcomeWriter::registerPropertyDefinitions(armarx::PropertyDefinitionsPtr& def)
    {
        armem::client::util::SimpleWriterBase::registerPropertyDefinitions(def);
    }
 
    void
    TaskOutcomeWriter::connect(armem::client::MemoryNameSystem& memoryNameSystem)
    {
        ARMARX_VERBOSE << "Connecting TaskOutcomeWriter ...";
        armem::client::util::SimpleWriterBase::connect(memoryNameSystem);
        ARMARX_VERBOSE << "TaskOutcomeWriter connected.";
    }
 
    bool
    TaskOutcomeWriter::commitTaskOutcome(const TaskOutcome& outcome,
                                         const std::string& provider,
                                         const armem::Time& referencedTime)
    {
        return this->commitTaskOutcomes({outcome}, provider, referencedTime);
    }
 
    bool
    TaskOutcomeWriter::commitTaskOutcomes(const std::vector<TaskOutcome>& outcomes,
                                          const std::string& provider,
                                          const armem::Time& referencedTime)
    {
        if (outcomes.empty())
        {
            ARMARX_WARNING << "No task outcomes to commit";
            return false;
        }
 
        try
        {
            for (const TaskOutcome& outcome : outcomes)
            {
                // Convert BO -> DTO
                armarx::task_outcome::arondto::TaskOutcome outcomeAron;
                toAron(outcomeAron, outcome);
 
                // Create entity ID: group by task name
                armarx::armem::MemoryID entityId =
                    armarx::task_outcome::TaskOutcomeCoreSegmentID
                        .withProviderSegmentName(provider)
                        .withEntityName(outcome.taskName);
 
                // Create entity update
                armarx::armem::EntityUpdate update = {
                    .entityID = entityId,
                    .instancesData = {outcomeAron.toAron()},
                    .referencedTime = referencedTime,
                    .confidence = 1.0F,
                    .sentTime = armarx::armem::Time::Now(),
                    .arrivedTime = armarx::armem::Time::Now(),
                };
 
                // Commit the update
                armem::Commit commit;
                commit.add(update);
 
                ARMARX_DEBUG << "Committing task outcome for '" << outcome.taskName
                             << "' (type: " << static_cast<int>(outcome.taskType) << ")";
 
                memoryWriter().commit(commit);
            }
 
            return true;
        }
        catch (...)
        {
            ARMARX_WARNING << "Failed to commit task outcomes: "
                           << GetHandledExceptionString();
            return false;
        }
    }
 
} // namespace armarx::armem::task_outcome::client