Client.h

Go to the documentation of this file.

#pragma once
 
#include <vector>
 
#include "Interaction.h"
#include "Layer.h"
 
namespace armarx
{
    class Component;
    class ManagedIceObject;
 
    namespace viz
    {
        /**
     * A staged commit prepares multiple layers to be committed.
     *
     * Add all relevant layer updates via .add(layer).
     * Add layers for which you want interaction feedback via .requestInteraction(layer).
     * Then, commit via client.apply(stagedCommit).
     *
     * A staged commit can be reused for subsequent commits.
     * Remember to call .reset() to clear the internal data structures.
     *
     * As long as you keep the staged commits separate, this method is thread-safe.
     * So you can have two threads calling .commit(A) and .commit(B)
     * simultaneously without any locking mechanism.
     */
        struct StagedCommit
        {
            /**
         * @brief Stage a layer to be committed later via client.apply(*this)
         * @param layer The layer to be added to this staged commit.
         */
            void
            add(Layer const& layer)
            {
                data_.updates.push_back(layer.data_);
            }
 
            void
            add(std::initializer_list<Layer> layers)
            {
                data_.updates.reserve(data_.updates.size() + layers.size());
                for (Layer const& layer : layers)
                {
                    data_.updates.push_back(layer.data_);
                }
            }
 
            /**
         * @brief Request interaction feedback for a particular layer.
         * @param layer The layer you want to get interaction feedback for.
         */
            void
            requestInteraction(Layer const& layer)
            {
                data_.interactionComponent = layer.data_.component;
                data_.interactionLayers.push_back(layer.data_.name);
            }
 
            /**
         * @brief Reset all staged layers and interaction requests.
         */
            void
            reset()
            {
                data_.updates.clear();
                data_.interactionComponent.clear();
                data_.interactionLayers.clear();
            }
 
            viz::data::CommitInput data_;
        };
 
        struct CommitResult
        {
            long
            revision() const
            {
                return data_.revision;
            }
 
            InteractionFeedbackRange
            interactions() const
            {
                const InteractionFeedback* begin =
                    reinterpret_cast<const InteractionFeedback*>(data_.interactions.data());
                const InteractionFeedback* end = begin + data_.interactions.size();
                return InteractionFeedbackRange{begin, end};
            }
 
            data::CommitResult data_;
        };
 
        struct CommitResultAsync
        {
            bool
            isAvailable() const
            {
                return async && async->isCompleted();
            }
 
            CommitResult
            waitAndGet() const
            {
                CommitResult result;
                result.data_ = storage->end_commitAndReceiveInteractions(async);
                return result;
            }
 
            Ice::AsyncResultPtr async;
            armarx::viz::StorageInterfacePrx storage;
        };
 
        class Client
        {
        public:
            Client() = default;
            Client(const Client&) = default;
 
            Client(armarx::Component& component,
                   std::string const& topicNameProperty = "ArVizTopicName",
                   std::string const& storageNameProperty = "ArVizStorageName");
 
            Client(ManagedIceObject& obj,
                   std::string const& topicName = "ArVizTopic",
                   std::string const& storageName = "ArVizStorage");
 
            virtual ~Client() = default;
            static Client createFromTopic(std::string const& componentName,
                                          armarx::viz::Topic::ProxyType const& topic);
 
            static Client
            createFromProxies(std::string const& componentName,
                              armarx::viz::Topic::ProxyType const& topic,
                              armarx::viz::StorageAndTopicInterfacePrx const& storage);
 
            static Client createForGuiPlugin(armarx::Component& component,
                                             std::string const& topicName = "ArVizTopic",
                                             std::string const& storageName = "ArVizStorage");
 
            virtual Layer layer(std::string const& name) const;
 
            StagedCommit
            stage()
            {
                return StagedCommit();
            }
 
            CommitResult commit(StagedCommit const& commit);
 
            CommitResultAsync commitAsync(StagedCommit const& commit);
 
            void
            commit(Layer const& layer)
            {
                std::vector<Layer> layers;
                layers.push_back(layer);
                commit(layers);
            }
 
            void commit(std::vector<Layer> const& layers);
 
            void
            commitLayerContaining(std::string const& name)
            {
                std::vector<viz::Layer> layers;
                layers.push_back(this->layer(name));
                commit(layers);
            }
 
            template <typename ElementT>
            void
            commitLayerContaining(std::string const& name, ElementT const& element)
            {
                std::vector<viz::Layer> layers;
                viz::Layer& newLayer = layers.emplace_back(this->layer(name));
                newLayer.add(element);
                commit(layers);
            }
 
            void
            commitDeleteLayer(std::string const& name)
            {
                std::vector<viz::Layer> layers;
                viz::Layer& layerToDelete = layers.emplace_back(this->layer(name));
                layerToDelete.markForDeletion();
                commit(layers);
            }
 
            void
            updateComponentName(std::string const& name)
            {
                this->componentName = name;
            }
 
        private:
            std::string componentName;
            armarx::viz::StorageInterfacePrx storage;
            armarx::viz::TopicPrx topic;
        };
 
    } // namespace viz
} // namespace armarx