smacc2::introspection::SmaccStateMachineInfo Class Reference

#include <smacc_state_machine_info.hpp>

Inheritance diagram for smacc2::introspection::SmaccStateMachineInfo:

Collaboration diagram for smacc2::introspection::SmaccStateMachineInfo:

Public Member Functions
	SmaccStateMachineInfo (rclcpp::Node::SharedPtr nh)
template<typename InitialStateType >
void	buildStateMachineInfo ()
template<typename StateType >
std::shared_ptr< SmaccStateInfo >	createState (std::shared_ptr< SmaccStateInfo > parentState)
template<typename StateType >
bool	containsState ()
template<typename StateType >
std::shared_ptr< SmaccStateInfo >	getState ()
rclcpp::Node::SharedPtr	getNode ()
rclcpp::Logger	getLogger ()
template<typename StateType >
void	addState (std::shared_ptr< StateType > &state)
void	assembleSMStructureMessage (ISmaccStateMachine *sm)

Public Attributes
std::map< std::string, std::shared_ptr< SmaccStateInfo > >	states
std::vector< smacc2_msgs::msg::SmaccState >	stateMsgs

Private Attributes
rclcpp::Node::SharedPtr	nh_

Detailed Description

Definition at line 44 of file smacc_state_machine_info.hpp.

Constructor & Destructor Documentation

SmaccStateMachineInfo()

smacc2::introspection::SmaccStateMachineInfo::SmaccStateMachineInfo ( rclcpp::Node::SharedPtr nh )

inlineexplicit

Definition at line 47 of file smacc_state_machine_info.hpp.

: nh_(nh) {}

Member Function Documentation

addState()

template<typename StateType >

void smacc2::introspection::SmaccStateMachineInfo::addState

(

std::shared_ptr< StateType > &

state

)

Definition at line 470 of file smacc_state_machine_info.hpp.

{
  states[state->fullStateName] = state;
}

References states.

Referenced by createState().

Here is the caller graph for this function:

assembleSMStructureMessage()

void smacc2::SmaccStateMachineInfo::assembleSMStructureMessage

(

ISmaccStateMachine *

sm

)

Definition at line 26 of file smacc_state_machine_info.cpp.

