StatechartListenerSegment.cpp

Go to the documentation of this file.

#include "StatechartListenerSegment.h"
 
#include <atomic>
 
#include <RobotAPI/libraries/armem/core/Commit.h>
#include <RobotAPI/libraries/armem/server/MemoryToIceAdapter.h>
#include <RobotAPI/libraries/armem_skills/aron/Statechart.aron.generated.h>
#include <RobotAPI/libraries/armem_skills/aron_conversions.h>
 
namespace armarx::skills::segment
{
    StatechartListenerProviderSegment::StatechartListenerProviderSegment(
        armem::server::MemoryToIceAdapter& iceMemory) :
        Base(iceMemory,
             "StatechartListener",
             "Transitions",
             arondto::Statechart::Transition::ToAronType())
    {
    }
 
    void
    StatechartListenerProviderSegment::defineProperties(PropertyDefinitionsPtr defs,
                                                        const std::string& prefix)
    {
        // Statechart Logging
        defs->optional(p.statechartCoreSegmentName,
                       "StatechartCoreSegmentName",
                       "Name of the core segment for statecharts.");
        defs->optional(p.statechartTransitionsProviderSegmentName,
                       "TransitionsProviderSegmentName",
                       "Name of the provider segment for statechart transitions.");
        defs->optional(p.statechartTransitionsTopicName,
                       "tpc.sub.ProfilerListener",
                       "Name of the ProfilerListenerInterface topics to subscribe.");
 
        this->setDefaultMaxHistorySize(10);
        coreSegment.setDefaultMaxHistorySize(10);
        Base::defineProperties(defs, prefix);
    }
 
    void
    StatechartListenerProviderSegment::init()
    {
        Base::init();
    }
 
    void
    StatechartListenerProviderSegment::reportStatechartTransitionWithParameters(
        const ProfilerStatechartTransitionWithParameters& t)
    {
        // Ice topic callbacks can fire before init() has set segmentPtr, or
        // after the segment has been torn down during shutdown. In both cases
        // dereferencing segmentPtr would crash the component.
        if (segmentPtr == nullptr)
        {
            static std::atomic_flag warned = ATOMIC_FLAG_INIT;
            if (!warned.test_and_set())
            {
                ARMARX_WARNING << "StatechartListenerProviderSegment received a "
                                  "transition before init() or after shutdown; "
                                  "dropping. This warning is only logged once.";
            }
            return;
        }
 
        const std::string& entityName = getStatechartName(t.targetStateIdentifier);
        armem::Time transitionTime = armem::Time(armem::Duration::MicroSeconds(t.timestamp));
 
        armem::Commit commit;
        armem::EntityUpdate& update = commit.add();
        update.entityID = segmentPtr->id().withEntityName(entityName);
 
        update.referencedTime = transitionTime;
        skills::arondto::Statechart::Transition data;
        armem::toAron(data, t);
        update.instancesData.push_back(data.toAron());
 
        try
        {
            // Commit through the locking path so the underlying std::map is
            // modified under an exclusive lock on the core segment. Without
            // this lock, concurrent queries (which iterate the map under a
            // shared lock) hit invalidated iterators -> segfault.
            iceMemory.commitLocking(commit);
        }
        catch (const armem::error::ArMemError& e)
        {
            ARMARX_WARNING << e.what();
        }
    }
 
    void
    StatechartListenerProviderSegment::reportStatechartTransitionWithParametersList(
        const ProfilerStatechartTransitionWithParametersList& transitions)
    {
        for (const auto& t : transitions)
        {
            reportStatechartTransitionWithParameters(t);
        }
    }
 
    std::string
    StatechartListenerProviderSegment::getStatechartName(std::string stateName)
    {
        const std::string delimiter = "->";
        const int maxLevels = 2;
 
        size_t pos;
        int levels = 0;
        std::string statechartName;
        while ((pos = stateName.find(delimiter)) != std::string::npos && levels < maxLevels)
        {
            if (levels != 0)
            {
                statechartName += delimiter;
            }
            statechartName += stateName.substr(0, pos);
            stateName.erase(0, pos + delimiter.length());
            levels++;
        }
 
        return statechartName;
    }
} // namespace armarx::skills::segment