DebugDrawerHelperComponentPlugin.cpp

Go to the documentation of this file.

/*
 * This file is part of ArmarX.
 *
 * ArmarX is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License version 2 as
 * published by the Free Software Foundation.
 *
 * ArmarX is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program. If not, see <http://www.gnu.org/licenses/>.
 *
 * @package    RobotAPI::ArmarXObjects::RobotAPIComponentPlugins
 * @author     Raphael Grimm ( raphael dot grimm at kit dot edu )
 * @date       2019
 * @copyright  http://www.gnu.org/licenses/gpl-2.0.txt
 *             GNU General Public License
 */
 
#include "DebugDrawerHelperComponentPlugin.h"
 
#include <ArmarXCore/core/Component.h>
#include <ArmarXCore/util/CPPUtility/trace.h>
 
namespace armarx::plugins
{
    DebugDrawerHelperComponentPlugin::DebugDrawerHelperComponentPlugin(ManagedIceObject& parent,
                                                                       std::string pre) :
        ComponentPlugin(parent, pre), _pre{pre}
    {
        ARMARX_TRACE;
        addPlugin(_robotStateComponentPlugin, pre);
        addPluginDependency(_robotStateComponentPlugin);
    }
 
    const DebugDrawerHelper&
    DebugDrawerHelperComponentPlugin::getDebugDrawerHelper() const
    {
        ARMARX_TRACE;
        ARMARX_CHECK_NOT_NULL(_debugDrawerHelper);
        return *_debugDrawerHelper;
    }
 
    DebugDrawerHelper&
    DebugDrawerHelperComponentPlugin::getDebugDrawerHelper()
    {
        ARMARX_TRACE;
        ARMARX_CHECK_NOT_NULL(_debugDrawerHelper);
        return *_debugDrawerHelper;
    }
 
    const DebugDrawerInterfacePrx&
    DebugDrawerHelperComponentPlugin::getDebugDrawerTopic() const
    {
        ARMARX_TRACE;
        return getDebugDrawerHelper().getDebugDrawer();
    }
 
    std::unique_lock<std::recursive_mutex>
    DebugDrawerHelperComponentPlugin::getDebugDrawerHelperLock() const
    {
        ARMARX_TRACE;
        return std::unique_lock{_debugDrawerHelperMutex};
    }
 
    std::string
    DebugDrawerHelperComponentPlugin::getDebugDrawerLayerName() const
    {
        ARMARX_TRACE;
        if (_pre.empty())
        {
            return parent().getName();
        }
        return _pre + "_" + parent().getName();
    }
 
    void
    DebugDrawerHelperComponentPlugin::preOnInitComponent()
    {
        ARMARX_TRACE;
        if (!_debugDrawerTopic)
        {
            parent<Component>().offeringTopicFromProperty(_propertyName);
        }
    }
 
    void
    DebugDrawerHelperComponentPlugin::preOnConnectComponent()
    {
        ARMARX_TRACE;
        if (!_debugDrawerTopic)
        {
            parent<Component>().getTopicFromProperty(_debugDrawerTopic, _propertyName);
        }
        if (!_debugDrawerHelper)
        {
            const auto robotID = _pre + "_DebugDrawerHelperComponentPlugin_" + parent().getName();
            if (!_robotStateComponentPlugin->hasRobot(robotID))
            {
                _robotStateComponentPlugin->addRobot(robotID, VirtualRobot::RobotIO::eStructure);
            }
 
            const auto robot = _robotStateComponentPlugin->getRobot(robotID);
            ARMARX_CHECK_NOT_NULL(_debugDrawerTopic);
            ARMARX_CHECK_NOT_NULL(robot);
            _debugDrawerHelper = std::make_unique<DebugDrawerHelper>(
                _debugDrawerTopic, getDebugDrawerLayerName(), robot);
        }
    }
 
    void
    DebugDrawerHelperComponentPlugin::postOnDisconnectComponent()
    {
        ARMARX_TRACE;
        if (!_doNotClearLayersOnDisconnect)
        {
            try
            {
                _debugDrawerHelper->cyclicCleanup();
                _debugDrawerHelper->cyclicCleanup();
                _debugDrawerHelper->clearLayer();
            }
            catch (...)
            {
            }
        }
        _debugDrawerTopic = nullptr;
    }
 
    void
    DebugDrawerHelperComponentPlugin::postCreatePropertyDefinitions(
        PropertyDefinitionsPtr& properties)
    {
        ARMARX_TRACE;
        if (!properties->hasDefinition(_propertyName))
        {
            properties->defineOptionalProperty<std::string>(
                _propertyName, "DebugDrawerUpdates", "Name of the debug drawer topic");
        }
    }
 
    VirtualRobot::RobotPtr
    DebugDrawerHelperComponentPlugin::getDebugDrawerHelperRobot() const
    {
        ARMARX_TRACE;
        return _debugDrawerHelper->getRobot();
    }
 