{
  std::stringstream ss;
 
  ss << "----------- PRINT STATE MACHINE STRUCTURE -------------------" << std::endl;
  // Rebuild the state message list from scratch on every call.
  stateMsgs.clear();
  // Walk every registered state and describe it in a message and in the text summary.
  for (auto & val : this->states)
  {
    smacc2_msgs::msg::SmaccState stateMsg;
    auto state = val.second;
    // Basic identity: index, demangled name and depth in the state hierarchy.
    stateMsg.index = state->stateIndex_;
 
    ss << "**** State: " << demangleSymbol(val.first.c_str()) << std::endl;
 
    stateMsg.name = state->getDemangledFullName();
    stateMsg.level = (int)state->getStateLevel();
 
    ss << "Index: " << stateMsg.index << std::endl;
    ss << "StateLevel: " << stateMsg.level << std::endl;
 
    ss << " Childstates:" << std::endl;
 
    // List the direct child states.
    for (auto & child : state->children_)
    {
      auto childStateName = child->getDemangledFullName();
      stateMsg.children_states.push_back(childStateName);
 
      ss << " - " << childStateName << std::endl;
    }
 
    ss << " Transitions:" << std::endl;
 
    // Convert each transition table row into a message and print its details.
    for (auto & transition : state->transitions_)
    {
      smacc2_msgs::msg::SmaccTransition transitionMsg;
 
      transitionInfoToMsg(transition, transitionMsg);
 
      ss << " - Transition.  " << std::endl;
      ss << "      - Index: " << transitionMsg.index << std::endl;
      ss << "      - Transition Name: " << transitionMsg.transition_name << std::endl;
      ss << "      - Transition Type: " << transitionMsg.transition_type << std::endl;
      ss << "      - Event Type :" << transitionMsg.event.event_type << std::endl;
      ss << "      - Event Source: " << transitionMsg.event.event_source << std::endl;
      ss << "      - Event ObjectTag: " << transitionMsg.event.event_object_tag << std::endl;
      ss << "      - Event Label: " << transitionMsg.event.label << std::endl;
      ss << "      - Destiny State: " << transitionMsg.destiny_state_name << std::endl;
      ss << "      - Owner State: " << transitionMsg.source_state_name << std::endl;
      ss << "      - Is History Node: " << std::to_string(transitionMsg.history_node) << std::endl;
      ss << "      - TransitionC++Type: " << transition.transitionTypeInfo->getFullName()
         << std::endl;
      ss << "      - EventC++Type: " << transition.eventInfo->eventType->getFullName() << std::endl;
 
      stateMsg.transitions.push_back(transitionMsg);
    }
 
    const std::type_info * statetid = state->tid_;
 
    // Group the client behaviors statically configured for this state by orthogonal type.
    std::map<const std::type_info *, std::vector<smacc2::ClientBehaviorInfoEntry *>>
      smaccBehaviorInfoMappingByOrthogonalType;
 
    ss << " Orthogonals:" << std::endl;
    if (SmaccStateInfo::staticBehaviorInfo.count(statetid) > 0)
    {
      for (auto & bhinfo : SmaccStateInfo::staticBehaviorInfo[statetid])
      {
        if (smaccBehaviorInfoMappingByOrthogonalType.count(bhinfo.orthogonalType) == 0)
        {
          smaccBehaviorInfoMappingByOrthogonalType[bhinfo.orthogonalType] =
            std::vector<smacc2::ClientBehaviorInfoEntry *>();
        }
 
        smaccBehaviorInfoMappingByOrthogonalType[bhinfo.orthogonalType].push_back(&bhinfo);
      }
    }
 
    // Describe every runtime orthogonal with the behaviors and clients it holds for this state.
    auto & runtimeOrthogonals = sm->getOrthogonals();
 
    for (auto & orthogonal : runtimeOrthogonals)
    {
      smacc2_msgs::msg::SmaccOrthogonal orthogonalMsg;
 
      const auto * orthogonaltid = &typeid(*(orthogonal.second));
      orthogonalMsg.name = demangleSymbol(orthogonaltid->name());
 
      ss << " - orthogonal: " << orthogonalMsg.name << std::endl;
 
      // Client behaviors this state configures in this orthogonal.
      if (smaccBehaviorInfoMappingByOrthogonalType[orthogonaltid].size() > 0)
      {
        auto & behaviors = smaccBehaviorInfoMappingByOrthogonalType[orthogonaltid];
        for (auto & bhinfo : behaviors)
        {
          auto ClientBehaviorName = demangleSymbol(bhinfo->behaviorType->name());
          orthogonalMsg.client_behavior_names.push_back(ClientBehaviorName);
          ss << "          - client behavior: " << ClientBehaviorName << std::endl;
        }
      }
      else
      {
        ss << "          - NO CLIENT BEHAVIORS -" << std::endl;
      }
 
      // Clients owned by the orthogonal for the whole state machine lifetime.
      auto & clients = orthogonal.second->getClients();
      if (clients.size() > 0)
      {
        for (auto & client : clients)
        {
          auto clientTid = client->getType();
          auto clientName = clientTid->getNonTemplatedTypeName();
          orthogonalMsg.client_names.push_back(clientName);
          ss << "          - client: " << clientName << std::endl;
        }
      }
      else
      {
        ss << "          - NO CLIENTS - " << std::endl;
      }
      stateMsg.orthogonals.push_back(orthogonalMsg);
    }
 
    // Event generators attached to this state.
    ss << " State event generators:" << std::endl;
    if (SmaccStateInfo::eventGeneratorsInfo.count(statetid) > 0)
    {
      int k = 0;
      for (auto & eginfo : SmaccStateInfo::eventGeneratorsInfo[statetid])
      {
        smacc2_msgs::msg::SmaccEventGenerator eventGeneratorMsg;
        eventGeneratorMsg.index = k++;
        eventGeneratorMsg.type_name = eginfo->eventGeneratorType->getFullName();
 
        ss << " - event generator: " << eventGeneratorMsg.type_name << std::endl;
        if (eginfo->objectTagType != nullptr)
        {
          eventGeneratorMsg.object_tag = eginfo->objectTagType->getFullName();
          ss << "        - object tag: " << eventGeneratorMsg.object_tag << std::endl;
        }
        stateMsg.event_generators.push_back(eventGeneratorMsg);
      }
    }
 
    // State reactors attached to this state, with the events each one listens to.
    ss << " State reactors:" << std::endl;
    if (SmaccStateInfo::stateReactorsInfo.count(statetid) > 0)
    {
      int k = 0;
      for (auto & srinfo : SmaccStateInfo::stateReactorsInfo[statetid])
      {
        smacc2_msgs::msg::SmaccStateReactor stateReactorMsg;
        stateReactorMsg.index = k++;
        stateReactorMsg.type_name = srinfo->stateReactorType->getFullName();
 
        ss << " - state reactor: " << stateReactorMsg.type_name << std::endl;
        if (srinfo->objectTagType != nullptr)
        {
          stateReactorMsg.object_tag = srinfo->objectTagType->getFullName();
          ss << "        - object tag: " << stateReactorMsg.object_tag << std::endl;
        }
 
        // Record every source event that can trigger this reactor.
        for (auto & tev : srinfo->sourceEventTypes)
        {
          // WE SHOULD CREATE A SMACC_EVENT_INFO TYPE, also using in typewalker transition
          auto eventTypeName = tev->getEventTypeName();
          smacc2_msgs::msg::SmaccEvent event;
 
          ss << "             - triggering event: " << tev->getEventTypeName() << std::endl;
          event.event_type = eventTypeName;
 
          event.event_source = tev->getEventSourceName();
          ss << "                 - source type: " << event.event_source << std::endl;
 
          event.event_object_tag = tev->getOrthogonalName();
          ss << "                 - source object: " << event.event_object_tag << std::endl;
 
          event.label = tev->label;
          ss << "                 - event label: " << event.label << std::endl;
 
          stateReactorMsg.event_sources.push_back(event);
        }
 
        stateMsg.state_reactors.push_back(stateReactorMsg);
      }
    }
    else
    {
      ss << "- NO STATE REACTORS - " << std::endl;
    }
 
    ss << "----------------------------------------------------------" << std::endl;
 
    // Emit the text summary at debug level and keep the message for the description topic.
    auto resumeMsg = ss.str();
    RCLCPP_DEBUG(getLogger(), "%s", resumeMsg.c_str());
    stateMsgs.push_back(stateMsg);
  }
}

