SimpleEventHandler.cpp

Go to the documentation of this file.

#include "SimpleEventHandler.h"
 
#include <armarx/navigation/client/services/EventSubscriptionInterface.h>
#include <armarx/navigation/core/events.h>
 
namespace armarx::navigation::client
{
 
    void
    SimpleEventHandler::onGoalReached(const OnGoalReachedCallback& callback)
    {
        subscriptions.goalReachedCallbacks.push_back(callback);
    }
 
    void
    SimpleEventHandler::onWaypointReached(const OnWaypointReachedCallback& callback)
    {
        subscriptions.waypointReachedCallbacks.push_back(callback);
    }
 
    void
    SimpleEventHandler::onSafetyThrottlingTriggered(
        const OnSafetyThrottlingTriggeredCallback& callback)
    {
        subscriptions.safetyThrottlingTriggeredCallbacks.push_back(callback);
    }
 
    void
    SimpleEventHandler::onSafetyStopTriggered(const OnSafetyStopTriggeredCallback& callback)
    {
        subscriptions.safetyStopTriggeredCallbacks.push_back(callback);
    }
 
    void
    SimpleEventHandler::onUserAbortTriggered(const OnUserAbortTriggeredCallback& callback)
    {
        subscriptions.userAbortTriggeredCallbacks.push_back(callback);
    }
 
    void
    SimpleEventHandler::onInternalError(const OnInternalErrorCallback& callback)
    {
        subscriptions.internalErrorCallbacks.push_back(callback);
    }
 
    void
    SimpleEventHandler::SimpleEventHandler::onMovementStarted(
        const OnMovementStartedCallback& callback)
    {
        subscriptions.movementStartedCallbacks.push_back(callback);
    }
 
    void
    SimpleEventHandler::onGlobalPlanningFailed(const GlobalPlanningFailedCallback& callback)
    {
        subscriptions.globalPlanningFailedCallbacks.push_back(callback);
    }
 
    void
    SimpleEventHandler::onLocalPlanningFailed(const LocalPlanningFailedCallback& callback)
    {
        subscriptions.localPlanningFailedCallbacks.push_back(callback);
    }
 
    void
    SimpleEventHandler::onGlobalTrajectoryUpdated(const GlobalTrajectoryUpdatedCallback& callback)
    {
        subscriptions.globalTrajectoryUpdatedCallbacks.push_back(callback);
    }
 
    void
    SimpleEventHandler::onLocalTrajectoryUpdated(const LocalTrajectoryUpdatedCallback& callback)
    {
        subscriptions.localTrajectoryUpdatedCallbacks.push_back(callback);
    }
 
    void
    SimpleEventHandler::goalReached(const core::GoalReachedEvent& event)
    {
        for (const auto& callback : subscriptions.goalReachedCallbacks)
        {
            callback(event);
        }
    }
 
    void
    SimpleEventHandler::waypointReached(const core::WaypointReachedEvent& event)
    {
        for (const auto& callback : subscriptions.waypointReachedCallbacks)
        {
            callback(event);
        }
    }
 
    void
    SimpleEventHandler::safetyThrottlingTriggered(const core::SafetyThrottlingTriggeredEvent& event)
    {
        for (const auto& callback : subscriptions.safetyThrottlingTriggeredCallbacks)
        {
            callback(event);
        }
    }
 
    void
    SimpleEventHandler::safetyStopTriggered(const core::SafetyStopTriggeredEvent& event)
    {
        for (const auto& callback : subscriptions.safetyStopTriggeredCallbacks)
        {
            callback(event);
        }
    }
 
    void
    SimpleEventHandler::userAbortTriggered(const core::UserAbortTriggeredEvent& event)
    {
        for (const auto& callback : subscriptions.userAbortTriggeredCallbacks)
        {
            callback(event);
        }
    }
 
    void
    SimpleEventHandler::internalError(const core::InternalErrorEvent& event)
    {
        for (const auto& callback : subscriptions.internalErrorCallbacks)
        {
            callback(event);
        }
    }
 
    void
    SimpleEventHandler::globalTrajectoryUpdated(const core::GlobalTrajectoryUpdatedEvent& event)
    {
        for (const auto& callback : subscriptions.globalTrajectoryUpdatedCallbacks)
        {
            callback(event);
        }
    }
 
    void
    SimpleEventHandler::localTrajectoryUpdated(const core::LocalTrajectoryUpdatedEvent& event)
    {
        for (const auto& callback : subscriptions.localTrajectoryUpdatedCallbacks)
        {
            callback(event);
        }
    }
 
    // void
    // SimpleEventHandler::trajectoryControllerUpdated(
    //     const traj_ctrl::local::TrajectoryControllerResult& event)
    // {
    //     for (const auto& callback : subscriptions.trajectoryControllerUpdatedCallbacks)
    //     {
    //         callback(event);
    //     }
    // }
 
    void
    SimpleEventHandler::globalPlanningFailed(const core::GlobalPlanningFailedEvent& event)
    {
        for (const auto& callback : subscriptions.globalPlanningFailedCallbacks)
        {
            callback(event);
        }
    }
 
    void
    SimpleEventHandler::localPlanningFailed(const core::LocalPlanningFailedEvent& event)
    {
        for (const auto& callback : subscriptions.localPlanningFailedCallbacks)
        {
            callback(event);
        }
    }
 
    void
    SimpleEventHandler::movementStarted(const core::MovementStartedEvent& event)
    {
        for (const auto& callback : subscriptions.movementStartedCallbacks)
        {
            callback(event);
        }
    }
 
 
} // namespace armarx::navigation::client