    bool
    DebugDrawerHelperComponentPlugin::synchronizeDebugDrawerHelperRobot() const
    {
        ARMARX_TRACE;
        const auto g = getDebugDrawerHelperLock();
        ARMARX_CHECK_NOT_NULL(getDebugDrawerHelperRobot());
        return _robotStateComponentPlugin->synchronizeLocalClone(getDebugDrawerHelperRobot());
    }
 
    bool
    DebugDrawerHelperComponentPlugin::synchronizeDebugDrawerHelperRobot(Ice::Long timestamp) const
    {
        ARMARX_TRACE;
        const auto g = getDebugDrawerHelperLock();
        ARMARX_CHECK_NOT_NULL(getDebugDrawerHelperRobot());
        return _robotStateComponentPlugin->synchronizeLocalClone(getDebugDrawerHelperRobot(),
                                                                 timestamp);
    }
 
    bool
    DebugDrawerHelperComponentPlugin::synchronizeDebugDrawerHelperRobot(
        const RobotStateConfig& state) const
    {
        ARMARX_TRACE;
        const auto g = getDebugDrawerHelperLock();
        ARMARX_CHECK_NOT_NULL(getDebugDrawerHelperRobot());
        return _robotStateComponentPlugin->synchronizeLocalClone(getDebugDrawerHelperRobot(),
                                                                 state);
    }
 
    void
    DebugDrawerHelperComponentPlugin::setClearLayersOnDisconnect(bool b)
    {
        ARMARX_TRACE;
        _doNotClearLayersOnDisconnect = !b;
    }
} // namespace armarx::plugins
 
namespace armarx
{
    DebugDrawerHelperComponentPluginUser::DebugDrawerHelperComponentPluginUser()
    {
        ARMARX_TRACE;
        addPlugin(_debugDrawerHelperComponentPlugin);
    }
 
    const DebugDrawerHelperComponentPluginUser::DebugDrawerHelperComponentPlugin&
    DebugDrawerHelperComponentPluginUser::getDebugDrawerHelperPlugin() const
    {
        ARMARX_TRACE;
        return *_debugDrawerHelperComponentPlugin;
    }
 
    DebugDrawerHelperComponentPluginUser::DebugDrawerHelperComponentPlugin&
    DebugDrawerHelperComponentPluginUser::getDebugDrawerHelperPlugin()
    {
        ARMARX_TRACE;
        return *_debugDrawerHelperComponentPlugin;
    }
 
    const DebugDrawerHelper&
    DebugDrawerHelperComponentPluginUser::getDebugDrawerHelper() const
    {
        ARMARX_TRACE;
        return getDebugDrawerHelperPlugin().getDebugDrawerHelper();
    }
 
    DebugDrawerHelper&
    DebugDrawerHelperComponentPluginUser::getDebugDrawerHelper()
    {
        ARMARX_TRACE;
        return getDebugDrawerHelperPlugin().getDebugDrawerHelper();
    }
 
    const DebugDrawerInterfacePrx&
    DebugDrawerHelperComponentPluginUser::getDebugDrawerTopic() const
    {
        ARMARX_TRACE;
        return getDebugDrawerHelperPlugin().getDebugDrawerTopic();
    }
 
    std::unique_lock<std::recursive_mutex>
    DebugDrawerHelperComponentPluginUser::getDebugDrawerHelperLock() const
    {
        ARMARX_TRACE;
        return getDebugDrawerHelperPlugin().getDebugDrawerHelperLock();
    }
 
    std::string
    DebugDrawerHelperComponentPluginUser::getDebugDrawerLayerName() const
    {
        ARMARX_TRACE;
        return getDebugDrawerHelperPlugin().getDebugDrawerLayerName();
    }
 
    VirtualRobot::RobotPtr
    DebugDrawerHelperComponentPluginUser::getDebugDrawerHelperRobot() const
    {
        ARMARX_TRACE;
        return getDebugDrawerHelperPlugin().getDebugDrawerHelperRobot();
    }
 
    bool
    DebugDrawerHelperComponentPluginUser::synchronizeDebugDrawerHelperRobot() const
    {
        ARMARX_TRACE;
        return getDebugDrawerHelperPlugin().synchronizeDebugDrawerHelperRobot();
    }
 
    bool
    DebugDrawerHelperComponentPluginUser::synchronizeDebugDrawerHelperRobot(
        Ice::Long timestamp) const
    {
        ARMARX_TRACE;
        return getDebugDrawerHelperPlugin().synchronizeDebugDrawerHelperRobot(timestamp);
    }
 
    bool
    DebugDrawerHelperComponentPluginUser::synchronizeDebugDrawerHelperRobot(
        const RobotStateConfig& state) const
    {
        ARMARX_TRACE;
        return getDebugDrawerHelperPlugin().synchronizeDebugDrawerHelperRobot(state);
    }
} // namespace armarx