References smacc2::introspection::demangleSymbol(), smacc2::introspection::SmaccStateInfo::eventGeneratorsInfo, getLogger(), smacc2::ISmaccStateMachine::getOrthogonals(), stateMsgs, smacc2::introspection::SmaccStateInfo::stateReactorsInfo, states, smacc2::introspection::SmaccStateInfo::staticBehaviorInfo, and smacc2::introspection::transitionInfoToMsg().

Here is the call graph for this function:

buildStateMachineInfo()

template<typename InitialStateType >

void smacc2::introspection::SmaccStateMachineInfo::buildStateMachineInfo

(

)

Definition at line 438 of file smacc_state_machine_info.hpp.

{
  auto initialState = this->createState<InitialStateType>(nullptr);
  WalkStatesExecutor<InitialStateType>::walkStates(initialState, true);
}

References createState(), and smacc2::introspection::WalkStatesExecutor< InitialStateType >::walkStates().

Here is the call graph for this function:

containsState()

template<typename StateType >

bool smacc2::introspection::SmaccStateMachineInfo::containsState ( )

inline

Definition at line 60 of file smacc_state_machine_info.hpp.

  {
    auto typeNameStr = typeid(StateType).name();
 
    return states.count(typeNameStr) > 0;
  }

References states.

Referenced by getState().

Here is the caller graph for this function:

createState()

template<typename StateType >

std::shared_ptr< SmaccStateInfo > smacc2::introspection::SmaccStateMachineInfo::createState

(

std::shared_ptr< SmaccStateInfo >

parentState

)

Definition at line 445 of file smacc_state_machine_info.hpp.

{
  auto thisptr = this->shared_from_this();
  auto * statetid = &(typeid(StateType));
 
  auto demangledName = demangledTypeName<StateType>();
  RCLCPP_INFO_STREAM(getLogger(), "Creating State Info: " << demangledName);
 
  auto state = std::make_shared<SmaccStateInfo>(statetid, parent, thisptr);
  state->demangledStateName = demangledName;
  state->fullStateName = typeid(StateType).name();
  state->stateIndex_ = states.size();
 
  if (parent != nullptr)
  {
    parent->children_.push_back(state);
  }
 
  this->addState(state);
 
  return state;
}

References addState(), smacc2::introspection::demangledTypeName(), getLogger(), and states.

Referenced by buildStateMachineInfo().

Here is the call graph for this function:

Here is the caller graph for this function:

getLogger()

rclcpp::Logger smacc2::introspection::SmaccStateMachineInfo::getLogger ( )

inline

Definition at line 79 of file smacc_state_machine_info.hpp.

{ return nh_->get_logger(); }

References nh_.

Referenced by assembleSMStructureMessage(), and createState().

Here is the caller graph for this function:

getNode()

rclcpp::Node::SharedPtr smacc2::introspection::SmaccStateMachineInfo::getNode ( )

inline

Definition at line 77 of file smacc_state_machine_info.hpp.

{ return nh_; }

References nh_.

getState()

template<typename StateType >

std::shared_ptr< SmaccStateInfo > smacc2::introspection::SmaccStateMachineInfo::getState ( )

inline

Definition at line 68 of file smacc_state_machine_info.hpp.

  {
    if (this->containsState<StateType>())
    {
      return states[typeid(StateType).name()];
    }
    return nullptr;
  }

References containsState().

Here is the call graph for this function:

Member Data Documentation

nh_

rclcpp::Node::SharedPtr smacc2::introspection::SmaccStateMachineInfo::nh_

private

Definition at line 86 of file smacc_state_machine_info.hpp.

Referenced by getLogger(), and getNode().

stateMsgs

std::vector<smacc2_msgs::msg::SmaccState> smacc2::introspection::SmaccStateMachineInfo::stateMsgs

Definition at line 51 of file smacc_state_machine_info.hpp.

Referenced by assembleSMStructureMessage().

states

std::map<std::string, std::shared_ptr<SmaccStateInfo> > smacc2::introspection::SmaccStateMachineInfo::states

Definition at line 49 of file smacc_state_machine_info.hpp.

Referenced by addState(), assembleSMStructureMessage(), containsState(), and createState().

---

The documentation for this class was generated from the following files:

• smacc2/include/smacc2/introspection/smacc_state_machine_info.hpp
• smacc2/src/smacc2/smacc_state_machine_info.cpp