ComponentPlugin.cpp

Go to the documentation of this file.

#include <memory>
#include <string>
 
#include <ArmarXCore/core/Component.h>
#include <ArmarXCore/core/application/properties/PropertyDefinitionContainer.h>
#include <ArmarXCore/core/exceptions/local/ExpressionException.h>
#include <ArmarXCore/core/logging/Logging.h>
#include <ArmarXCore/util/CPPUtility/trace.h>
 
#include <RobotAPI/libraries/armem/client/MemoryNameSystem.h>
#include <RobotAPI/libraries/armem/client/plugins/ListeningPluginUser.h>
 
#include <armarx/navigation/client/ComponentPlugin.h>
#include <armarx/navigation/client/NavigationStackConfig.h>
#include <armarx/navigation/client/Navigator.h>
#include <armarx/navigation/client/services/IceNavigatorFactory.h>
#include <armarx/navigation/client/services/MemorySubscriber.h>
#include <armarx/navigation/client/services/SimpleEventHandler.h>
 
// ComponentPlugin
 
namespace armarx::navigation::client
{
 
    ComponentPlugin::~ComponentPlugin() = default;
 
    void
    ComponentPlugin::postCreatePropertyDefinitions(armarx::PropertyDefinitionsPtr& properties)
    {
        if (not properties->hasDefinition(PROPERTY_NAME))
        {
            properties->defineOptionalProperty<std::string>(
                PROPERTY_NAME, "navigator", "Name of the Navigator");
        }
    }
 
    void
    ComponentPlugin::preOnInitComponent()
    {
        ARMARX_TRACE;
        parent<armarx::Component>().usingProxyFromProperty(PROPERTY_NAME);
    }
 
    void
    ComponentPlugin::preOnConnectComponent()
    {
        ARMARX_TRACE;
        parent<armarx::Component>().getProxyFromProperty(navigatorPrx, PROPERTY_NAME);
 
        ARMARX_TRACE;
        const std::string componentName = parent().getName();
 
        ARMARX_CHECK_NOT_NULL(navigatorPrx) << "Navigator proxy is null!";
        iceNavigatorFactory.setNavigatorComponent(navigatorPrx);
    }
 
    void
    ComponentPlugin::configureNavigator(const client::NavigationStackConfig& stackConfig,
                                        const std::string& configId)
    {
        ARMARX_TRACE;
 
        // ARMARX_CHECK_NULL(eventHandler) << "`configureNavigator()` can only be called once!";
 
        eventHandler = [&]() -> std::unique_ptr<SimpleEventHandler>
        {
            ARMARX_TRACE;
            if (parentDerives<armarx::armem::client::plugins::ListeningPluginUser>())
            {
                ARMARX_TRACE;
                ARMARX_INFO << "Using memory event callbacks.";
                // must(!!) use a reference here: otherwise the mns events won't work
                auto& memoryNameSystem =
                    parent<armarx::armem::client::plugins::ListeningPluginUser>()
                        .memoryNameSystem();
                return std::make_unique<MemorySubscriber>(configId, memoryNameSystem);
            }
 
            ARMARX_INFO
                << "Cannot use memory event callbacks as this component is not derived from "
                   "`armarx::armem::client::plugins::ListeningPluginUser`";
 
            return std::make_unique<SimpleEventHandler>();
        }();
 
        iceNavigatorHandle = iceNavigatorFactory.createConfig(stackConfig, configId);        
 
        navigator = std::make_unique<Navigator>(Navigator::InjectedServices{
            .navigator = iceNavigatorHandle.get(), .subscriber = eventHandler.get()});
    }
 
    // ComponentPluginUser
 
    ComponentPluginUser::ComponentPluginUser()
    {
        ARMARX_TRACE;
        addPlugin(plugin);
    }
 
    void
    ComponentPluginUser::configureNavigator(const client::NavigationStackConfig& stackConfig)
    {
        ARMARX_TRACE;
        plugin->configureNavigator(stackConfig, getName());
    }
 
    Navigator&
    ComponentPluginUser::getNavigator()
    {
        ARMARX_CHECK_NOT_NULL(plugin->navigator)
            << "You need to call `configureNavigator()` before you can access the navigator!";
        return *plugin->navigator;
    }
 
    ComponentPluginUser::~ComponentPluginUser() = default;
 
} // namespace armarx::navigation::client