Writer.cpp

Go to the documentation of this file.

#include "Writer.h"
 
#include <mutex>
#include <string>
#include <vector>
 
#include <SimoxUtility/algorithm/string/string_tools.h>
 
#include <ArmarXCore/core/exceptions/local/ExpressionException.h>
#include <ArmarXCore/core/logging/Logging.h>
 
#include <RobotAPI/libraries/armem/client/util/SimpleWriterBase.h>
#include <RobotAPI/libraries/armem/core/Commit.h>
#include <RobotAPI/libraries/armem/core/MemoryID.h>
#include <RobotAPI/libraries/armem/core/forward_declarations.h>
 
#include <armarx/navigation/algorithms/Room.h>
#include <armarx/navigation/algorithms/aron/Room.aron.generated.h>
#include <armarx/navigation/algorithms/aron_conversions.h>
#include <armarx/navigation/memory/constants.h>
 
namespace armarx::navigation::memory::client::rooms
{
    Writer::~Writer() = default;
 
    bool
    Writer::store(const armarx::navigation::algorithms::Room& room,
                  const std::string& providerName,
                  const armem::Time& timestamp)
    {
        return store(
            std::vector<armarx::navigation::algorithms::Room>{room}, providerName, timestamp);
    }
 
    bool
    Writer::store(const std::vector<armarx::navigation::algorithms::Room>& rooms,
                  const std::string& providerName,
                  const armem::Time& timestamp)
    {
        std::lock_guard g{writeMutex};
 
        const auto result =
            memoryWriter().addSegment(memory::constants::RoomsCoreSegmentName, providerName);
 
        if (not result.success)
        {
            ARMARX_ERROR << result.errorMessage;
            return false;
        }
 
        const auto providerId = armem::MemoryID(result.segmentID);
 
        armem::Commit commit;
 
        for (const auto& room : rooms)
        {
            ARMARX_CHECK(not room.name.empty())
                << "A room must have a name as it is used as the entity name.";
 
            navigation::algorithms::arondto::Room dto;
            toAron(dto, room);
 
            armem::EntityUpdate& update = commit.add();
            update.entityID = providerId.withEntityName(room.name).withTimestamp(timestamp);
            update.referencedTime = timestamp;
            update.instancesData = {dto.toAron()};
        }
 
        ARMARX_DEBUG << "Committing " << commit << " at time " << timestamp;
        const armem::CommitResult commitResult = memoryWriter().commit(commit);
 
        if (not commitResult.allSuccess())
        {
            ARMARX_ERROR << simox::alg::join(commitResult.allErrorMessages(), "\n");
            return false;
        }
 
        return true;
    }
 
    std::string
    Writer::propertyPrefix() const
    {
        return "mem.nav.rooms.";
    }
 
    armarx::armem::client::util::SimpleWriterBase::Properties
    Writer::defaultProperties() const
    {
        return {.memoryName = memory::constants::NavigationMemoryName,
                .coreSegmentName = memory::constants::RoomsCoreSegmentName,
                .providerName = ""};
    }
 
} // namespace armarx::navigation::memory::client::rooms