yasmin::Concurrence Class Reference

Runs a series of states in parallel. More...

#include <concurrence.hpp>

Inheritance diagram for yasmin::Concurrence:

Collaboration diagram for yasmin::Concurrence:

Public Types
typedef std::map< std::shared_ptr< State >, std::string >	StateMap
typedef std::map< std::string, StateMap >	OutcomeMap

Public Member Functions
	Concurrence (std::set< std::shared_ptr< State > > states, std::string default_outcome, OutcomeMap outcome_map)
	Constructs a State with a set of possible outcomes.
std::string	execute (std::shared_ptr< blackboard::Blackboard > blackboard) override
	Executes the state's specific logic.
void	cancel_state () override
	Cancels the current state execution.
std::string	to_string () override
	Converts the state to a string representation.
Public Member Functions inherited from yasmin::State
	State (std::set< std::string > outcomes)
	Constructs a State with a set of possible outcomes.
std::string	operator() (std::shared_ptr< blackboard::Blackboard > blackboard)
	Executes the state and returns the outcome.
bool	is_canceled () const
	Checks if the state has been canceled.
bool	is_running () const
	Checks if the state is currently running.
std::set< std::string > const &	get_outcomes ()
	Gets the set of possible outcomes for this state.

Protected Attributes
const std::set< std::shared_ptr< State > >	states
	The states to run concurrently.
const std::string	default_outcome
	Default outcome.
OutcomeMap	outcome_map
std::map< std::shared_ptr< State >, std::shared_ptr< std::string > >	intermediate_outcome_map
	Stores the intermedaite outcomes of the concurrent states.
std::set< std::string >	possible_outcomes
	The set of possible outcomes.
Protected Attributes inherited from yasmin::State
std::set< std::string >	outcomes
	The possible outcomes of this state.

Static Private Member Functions
static std::set< std::string >	generate_possible_outcomes (const OutcomeMap &outcome_map, const std::string &default_outcome)
	Helper function to generate a set of possible outcomes from an outcome map.

Private Attributes
std::atomic_bool	canceled {false}
	Indicates if the state has been canceled.
std::atomic_bool	running {false}
	Indicates if the state is currently running.
std::mutex	intermediate_outcome_mutex
	Mutex for intermediate outcome map.

Detailed Description

Runs a series of states in parallel.

The Concurrence class runs a set of states concurrently, waiting for the termination of each, and then returns a single output according to a provided rule map, or a default outcome if no rule is satisfied.

Member Typedef Documentation

OutcomeMap

typedef std::map<std::string, StateMap> yasmin::Concurrence::OutcomeMap

StateMap

typedef std::map<std::shared_ptr<State>, std::string> yasmin::Concurrence::StateMap

Constructor & Destructor Documentation

Concurrence()

Concurrence::Concurrence	(	std::set< std::shared_ptr< State > >	states,
		std::string	default_outcome,
		OutcomeMap	outcome_map )

Constructs a State with a set of possible outcomes.

Parameters

outcomes

A set of possible outcomes for this state.

Member Function Documentation

cancel_state()

void Concurrence::cancel_state ( )

overridevirtual

Cancels the current state execution.

This method sets the canceled flag to true and logs the action.

Reimplemented from yasmin::State.

execute()

std::string Concurrence::execute ( std::shared_ptr< blackboard::Blackboard > blackboard )

overridevirtual

Executes the state's specific logic.

Parameters

blackboard

A shared pointer to the Blackboard to use during execution.

Returns

A string representing the outcome of the execution.

This method is intended to be overridden by derived classes to provide specific execution logic.

Reimplemented from yasmin::State.

generate_possible_outcomes()

std::set< std::string > Concurrence::generate_possible_outcomes ( const OutcomeMap & outcome_map, const std::string & default_outcome )

staticprivate

Helper function to generate a set of possible outcomes from an outcome map.

Parameters

outcome_map
default_outcome

Returns

The set of possible outcomes

to_string()

std::string yasmin::Concurrence::to_string ( )

inlineoverridevirtual

Converts the state to a string representation.

Returns

A string representation of the state.

This method retrieves the demangled name of the class for a readable string representation.

Reimplemented from yasmin::State.

Member Data Documentation

canceled

std::atomic_bool yasmin::Concurrence::canceled {false}

private

Indicates if the state has been canceled.

default_outcome

const std::string yasmin::Concurrence::default_outcome

protected

Default outcome.

intermediate_outcome_map

std::map<std::shared_ptr<State>, std::shared_ptr<std::string> > yasmin::Concurrence::intermediate_outcome_map

protected

Stores the intermedaite outcomes of the concurrent states.

intermediate_outcome_mutex

std::mutex yasmin::Concurrence::intermediate_outcome_mutex

private

Mutex for intermediate outcome map.

outcome_map

OutcomeMap yasmin::Concurrence::outcome_map

protected

Specifies which combination of state outputs should produce a given overall output

possible_outcomes

std::set<std::string> yasmin::Concurrence::possible_outcomes

protected

The set of possible outcomes.

running

std::atomic_bool yasmin::Concurrence::running {false}

private

Indicates if the state is currently running.

states

const std::set<std::shared_ptr<State> > yasmin::Concurrence::states

protected

The states to run concurrently.

---

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

• yasmin/include/yasmin/concurrence.hpp
• yasmin/src/yasmin/concurrence.cpp