Client.cpp

Go to the documentation of this file.

#include "Client.h"
 
#include <ArmarXCore/core/Component.h>
 
namespace armarx::viz
{
 
    Client::Client(Component& component,
                   std::string const& topicNameProperty,
                   std::string const& storageNameProperty)
    {
        componentName = component.getName();
        component.getTopicFromProperty(topic, topicNameProperty);
 
        // Optional dependency on ArVizStorage
        std::string storageName;
        if (component.hasProperty(storageNameProperty))
        {
            storageName = component.getProperty<std::string>(storageNameProperty);
        }
        else
        {
            storageName = "ArVizStorage";
        }
        component.getProxy(storage, storageName);
    }
 
    Client::Client(ManagedIceObject& obj,
                   std::string const& topicName,
                   std::string const& storageName)
    {
        componentName = obj.getName();
        ARMARX_CHECK_NOT_EMPTY(componentName)
            << "ArViz client must be created with non-empty component name.";
        obj.getTopic(topic, topicName);
        obj.getProxy(storage, storageName);
    }
 
    Client
    Client::createFromTopic(std::string const& componentName, Topic::ProxyType const& topic)
    {
        Client client;
        ARMARX_CHECK_NOT_EMPTY(componentName);
        client.componentName = componentName;
        client.topic = topic;
        return client;
    }
 
    Client
    Client::createFromProxies(std::string const& componentName,
                              Topic::ProxyType const& topic,
                              StorageAndTopicInterfacePrx const& storage)
    {
        Client client;
        client.componentName = componentName;
        client.topic = topic;
        client.storage = storage;
        return client;
    }
 
    Client
    Client::createForGuiPlugin(Component& component,
                               std::string const& topicName,
                               std::string const& storageName)
    {
        Client client;
        std::string name = component.getName();
        std::size_t dashPos = name.find('-');
        if (dashPos != std::string::npos)
        {
            name = name.substr(0, dashPos);
        }
        client.componentName = name;
        component.getTopic(client.topic, topicName);
        component.getProxy(client.storage, storageName);
        return client;
    }
 
    Layer
    Client::layer(const std::string& name) const
    {
        ARMARX_CHECK_NOT_EMPTY(componentName)
            << "Layers must be created with non-empty component name.";
        ARMARX_CHECK_NOT_EMPTY(name) << "Layers must be created with non-empty layer name.";
        return Layer(componentName, name);
    }
 
    CommitResult
    Client::commit(const StagedCommit& commit)
    {
        CommitResult result;
 
        ARMARX_CHECK_NOT_NULL(storage);
        result.data_ = storage->commitAndReceiveInteractions(commit.data_);
        return result;
    }
 
    CommitResultAsync
    Client::commitAsync(const StagedCommit& commit)
    {
        CommitResultAsync result;
 
        ARMARX_CHECK_NOT_NULL(storage);
        result.async = storage->begin_commitAndReceiveInteractions(commit.data_);
        result.storage = storage;
        return result;
    }
 
    void
    Client::commit(const std::vector<Layer>& layers)
    {
        data::LayerUpdateSeq updates;
        updates.reserve(layers.size());
        for (Layer const& layer : layers)
        {
            updates.push_back(layer.data_);
        }
        // This commit call still uses the legacy topic API
        ARMARX_CHECK_NOT_NULL(topic);
        topic->updateLayers(updates);
    }
 
 
} // namespace armarx::viz