| helics 3.6.1

Namespaces | Classes | Typedefs | Enumerations | Functions | Variables
helics Namespace Reference

the main namespace for the helics co-simulation library User functions will be in the helics namespace with internal functions possible in a lower level namespace More...

## Namespaces
| action_message_def
| BrokerFactory
| CoreFactory

## Classes
class | AsyncFedCallInfo
class | BrokerApp
class | BrokerKeeper
class | CallbackFederate
class | CombinationFederate
class | ConnectorFederateManager
class | CoreApp
class | CoreKeeper
class | data_view
class | Endpoint
class | Federate
class | Interface
class | FederateInfo
class | FilterOperations
class | DelayFilterOperation
class | RandomDelayFilterOperation
class | RandomDropFilterOperation
class | RerouteFilterOperation
class | FirewallFilterOperation
class | CloneFilterOperation
class | Filter
class | CloningFilter
class | IdentifierId
class | NamedPoint
class | Input
class | MessageFederate
class | MessageFederateManager
class | MessageTimeOperator
class | MessageDestOperator
class | MessageDataOperator
class | MessageConditionalOperator
class | CloneOperator
class | FirewallOperator
class | CustomMessageOperator
class | PotentialInterfacesManager
class | Publication
class | VectorSubscription
class | VectorSubscription2d
class | Translator
class | JsonTranslatorOperator
class | BinaryTranslatorOperator
class | CustomTranslatorOperator
class | TranslatorOperations
class | CustomTranslatorOperation
class | JsonTranslatorOperation
class | BinaryTranslatorOperation
class | ValueConverter
class | ValueConverter< std::vector< std::string > >
class | ValueFederate
struct | publication_info
struct | InputData
class | ValueFederateManager
class | MultiBroker
class | LogBuffer
class | ActionMessage
class | AsyncTimeCoordinator
class | BaseTimeCoordinator
class | BasicHandleInfo
class | Broker
class | BrokerBase
class | FedInfo
class | CommonCore
class | Message
class | FilterOperator
class | NullFilterOperator
class | TranslatorOperator
class | NullTranslatorOperator
class | FederateOperator
class | NullFederateOperator
class | HelicsException
class | FunctionExecutionFailure
class | InvalidIdentifier
class | InvalidParameter
class | InvalidConversion
class | InvalidFunctionCall
class | ConnectionFailure
class | RegistrationFailure
class | HelicsSystemFailure
class | FederateError
class | Core
struct | BasicFedInfo
| forward declaration of QueryReuse More...
class | BasicBrokerInfo
class | CoreBroker
class | CoreFederateInfo
class | EmptyCore
struct | EndpointInformation
class | EndpointInfo
class | FederateState
class | FilterCoordinator
class | FilterFederate
struct | EptInformation
class | FilterInfo
class | ForwardingTimeCoordinator
class | GlobalBrokerId
class | GlobalFederateId
class | GlobalHandle
class | route_id
class | GlobalTimeCoordinator
class | HandleManager
class | helicsCLI11App
class | HelicsConfigJSON
| Define a JSON parser for the config files for CLI11. More...
struct | iteration_time
class | InputInfo
class | InterfaceInfo
class | LocalFederateId
class | InterfaceHandle
class | LogManager
class | MessageTimer
class | ProfilerBuffer
struct | SubscriberInformation
class | PublicationInfo
class | SmallBuffer
class | tcoptions
class | TimeCoordinator
class | TimeData
class | DependencyInfo
class | TimeDependencies
struct | linkConnection
class | TimeoutMonitor
class | TranslatorFederate
struct | TransInformation
class | TranslatorInfo
class | UnknownHandleManager
class | CommsBroker
class | CommsInterface
class | ConditionalChangeOnDestroy
class | NetworkBroker
class | NetworkBrokerData
class | NetworkCommsInterface
class | NetworkCore
class | BrokerObject
class | CoreObject
class | AppObject
class | MessageHolder
class | FedObject
class | InputObject
class | PublicationObject
class | EndpointObject
class | FilterObject
class | TranslatorObject
class | QueryObject

## Typedefs
using | defV = std::variant< double, int64_t, std::string, std::complex< double >, std::vector< double >, std::vector< std::complex< double > >, NamedPoint >
using | IdentifierType = std::uint32_t
| specify the underlying type used in the identifiers
using | PublicationId = IdentifierId< IdentifierType, Identifiers::PUBLICATION, invalid_id_value >
using | InputId = IdentifierId< IdentifierType, Identifiers::INPUT, invalid_id_value >
using | QueryId = IdentifierId< IdentifierType, Identifiers::QUERY, invalid_id_value >
template<typename T >
using | remove_cv_ref = std::remove_cv_t< std::remove_reference_t< T > >
| Helper template to remove const volatile references.
template<typename X >
using | typeCategory = std::conditional_t< helicsType< remove_cv_ref< X > >() !=DataType::HELICS_CUSTOM, std::integral_constant< int, primaryType >, std::conditional_t< isConvertableType< remove_cv_ref< X > >(), std::integral_constant< int, convertibleType >, std::integral_constant< int, nonConvertibleType > >>
using | dvalue = std::variant< double, std::string >
using | portData = std::vector< std::tuple< int, bool, std::shared_ptr< Broker > >>
using | activeProtector = gmlc::libguarded::guarded< std::pair< bool, bool > >
using | MapType = std::unordered_map< std::string_view, InterfaceHandle >
using | AliasT = std::unordered_map< std::string_view, std::vector< std::string_view > >
using | Time = TimeRepresentation< count_time< 9 > >
using | IdentifierBaseType = int32_t
using | InterfaceTypes = gmlc::networking::InterfaceTypes

## Enumerations
enum class | RandomDistributions : int { CONSTANT , UNIFORM , BERNOULLI , BINOMIAL , GEOMETRIC , POISSON , EXPONENTIAL , GAMMA , WEIBULL , EXTREME_VALUE , NORMAL , LOGNORMAL , CHI_SQUARED , CAUCHY , FISHER_F , STUDENT_T }
enum class | FilterTypes { CUSTOM = HELICS_FILTER_TYPE_CUSTOM , DELAY = HELICS_FILTER_TYPE_DELAY , RANDOM_DELAY = HELICS_FILTER_TYPE_RANDOM_DELAY , RANDOM_DROP = HELICS_FILTER_TYPE_RANDOM_DROP , REROUTE = HELICS_FILTER_TYPE_REROUTE , CLONE = HELICS_FILTER_TYPE_CLONE , FIREWALL = HELICS_FILTER_TYPE_FIREWALL , UNRECOGNIZED = 7 }
enum | TypeLocation : decltype(std::declval< defV >().index()) { double_loc = 0U , int_loc = 1U , string_loc = 2U , complex_loc = 3U , vector_loc = 4U , complex_vector_loc = 5U , named_point_loc = 6U }
enum class | Identifiers : char { PUBLICATION = 'p' , INPUT = 'i' , FILTER = 'f' , ENDPOINT = 'e' , QUERY = 'q' , TRANSLATORS = 't' }
enum class | InterfaceVisibility { LOCAL , GLOBAL }
enum class | DataType : int { HELICS_UNKNOWN = HELICS_DATA_TYPE_UNKNOWN , HELICS_STRING = HELICS_DATA_TYPE_STRING , HELICS_DOUBLE = HELICS_DATA_TYPE_DOUBLE , HELICS_INT = HELICS_DATA_TYPE_INT , HELICS_COMPLEX = HELICS_DATA_TYPE_COMPLEX , HELICS_VECTOR = HELICS_DATA_TYPE_VECTOR , HELICS_COMPLEX_VECTOR = HELICS_DATA_TYPE_COMPLEX_VECTOR , HELICS_NAMED_POINT = HELICS_DATA_TYPE_NAMED_POINT , HELICS_BOOL = HELICS_DATA_TYPE_BOOLEAN , HELICS_TIME = HELICS_DATA_TYPE_TIME , HELICS_CHAR = HELICS_DATA_TYPE_CHAR , HELICS_CUSTOM = HELICS_DATA_TYPE_RAW , HELICS_ANY = HELICS_DATA_TYPE_ANY , HELICS_JSON = HELICS_DATA_TYPE_JSON , HELICS_MULTI = HELICS_DATA_TYPE_MULTI }
enum | MultiInputHandlingMethod : uint16_t { NO_OP = HELICS_MULTI_INPUT_NO_OP , VECTORIZE_OPERATION = HELICS_MULTI_INPUT_VECTORIZE_OPERATION , AND_OPERATION = HELICS_MULTI_INPUT_AND_OPERATION , OR_OPERATION = HELICS_MULTI_INPUT_OR_OPERATION , SUM_OPERATION = HELICS_MULTI_INPUT_SUM_OPERATION , DIFF_OPERATION = HELICS_MULTI_INPUT_DIFF_OPERATION , MAX_OPERATION = HELICS_MULTI_INPUT_MAX_OPERATION , MIN_OPERATION = HELICS_MULTI_INPUT_MIN_OPERATION , AVERAGE_OPERATION = HELICS_MULTI_INPUT_AVERAGE_OPERATION }
enum | TranslatorTypes : std::int32_t { CUSTOM = HELICS_TRANSLATOR_TYPE_CUSTOM , CUSTOM = HELICS_FILTER_TYPE_CUSTOM , JSON = HELICS_TRANSLATOR_TYPE_JSON , BINARY = HELICS_TRANSLATOR_TYPE_BINARY , UNRECOGNIZED = 7 , UNRECOGNIZED = 7 }
enum class | JsonErrorCodes : std::int32_t { BAD_REQUEST = 400 , FORBIDDEN = 403 , NOT_FOUND = 404 , METHOD_NOT_ALLOWED = 405 , TIMEOUT = 408 , DISCONNECTED = 410 , INTERNAL_ERROR = 500 , NOT_IMPLEMENTED = 501 , BAD_GATEWAY = 502 , SERVICE_UNAVAILABLE = 503 , GATEWAY_TIMEOUT = 504 }
enum | LogLevels : int { DUMPLOG = HELICS_LOG_LEVEL_DUMPLOG , NO_PRINT = HELICS_LOG_LEVEL_NO_PRINT , ERROR_LEVEL = HELICS_LOG_LEVEL_ERROR , PROFILING = HELICS_LOG_LEVEL_PROFILING , WARNING = HELICS_LOG_LEVEL_WARNING , SUMMARY = HELICS_LOG_LEVEL_SUMMARY , CONNECTIONS , INTERFACES , TIMING = HELICS_LOG_LEVEL_TIMING , DATA = HELICS_LOG_LEVEL_DATA , DEBUG = HELICS_LOG_LEVEL_DEBUG , TRACE = HELICS_LOG_LEVEL_TRACE , FED = 99999 }
enum | CommandErrorCodes : int { lost_server_connection_code = -5 , connection_error_code = -2 , already_init_error_code = 5 , duplicate_federate_name_error_code = 6 , duplicate_broker_name_error_code = 7 , mismatch_broker_key_error_code = 9 , max_federate_count_exceeded = 11 , max_broker_count_exceeded = 13 , broker_terminating = 14 , multiple_wait_for_current_time_flags = 15 , duplicate_federate_id = 17 }
enum class | OperatingState : std::uint8_t { OPERATING = 0 , ERROR_STATE = 5 , DISCONNECTED = 10 }
enum class | ConnectionState : std::uint8_t { CONNECTED = 0 , INIT_REQUESTED = 1 , OPERATING = 2 , ERROR_STATE = 40 , REQUEST_DISCONNECT = 48 , DISCONNECTED = 50 }
enum class | FederateStates : std::uint8_t { CREATED , INITIALIZING , EXECUTING , TERMINATING , ERRORED , FINISHED , UNKNOWN }
enum class | CoreThreading : std::uint8_t { DEFAULT = HELICS_CORE_TYPE_DEFAULT , MULTI = HELICS_FLAG_MULTI_THREAD_CORE , SINGLE = HELICS_FLAG_SINGLE_THREAD_CORE }
enum class | CoreType : int { DEFAULT = HELICS_CORE_TYPE_DEFAULT , ZMQ = HELICS_CORE_TYPE_ZMQ , MPI = HELICS_CORE_TYPE_MPI , TEST = HELICS_CORE_TYPE_TEST , INTERPROCESS = HELICS_CORE_TYPE_INTERPROCESS , IPC = HELICS_CORE_TYPE_IPC , TCP = HELICS_CORE_TYPE_TCP , TCP_SS = HELICS_CORE_TYPE_TCP_SS , UDP = HELICS_CORE_TYPE_UDP , NNG = HELICS_CORE_TYPE_NNG , ZMQ_SS = HELICS_CORE_TYPE_ZMQ_SS , HTTP = HELICS_CORE_TYPE_HTTP , WEBSOCKET = HELICS_CORE_TYPE_WEBSOCKET , INPROC = HELICS_CORE_TYPE_INPROC , NULLCORE = HELICS_CORE_TYPE_NULL , EMPTY = HELICS_CORE_TYPE_EMPTY , UNRECOGNIZED = 22 , MULTI = 45 , EXTRACT = HELICS_CORE_TYPE_EXTRACT }
enum class | MessageProcessingResult : std::int8_t { CONTINUE_PROCESSING = -2 , DELAY_MESSAGE = -1 , NEXT_STEP = 0 , ITERATING = 2 , HALTED = 3 , USER_RETURN = 5 , ERROR_RESULT = 7 , REPROCESS_MESSAGE = 8 , BUSY = 10 }
enum class | IterationResult : signed char { NEXT_STEP = 0 , ITERATING = 2 , HALTED = 3 , ERROR_RESULT = 7 }
enum class | IterationRequest : signed char { NO_ITERATIONS = 0 , FORCE_ITERATION = 1 , ITERATE_IF_NEEDED = 2 , HALT_OPERATIONS = 3 , ERROR_CONDITION = 7 }
enum class | InterfaceType : char { UNKNOWN = 'u' , PUBLICATION = 'p' , INPUT = 'i' , ENDPOINT = 'e' , FILTER = 'f' , TRANSLATOR = 't' , SINK = 's' }
enum class | TimeSynchronizationMethod : uint8_t { DISTRIBUTED = 0 , GLOBAL = 1 , ASYNC = 2 }
| enumeration of possible time coordination methods
enum | GeneralFlags : uint16_t { error_flag = 4 , indicator_flag = 5 }
enum | TimingFlags : uint16_t { iteration_requested_flag = 0 , non_granting_flag = 7 , interrupted_flag = 8 , delayed_timing_flag = 10 , parent_flag = 13 , child_flag = 14 }
| flags used in timing messages More...
enum | InterfaceFlags : uint16_t { buffer_data_flag = 0 , destination_target = 1 , required_flag = 2 , single_connection_flag = 3 , only_update_on_change_flag = 6 , reconnectable_flag = 7 , optional_flag = 8 , only_transmit_on_change_flag = 12 , nameless_interface_flag = 15 }
| flags used on handles More...
enum | EndpointFlags { targeted_flag = 10 , has_source_filter_flag = 11 , source_only_flag = 13 , receive_only_flag = 14 }
| enumeration of endpoint specific flags More...
enum | FilterFlags { clone_flag = 9 , has_dest_filter_flag = 13 , has_non_cloning_dest_filter_flag = 14 }
| enumeration of filter specific flags More...
enum | ConnectionFlags : uint16_t { core_flag = 3 , global_timing_flag = 5 , use_json_serialization_flag = 6 , async_timing_flag = 7 , observer_flag = 8 , dynamic_join_flag = 9 , reentrant_flag = 10 , global_disconnect_flag = 11 , disconnected_flag = 12 , test_connection_flag = 13 , slow_responding_flag = 14 , non_counting_flag = 15 }
| flags used when connecting a federate/core/broker to a federation More...
enum | MessageFlags : uint16_t { filter_processing_required_flag = 7 , user_custom_message_flag1 = 10 , destination_processing_flag = 11 , user_custom_message_flag2 = 13 , user_custom_message_flag3 = 14 , empty_flag = 15 }
| flags used for messages More...
enum | OperationFlags : uint16_t { cancel_flag = 13 }
| general flags used for other operations More...
enum | Subqueries : std::uint16_t { GENERAL_QUERY = 0 , FEDERATE_MAP = 1 , CURRENT_TIME_MAP = 2 , DEPENDENCY_GRAPH = 3 , DATA_FLOW_GRAPH = 4 , VERSION_ALL = 5 , GLOBAL_STATE = 6 , GLOBAL_TIME_DEBUGGING = 7 , GLOBAL_FLUSH = 8 , GLOBAL_STATUS = 9 , BARRIERS = 11 , UNCONNECTED_INTERFACES = 14 }
| enumeration of subqueries that cascade and need multiple levels of processing
enum class | QueryReuse : std::uint8_t { ENABLED = 0 , DISABLED = 1 }
| Enumeration of if query result is reusable.
enum class | TimeState : std::uint8_t { initialized = 0 , exec_requested_require_iteration = 1 , exec_requested_iterative = 2 , exec_requested = 3 , time_granted = 5 , time_requested_require_iteration = 6 , time_requested_iterative = 7 , time_requested = 8 , error = 10 }
enum class | ConnectionType : std::uint8_t { INDEPENDENT = 0 , PARENT = 1 , CHILD = 2 , SELF = 3 , NONE = 4 }
enum class | TimeProcessingResult : std::uint8_t { NOT_PROCESSED = 0 , PROCESSED = 1 , PROCESSED_AND_CHECK = 2 , PROCESSED_NEW_REQUEST = 3 , DELAY_PROCESSING = 5 }
enum class | GrantDelayMode : std::uint8_t { NONE = 0 , INTERRUPTED = 1 , WAITING = 2 }
enum class | FederateType : int { GENERIC , VALUE , MESSAGE , COMBINATION , CALLBACK , INVALID }

## Functions
template<>
const char * | typeNameString< std::vector< SmallBuffer > > ()
void | cleanupHelicsLibrary ()
int | getPropertyIndex (std::string val)
int | getFlagIndex (std::string val)
int | getOptionIndex (std::string val)
int | getOptionValue (std::string val)
FederateInfo | loadFederateInfo (const std::string &configString)
std::string | generateFullCoreInitString (const FederateInfo &fedInfo)
double | randDouble (RandomDistributions dist, double param1, double param2)
std::string | newDestGeneration (const std::string &src, const std::string &dest, std::string formula)
FilterTypes | filterTypeFromString (std::string_view filterType) noexcept
void | addOperations (Filter *filt, FilterTypes type, Core *)
Filter & | make_filter (FilterTypes type, Federate *mFed, std::string_view name)
Filter & | make_filter (InterfaceVisibility locality, FilterTypes type, Federate *mFed, std::string_view name)
std::unique_ptr< Filter > | make_filter (FilterTypes type, Core *core, std::string_view name)
std::unique_ptr< Filter > | make_filter (FilterTypes type, CoreApp &core, std::string_view name)
CloningFilter & | make_cloning_filter (FilterTypes type, Federate *mFed, std::string_view delivery, std::string_view name)
CloningFilter & | make_cloning_filter (InterfaceVisibility locality, FilterTypes type, Federate *mFed, std::string_view delivery, std::string_view name)
std::unique_ptr< CloningFilter > | make_cloning_filter (FilterTypes type, Core *core, std::string_view delivery, std::string_view name)
std::unique_ptr< CloningFilter > | make_cloning_filter (FilterTypes type, CoreApp &core, std::string_view delivery, std::string_view name)
bool | changeDetected (const defV &prevValue, const std::string &val, double)
bool | changeDetected (const defV &prevValue, std::string_view val, double)
bool | isTrueString (const std::string_view str)
bool | changeDetected (const defV &prevValue, bool val, double)
bool | changeDetected (const defV &prevValue, const std::vector< double > &val, double deltaV)
bool | changeDetected (const defV &prevValue, const std::vector< std::complex< double >> &val, double deltaV)
bool | changeDetected (const defV &prevValue, const double *vals, size_t size, double deltaV)
bool | changeDetected (const defV &prevValue, const std::complex< double > &val, double deltaV)
bool | changeDetected (const defV &prevValue, double val, double deltaV)
bool | changeDetected (const defV &prevValue, Time val, double deltaV)
bool | changeDetected (const defV &prevValue, int64_t val, double deltaV)
bool | changeDetected (const defV &prevValue, const NamedPoint &val, double deltaV)
void | valueExtract (const defV &data, std::string &val)
void | valueExtract (const defV &data, std::complex< double > &val)
void | valueExtract (const defV &data, std::vector< double > &val)
void | valueExtract (const defV &data, std::vector< std::complex< double >> &val)
void | valueExtract (const defV &data, NamedPoint &val)
void | valueExtract (const defV &data, Time &val)
void | valueExtract (const defV &data, char &val)
void | valueExtract (const defV &data, bool &val)
defV | readJsonValue (const data_view &data)
void | valueExtract (const data_view &data, DataType baseType, std::string &val)
void | valueExtract (const data_view &data, DataType baseType, std::vector< double > &val)
void | valueExtract (const data_view &data, DataType baseType, std::vector< std::complex< double >> &val)
void | valueExtract (const data_view &data, DataType baseType, std::complex< double > &val)
void | valueExtract (const data_view &data, DataType baseType, NamedPoint &val)
void | valueExtract (const data_view &data, DataType baseType, Time &val)
void | valueExtract (const data_view &data, DataType baseType, bool &val)
void | valueExtract (const data_view &data, DataType baseType, char &val)
void | valueExtract (const data_view &data, DataType baseType, defV &val)
void | valueConvert (defV &val, DataType newType)
SmallBuffer | typeConvertDefV (DataType type, const defV &val)
SmallBuffer | typeConvertDefV (const defV &val)
int64_t | make_valid (bool obj)
int64_t | make_valid (uint64_t val)
int64_t | make_valid (int16_t val)
int64_t | make_valid (uint16_t val)
int64_t | make_valid (char val)
int64_t | make_valid (unsigned char val)
int64_t | make_valid (int32_t val)
int64_t | make_valid (uint32_t val)
int64_t | make_valid (Time val)
double | make_valid (float val)
std::complex< double > | make_valid (const std::complex< float > &val)
template<class X >
decltype(auto) | make_valid (X &&obj)
template<class X >
std::enable_if_t< std::is_arithmetic< X >::value &&(!std::is_same< X, char >::value)> | valueExtract (const defV &data, X &val)
template<class X >
std::enable_if_t< std::is_arithmetic< X >::value &&(!std::is_same< X, char >::value)> | valueExtract (const data_view &data, DataType baseType, X &val)
const std::string & | typeNameStringRef (DataType type)
double | vectorNorm (const std::vector< double > &vec)
double | vectorNorm (const double *vec, std::size_t size)
double | vectorNorm (const std::vector< std::complex< double >> &vec)
std::string | helicsComplexString (double real, double imag)
std::string | helicsComplexString (std::complex< double > val)
DataType | getTypeFromString (std::string_view typeName)
std::string_view | getCleanedTypeName (std::string_view typeName)
const std::regex | creg (R"(([+-]?(\d+(\.\d+)?|\.\d+)([eE][+-]?\d+)?)\s*([+-]\s*(\d+(\.\d+)?|\.\d+)([eE][+-]?\d+)?)[ji]*)")
std::complex< double > | helicsGetComplex (std::string_view val)
std::string | helicsIntString (std::int64_t val)
std::string | helicsDoubleString (double val)
std::string | helicsVectorString (const std::vector< double > &val)
std::string | helicsVectorString (const double *vals, size_t size)
std::string | helicsComplexVectorString (const std::vector< std::complex< double >> &val)
std::string | helicsNamedPointString (const NamedPoint &point)
std::string | helicsNamedPointString (std::string_view pointName, double val)
std::vector< double > | helicsGetVector (std::string_view val)
std::vector< std::complex< double > > | helicsGetComplexVector (std::string_view val)
NamedPoint | helicsGetNamedPoint (std::string_view val)
std::complex< double > | getComplexFromString (std::string_view val)
std::int64_t | getIntFromString (std::string_view val)
double | getDoubleFromString (std::string_view val)
void | helicsGetVector (std::string_view val, std::vector< double > &data)
void | helicsGetComplexVector (std::string_view val, std::vector< std::complex< double >> &data)
bool | helicsBoolValue (std::string_view val)
SmallBuffer | emptyBlock (DataType outputType, DataType inputType=DataType::HELICS_ANY)
SmallBuffer | typeConvert (DataType type, double val)
SmallBuffer | typeConvert (DataType type, int64_t val)
SmallBuffer | typeConvert (DataType type, std::string_view val)
SmallBuffer | typeConvert (DataType type, const std::vector< double > &val)
SmallBuffer | typeConvert (DataType type, const double *vals, size_t size)
SmallBuffer | typeConvertComplex (DataType type, const double *vals, size_t size)
SmallBuffer | typeConvert (DataType type, const std::vector< std::complex< double >> &val)
SmallBuffer | typeConvert (DataType type, const std::complex< double > &val)
SmallBuffer | typeConvert (DataType type, const NamedPoint &val)
SmallBuffer | typeConvert (DataType type, std::string_view str, double val)
SmallBuffer | typeConvert (DataType type, bool val)
SmallBuffer | typeConvert (DataType type, char val)
SmallBuffer | typeConvert (DataType type, Time val)
template<class X >
constexpr const char * | typeNameString ()
template<>
constexpr const char * | typeNameString< std::vector< std::string > > ()
template<>
constexpr const char * | typeNameString< std::vector< double > > ()
template<>
constexpr const char * | typeNameString< std::vector< std::complex< double > > > ()
template<>
constexpr const char * | typeNameString< double > ()
template<>
constexpr const char * | typeNameString< float > ()
template<>
constexpr const char * | typeNameString< bool > ()
template<>
constexpr const char * | typeNameString< char > ()
template<>
constexpr const char * | typeNameString< unsigned char > ()
template<>
constexpr const char * | typeNameString< std::int32_t > ()
template<>
constexpr const char * | typeNameString< std::uint32_t > ()
template<>
constexpr const char * | typeNameString< int64_t > ()
template<>
constexpr const char * | typeNameString< std::uint64_t > ()
template<>
constexpr const char * | typeNameString< std::complex< float > > ()
template<>
constexpr const char * | typeNameString< std::complex< double > > ()
template<>
constexpr const char * | typeNameString< std::string > ()
template<>
constexpr const char * | typeNameString< NamedPoint > ()
constexpr bool | isBytesType (DataType type)
template<class X >
constexpr DataType | helicsType ()
template<>
constexpr DataType | helicsType< int64_t > ()
template<>
constexpr DataType | helicsType< bool > ()
template<>
constexpr DataType | helicsType< std::string > ()
template<>
constexpr DataType | helicsType< NamedPoint > ()
template<>
constexpr DataType | helicsType< double > ()
template<>
constexpr DataType | helicsType< Time > ()
template<>
constexpr DataType | helicsType< std::complex< double > > ()
template<>
constexpr DataType | helicsType< std::vector< double > > ()
template<>
constexpr DataType | helicsType< std::vector< std::complex< double > > > ()
template<class X >
constexpr bool | isConvertableType ()
template<>
constexpr bool | isConvertableType< float > ()
template<>
constexpr bool | isConvertableType< long double > ()
template<>
constexpr bool | isConvertableType< int32_t > ()
template<>
constexpr bool | isConvertableType< int16_t > ()
template<>
constexpr bool | isConvertableType< uint16_t > ()
template<>
constexpr bool | isConvertableType< char > ()
template<>
constexpr bool | isConvertableType< unsigned char > ()
template<>
constexpr bool | isConvertableType< uint64_t > ()
template<class X >
X | invalidValue ()
template<>
constexpr double | invalidValue< double > ()
template<>
constexpr int64_t | invalidValue< int64_t > ()
template<>
constexpr uint64_t | invalidValue< uint64_t > ()
template<>
constexpr Time | invalidValue< Time > ()
template<>
NamedPoint | invalidValue< NamedPoint > ()
template<>
constexpr std::complex< double > | invalidValue< std::complex< double > > ()
template<class X >
X | varMax (const std::vector< defV > &vals)
template<class X , class Y , typename OP >
Y | varDiff (const std::vector< defV > &vals, const OP &op)
template<class X >
size_t | varMaxIndex (const std::vector< defV > &vals, std::function< double(const X &)> op)
template<class X >
X | varMin (const std::vector< defV > &vals)
template<class X >
size_t | varMinIndex (const std::vector< defV > &vals, std::function< double(const X &)> op)
double | doubleExtractAndConvert (const data_view &dv, const std::shared_ptr< units::precise_unit > &inputUnits, const std::shared_ptr< units::precise_unit > &outputUnits)
void | integerExtractAndConvert (defV &store, const data_view &dv, const std::shared_ptr< units::precise_unit > &inputUnits, const std::shared_ptr< units::precise_unit > &outputUnits)
bool | checkForNeededCoreRetrieval (std::size_t currentIndex, DataType injectionType, DataType conversionType)
template<class X >
const X & | getValueRefImpl (defV &val)
template<>
const std::string & | getValueRefImpl (defV &val)
std::vector< std::string > | vectorizeQueryResult (std::string_view queryres)
std::vector< int > | vectorizeIndexQuery (std::string_view queryres)
std::vector< std::string > | vectorizeAndSortQueryResult (std::string_view queryres)
bool | waitForInit (helics::Federate *fed, std::string_view fedName, std::chrono::milliseconds timeout)
bool | waitForFed (helics::Federate *fed, std::string_view fedName, std::chrono::milliseconds timeout)
std::string | queryFederateSubscriptions (helics::Federate *fed, std::string_view fedName)
time_units | timeUnitsFromString (std::string_view unitString)
Time | loadTimeFromString (std::string_view timeString)
Time | loadTimeFromString (std::string_view timeString, time_units defUnits)
TranslatorTypes | translatorTypeFromString (std::string_view translatorType) noexcept
void | addOperations (Translator *trans, TranslatorTypes type)
std::string | to_string (CoreType type)
CoreType | coreTypeFromString (std::string_view type) noexcept
bool | isCoreTypeAvailable (CoreType type) noexcept
std::string | systemInfo ()
template<class... Us>
void | publish (ValueFederate &fed, std::string_view pubName, Us... pargs)
int | getTypeSize (const std::string &type)
bool | isBlockSizeValid (int size, const publication_info &pubI)
bool | allowMultiBroker ()
void | processOptions (const toml::value &section, const std::function< int(const std::string &)> &optionConversion, const std::function< int(const std::string &)> &valueConversion, const std::function< void(int, int)> &optionAction)
void | processOptions (const nlohmann::json &section, const std::function< int(const std::string &)> &optionConversion, const std::function< int(const std::string &)> &valueConversion, const std::function< void(int, int)> &optionAction)
void | loadTags (const nlohmann::json &section, const std::function< void(std::string_view, std::string_view)> &tagAction)
void | loadTags (const toml::value &section, const std::function< void(std::string_view, std::string_view)> &tagAction)
template<typename Callable >
bool | addTargets (const toml::value &section, std::string targetName, Callable callback)
template<typename Callable >
bool | addTargets (const nlohmann::json &section, std::string targetName, Callable callback)
template<typename Block , typename Callable >
void | addTargetVariations (const Block &section, const std::string &name1, std::string name2, Callable callback)
std::string | generateJsonQuotedString (const std::string &string)
std::string | generateJsonErrorResponse (JsonErrorCodes code, const std::string &message)
void | bufferToJson (const LogBuffer &buffer, nlohmann::json &base)
LogLevels | logLevelFromString (std::string_view level)
std::string | logLevelToString (LogLevels level)
template<std::size_t DataSize>
void | swap_bytes (std::uint8_t *data)
std::unique_ptr< Message > | createMessageFromCommand (const ActionMessage &cmd)
std::unique_ptr< Message > | createMessageFromCommand (ActionMessage &&cmd)
const char * | actionMessageType (action_message_def::action_t action)
const char * | commandErrorString (int errorCode)
std::string | errorMessageString (const ActionMessage &command)
std::string | prettyPrintString (const ActionMessage &command)
std::ostream & | operator<< (std::ostream &out, const ActionMessage &command)
int | appendMessage (ActionMessage &multiMessage, const ActionMessage &newMessage)
void | setIterationFlags (ActionMessage &command, IterationRequest iterate)
bool | operator< (const ActionMessage &cmd, const ActionMessage &cmd2)
bool | isProtocolCommand (const ActionMessage &command) noexcept
bool | isPriorityCommand (const ActionMessage &command) noexcept
bool | isTimingCommand (const ActionMessage &command) noexcept
bool | isDependencyCommand (const ActionMessage &command) noexcept
bool | isDisconnectCommand (const ActionMessage &command) noexcept
bool | isErrorCommand (const ActionMessage &command) noexcept
bool | isIgnoreableCommand (const ActionMessage &command) noexcept
bool | isValidCommand (const ActionMessage &command) noexcept
const std::string & | brokerStateName (BrokerBase::BrokerState state)
const std::string & | stateString (OperatingState state)
template<class sizeType , class SizedDataType >
bool | isValidIndex (sizeType testSize, const SizedDataType &vec)
std::string_view | interfaceTypeName (InterfaceType type) noexcept
const std::string & | fedStateString (FederateStates state)
bool | returnableResult (MessageProcessingResult result)
template<class FlagContainer , class FlagIndex >
void | setActionFlag (FlagContainer &M, FlagIndex flag)
template<class FlagIndex >
bool | checkActionFlag (uint16_t flags, FlagIndex flag)
template<class FlagContainer , class FlagIndex >
bool | checkActionFlag (const FlagContainer &M, FlagIndex flag)
template<class FlagContainer , class FlagIndex >
void | clearActionFlag (FlagContainer &M, FlagIndex flag)
template<class FlagContainer , class FlagIndex >
void | toggleActionFlag (FlagContainer &M, FlagIndex flag)
constexpr uint16_t | make_flags (unsigned int flag)
constexpr uint16_t | make_flags (unsigned int flag1, unsigned int flag2)
constexpr uint16_t | make_flags (unsigned int flag1, unsigned int flag2, unsigned int flag3)
constexpr uint16_t | toggle_flag (uint16_t base, unsigned int flag)
std::ostream & | operator<< (std::ostream &os, GlobalBrokerId id)
constexpr GlobalFederateId | getSpecialFederateId (GlobalBrokerId broker, GlobalBrokerId::BaseType index)
std::ostream & | operator<< (std::ostream &os, GlobalFederateId id)
std::ostream & | operator<< (std::ostream &os, GlobalHandle id)
constexpr route_id | generateRouteId (int32_t route_type_code, int32_t index)
constexpr int32_t | getRouteTypeCode (route_id rid)
std::ostream & | operator<< (std::ostream &os, route_id id)
HelicsConfigJSON * | addJsonConfig (CLI::App *app)
| Add the HELICS JSON configuration processor to the app.
bool | checkTypeMatch (std::string_view type1, std::string_view type2, bool strict_match)
bool | checkUnitMatch (const std::string &unit1, const std::string &unit2, bool strict_match)
std::ostream & | operator<< (std::ostream &os, LocalFederateId fid)
std::ostream & | operator<< (std::ostream &os, InterfaceHandle handle)
constexpr LocalFederateId | gLocalCoreId (-259)
void | addFederateTags (nlohmann::json &v, const FederateState *fed)
nlohmann::json | generateInterfaceConfig (const helics::HandleManager &hm, const helics::GlobalFederateId &fed)
void | generateInterfaceConfig (nlohmann::json &iblock, const helics::HandleManager &hm, const helics::GlobalFederateId &fed)
std::string | generateInterfaceQueryResults (std::string_view request, const HandleManager &handles, const GlobalFederateId fed, const std::function< void(nlohmann::json &)> &addHeaderInfo)
std::string | generateInterfaceQueryResults (std::string_view request, const InterfaceInfo &info, const std::function< void(nlohmann::json &)> &addHeaderInfo)
bool | operator== (const SmallBuffer &sb1, const SmallBuffer &sb2)
bool | operator!= (const SmallBuffer &sb1, const SmallBuffer &sb2)
std::tuple< FederateStates, MessageProcessingResult, bool > | processCoordinatorMessage (ActionMessage &cmd, TimeCoordinator *timeCoord, const FederateStates state, const bool timeGranted_mode, const GlobalFederateId localID)
void | addTimeState (nlohmann::json &output, const TimeState state)
void | generateJsonOutputTimeData (nlohmann::json &output, const TimeData &dep, bool includeAggregates)
void | generateJsonOutputDependency (nlohmann::json &output, const DependencyInfo &dep)
const DependencyInfo & | getExecEntryMinFederate (const TimeDependencies &dependencies, GlobalFederateId self, ConnectionType ignoreType, GlobalFederateId ignore)
TimeData | generateMinTimeUpstream (const TimeDependencies &dependencies, bool restricted, GlobalFederateId self, GlobalFederateId ignore, std::int32_t responseCode)
TimeData | generateMinTimeDownstream (const TimeDependencies &dependencies, bool restricted, GlobalFederateId self, GlobalFederateId ignore, std::int32_t responseCode)
TimeData | generateMinTimeTotal (const TimeDependencies &dependencies, bool restricted, GlobalFederateId self, GlobalFederateId ignore, std::int32_t responseCode)
GrantDelayMode | getDelayMode (bool waiting, bool interrupted)
bool | checkSequenceCounter (const DependencyInfo &dep, Time tmin, std::int32_t sq)
template<typename ContainerT , typename PredicateT >
void | maperase_if (ContainerT &items, const PredicateT &predicate)
bool | loadCores ()
constexpr const char * | tcodeStr (int tcode)
int | getDefaultPort (int coreType)
FedObject * | getFedObject (HelicsFederate fed, HelicsError *err) noexcept
AppObject * | getAppObject (HelicsApp app, HelicsError *err) noexcept
CoreObject * | getCoreObject (HelicsCore core, HelicsError *err) noexcept
BrokerObject * | getBrokerObject (HelicsBroker broker, HelicsError *err) noexcept

## Variables
constexpr auto | bvecstr = "block_vector"
constexpr IdentifierType | invalid_id_value
| defining an invalid id value More...
constexpr double | invalidDouble = HELICS_INVALID_DOUBLE
| defined constant for an invalid value as a double
constexpr int | primaryType = 0
constexpr int | convertibleType = 1
constexpr int | nonConvertibleType = 2
constexpr std::string_view | emptyString {""}
const std::unordered_map< std::string, int > | gLogLevelMap
const std::map< LogLevels, std::string_view > | levelMaps
constexpr auto | LEADING_CHAR = '\xF3'
constexpr auto | TAIL_CHAR1 = '\xFA'
constexpr auto | TAIL_CHAR2 = '\xFC'
constexpr int | targetStringLoc {0}
constexpr int | sourceStringLoc {1}
constexpr int | unitStringLoc {1}
constexpr int | origSourceStringLoc {2}
constexpr int | origDestStringLoc {3}
constexpr int | typeStringLoc {0}
constexpr int | typeOutStringLoc {1}
constexpr int32_t | cmd_info_basis {65536}
constexpr char | universalKey [] = "**"
constexpr Time | startupTime = Time::minVal()
constexpr Time | initialTime {-1000000.0}
constexpr IdentifierBaseType | gGlobalFederateIdShift {0x0002'0000}
constexpr IdentifierBaseType | gGlobalBrokerIdShift {0x7000'0000}
constexpr IdentifierBaseType | gGlobalPriorityBlockSize {100'000'000}
constexpr GlobalBrokerId | parent_broker_id {0}
constexpr GlobalBrokerId | gRootBrokerID {1}
constexpr GlobalFederateId | gDirectCoreId {-235262}
constexpr route_id | parent_route_id {0}
constexpr route_id | control_route {-1}
constexpr int32_t | normal_route_code {0}
constexpr int32_t | json_route_code {10}
constexpr Time | timeZero = Time::zeroVal()
constexpr Time | timeEpsilon = Time::epsilon()
constexpr Time | negEpsilon = -Time::epsilon()
constexpr Time | cBigTime = Time{static_cast<int64_t>(HELICS_BIG_NUMBER * 1000000)}
constexpr Time | initializationTime = negEpsilon
constexpr auto | versionString = HELICS_VERSION_STRING
constexpr int | versionMajor = HELICS_VERSION_MAJOR
constexpr int | versionMinor = HELICS_VERSION_MINOR
constexpr int | versionPatch = HELICS_VERSION_PATCH
constexpr auto | versionBuild = HELICS_VERSION_BUILD
constexpr auto | buildFlags = HELICS_BUILD_FLAGS_DEBUG
constexpr auto | compiler = HELICS_COMPILER_VERSION
constexpr InterfaceHandle | gDirectSendHandle
| this special handle can be used to directly send a message in a core More...
constexpr const char * | tstr []
constexpr const char * | defInterface []
constexpr const char * | defBrokerInterface []
constexpr const char * | defLocalInterface [] = {"127.0.0.1", "127.0.0.1", "tcp://127.0.0.1", "", ""}

## Detailed Description

the main namespace for the helics co-simulation library User functions will be in the helics namespace with internal functions possible in a lower level namespace

HELICS Application API

the core namespace for the helics C++ library all user functions are found in this namespace along with many other functions in the Core API

## Typedef Documentation

## ◆ defV

using helics::defV = typedef std::variant<double, int64_t, std::string, std::complex<double>, std::vector<double>, std::vector<std::complex<double> >, NamedPoint>

define a variant with the different types

## ◆ IdentifierBaseType

using helics::IdentifierBaseType = typedef int32_t

base date type for id types

## ◆ Time

using helics::Time = typedef TimeRepresentation<count_time<9> >

Simulation virtual time.

Class represents time in the core.

## ◆ typeCategory

template<typename X >

using helics::typeCategory = typedef std::conditional_t<helicsType<remove_cv_ref<X> >() != DataType::HELICS_CUSTOM, std::integral_constant<int, primaryType>, std::conditional_t<isConvertableType<remove_cv_ref<X> >(), std::integral_constant<int, convertibleType>, std::integral_constant<int, nonConvertibleType> >>

template dividing types into 3 categories 0 is primary types 1 types convertible to primary types 2 type not convertible to primary types

## Enumeration Type Documentation

## ◆ ConnectionFlags

enum helics::ConnectionFlags : uint16_t

flags used when connecting a federate/core/broker to a federation

Enumerator
core_flag | flag indicating that message comes from a core vs a broker
global_timing_flag | flag indicating to use global timing (overload of indicator flag)
use_json_serialization_flag | flag to indicate it should use the json packetization
async_timing_flag | flag indicating use of asynchronous timing on a global level
observer_flag | flag indicating that the connection is an observer only
dynamic_join_flag | flag indicating that the connection allows joining dynamically
reentrant_flag | flag indicating that the connection may be reentrant
global_disconnect_flag | flag indicating that global disconnect synchronize is in use
disconnected_flag | flag indicating that a broker/federate is disconnected
test_connection_flag | flag indicating this is a test connection
slow_responding_flag | flag indicating a federate, core or broker is slow responding
non_counting_flag | flag indicating that a federate should not count in any totals

## ◆ ConnectionState

enum helics::ConnectionState : std::uint8_t
| strong

enumeration of possible states of a remote federate or broker

## ◆ ConnectionType

enum helics::ConnectionType : std::uint8_t
| strong

enumeration of the different connection arrangements

## ◆ CoreThreading

enum helics::CoreThreading : std::uint8_t
| strong

enumeration of the threading options for a core

Enumerator
DEFAULT | choose the default based on federate options
MULTI | specify the core should be multithreaded
SINGLE | specify a single threaded core

## ◆ CoreType

enum helics::CoreType : int
| strong

the type of the cores that are available

Enumerator
DEFAULT | ZMQ if available or UDP. pick a core type depending on compile configuration usually either
ZMQ | use the Zero MQ networking protocol
MPI | use MPI for operation on a parallel cluster
TEST | use the Test core if all federates are in the same process
INTERPROCESS | use when all federates are on the same machine interprocess uses memory mapped files to transfer data (for
IPC | same as INTERPROCESS
TCP | use a generic TCP protocol message stream to send messages
TCP_SS | a single socket version of the TCP core for more easily handling firewalls
UDP | use UDP packets to send the data
NNG | reserved for future Nanomsg implementation
ZMQ_SS | single socket version of ZMQ core for better scalability performance
HTTP | core/broker using web traffic
WEBSOCKET | core/broker using web sockets
INPROC | core/broker using a stripped down in process core type
NULLCORE | explicit core type that doesn't exist
EMPTY | core type that does nothing and can't communicate
UNRECOGNIZED | unknown
MULTI | use the multi-broker
EXTRACT | extract core type from later arguments/files

## ◆ DataType

enum helics::DataType : int
| strong

the base types for helics

## ◆ EndpointFlags

enum helics::EndpointFlags

enumeration of endpoint specific flags

Enumerator
targeted_flag | flag indicating an endpoint is targeted
has_source_filter_flag | indicator that an endpoint or message has a source filter
source_only_flag | indicator that an endpoint is source only
receive_only_flag | indicator that an endpoint is receive only

## ◆ FederateStates

enum helics::FederateStates : std::uint8_t
| strong

enumeration of the possible federate states

Enumerator
INITIALIZING | state upon creation, all registration calls are allowed the federation has entered initialization state and initial values can be published
EXECUTING | the federation has entered execution state and it now advancing in time
TERMINATING | the federate is in the process of shutting down
ERRORED | the federation has encountered an error
FINISHED | the federation has finished its execution
UNKNOWN | unknown state

## ◆ FederateType

enum helics::FederateType : int
| strong

type code embedded in the objects so the library knows how to cast them appropriately

## ◆ FilterFlags

enum helics::FilterFlags

enumeration of filter specific flags

Enumerator
clone_flag | flag indicating the filter is a clone filter or the data needs to be cloned
has_dest_filter_flag | indicator that an endpoint or message has a destination filter
has_non_cloning_dest_filter_flag | indicator that the endpoint or filter has a destination filter that alters the message

## ◆ FilterTypes

enum helics::FilterTypes
| strong

a set of common defined filters

## ◆ GeneralFlags

enum helics::GeneralFlags : uint16_t

flag definitions for the action Message Flag field

Enumerator
error_flag | flag indicating an error condition associated with the command
indicator_flag | flag used for setting values

## ◆ GrantDelayMode

enum helics::GrantDelayMode : std::uint8_t
| strong

enumeration of delay modes which affect whether a time is granted or not

## ◆ Identifiers

enum helics::Identifiers : char
| strong

the known types of identifiers

## ◆ InterfaceFlags

enum helics::InterfaceFlags : uint16_t

flags used on handles

Enumerator
buffer_data_flag | indicator that the interface should buffer data
destination_target | indicator that the target is a destination target
required_flag | flag indicating that an action or match is required
single_connection_flag | flag indicating that the interface accepts only a single connection
only_update_on_change_flag | flag indicating that the values should only be updated on change
reconnectable_flag | flag indicating that the target is mapped
optional_flag | flag indicating that a connection is optional and may not be matched
only_transmit_on_change_flag | indicator that the interface should only transmit on change
nameless_interface_flag | flag to indicate an interface is nameless

## ◆ InterfaceType

enum helics::InterfaceType : char
| strong

define the type of the handle

Enumerator
PUBLICATION | handle to output interface
INPUT | handle to a input interface
ENDPOINT | handle to an endpoint
FILTER | handle to a filter
TRANSLATOR | handle to a translator object
SINK | handle to a data sink

## ◆ InterfaceVisibility

enum helics::InterfaceVisibility
| strong

enumeration of locality namespaces

## ◆ IterationRequest

enum helics::IterationRequest : signed char
| strong

enumeration of the possible iteration requests by a federate

Enumerator
NO_ITERATIONS | indicator that the iterations have completed
FORCE_ITERATION | force an iteration whether it is needed or not
ITERATE_IF_NEEDED | indicator that the iterations need to continue
HALT_OPERATIONS | indicator that the federate should halt
ERROR_CONDITION | indicator that the federate has errored and co-simulation should stop

## ◆ IterationResult

enum helics::IterationResult : signed char
| strong

enumeration of the possible states of iteration

Enumerator
NEXT_STEP | indicator that the iterations have completed and the federate has moved to the next step
ITERATING | indicator that the iterations need to continue
HALTED | indicator that the simulation has been halted
ERROR_RESULT | indicator that an error has occurred

## ◆ LogLevels

enum helics::LogLevels : int

enumeration of defined print levels

Enumerator
DUMPLOG | only for dumplog
NO_PRINT | never print
ERROR_LEVEL | only print errors
PROFILING | profiling log level
WARNING | print/log warning and errors
SUMMARY | print/log summary information
CONNECTIONS | print summary+federate level connection information
INTERFACES | print connections+interface level connection information
TIMING | print interfaces+timing(exec/grant/disconnect)
DATA | print timing+data transmissions
DEBUG | print data+additional debug info
TRACE | trace level printing (all processed messages)
FED | special logging command for message coming from a fed

## ◆ MessageFlags

enum helics::MessageFlags : uint16_t

flags used for messages

Enumerator
filter_processing_required_flag | flag indicating that the message requires processing for filters yet
user_custom_message_flag1 | custom message flag 1
destination_processing_flag | flag indicating the message is for destination processing
user_custom_message_flag2 | flag indicating the message is empty custom message flag 2
user_custom_message_flag3 | custom message flag 3

## ◆ MessageProcessingResult

enum helics::MessageProcessingResult : std::int8_t
| strong

enumeration of the possible message processing results

Enumerator
CONTINUE_PROCESSING | the current loop should continue
DELAY_MESSAGE | delay the current message and continue processing
NEXT_STEP | indicator that the iterations have completed
ITERATING | indicator that the iterations need to continue
HALTED | indicator that the simulation has been halted
USER_RETURN | indicator that there was a return request but no other conditions or issues
ERROR_RESULT | indicator that an error has occurred

## ◆ OperatingState

enum helics::OperatingState : std::uint8_t
| strong

enumeration of possible operating conditions for a federate

## ◆ OperationFlags

enum helics::OperationFlags : uint16_t

general flags used for other operations

Enumerator
cancel_flag | flag indicating an operation is canceled

## ◆ RandomDistributions

enum helics::RandomDistributions : int
| strong

enumeration of possible random number generator distributions

## ◆ TimeProcessingResult

enum helics::TimeProcessingResult : std::uint8_t
| strong

enumeration of the possible time message processing results

Enumerator
NOT_PROCESSED | the message did not result in an update
PROCESSED | the message was used to update the current state
PROCESSED_AND_CHECK | the message was used to update the current state and additional checks should be made
PROCESSED_NEW_REQUEST | the message was used to update the current state and a new request was made
DELAY_PROCESSING | the message should be delayed and reprocessed later

## ◆ TimeState

enum helics::TimeState : std::uint8_t
| strong

enumeration of possible states for a federate to be in regards to time request

## ◆ TimingFlags

enum helics::TimingFlags : uint16_t

flags used in timing messages

Enumerator
iteration_requested_flag | indicator that an iteration has been requested
non_granting_flag | flag to indicate the request is from a non-granting federate
interrupted_flag | flag to mark an interrupted event
delayed_timing_flag | flag to indicate the request is from federate with delayed timing
parent_flag | flag indicating the message is from a parent object
child_flag | flag indicating a message is from a child object

## ◆ TranslatorTypes

enum helics::TranslatorTypes : std::int32_t

a set of common defined translators

## ◆ TypeLocation

enum helics::TypeLocation : decltype(std::declval< defV >().index())

enumeration of the index value of the types inside the defV variant

## Function Documentation

## ◆ actionMessageType()

const char * helics::actionMessageType | ( | action_message_def::action_t | action | ) |

return the name of the action

Parameters

  action | The action to get the name for

Returns
  a pointer to string with the name

Referenced by prettyPrintString().

## ◆ addOperations() [1/2]

void helics::addOperations | ( | Filter * | filt,
|  | FilterTypes | type,
|  | Core * |
| ) |  |

add a defined operation to a filter

Referenced by make_cloning_filter().

## ◆ addOperations() [2/2]

void helics::addOperations | ( | Translator * | trans,
|  | TranslatorTypes | type
| ) |  |

add a defined operation to a translator

## ◆ appendMessage()

int helics::appendMessage | ( | ActionMessage & | multiMessage,
|  | const ActionMessage & | newMessage
| ) |  |

append a multiMessage to multi multiMessage container

Parameters

  multiMessage | the multiMessage to add the extra multiMessage to
  newMessage | the multiMessage to append

Returns
  the integer location of the multiMessage in the stringData section

References helics::ActionMessage::action(), helics::ActionMessage::counter, and helics::ActionMessage::to_string().

Referenced by helics::BaseTimeCoordinator::disconnect(), helics::TimeCoordinator::localError(), and helics::CommonCore::setValue().

## ◆ brokerStateName()

const std::string & helics::brokerStateName | ( | BrokerBase::BrokerState | state | ) |

helper function to generate the name of a state as a string

## ◆ bufferToJson()

void helics::bufferToJson | ( | const LogBuffer & | buffer,
|  | nlohmann::json & | base
| ) |  |

helper function to write a log buffer to a json object

Referenced by helics::CommonCore::query(), and helics::CoreBroker::query().

## ◆ changeDetected()

HELICS_CXX_EXPORT bool helics::changeDetected | ( | const defV & | prevValue,
|  | const std::string & | val,
|  | double | deltaV
| ) |  |

detect a change from the previous values

Referenced by helics::Publication::publish(), and helics::Publication::publishComplex().

## ◆ checkActionFlag() [1/2]

template<class FlagContainer , class FlagIndex >

bool helics::checkActionFlag | ( | const FlagContainer & | M,
|  | FlagIndex | flag
| ) |  |
| inline

template function to check a flag in an object containing a flags field

## ◆ checkActionFlag() [2/2]

template<class FlagIndex >

bool helics::checkActionFlag | ( | uint16_t | flags,
|  | FlagIndex | flag
| ) |  |
| inline

check a flag value on a specified index template function to check a flag in an object containing a flags field

Referenced by helics::CommonCore::addDestinationTarget(), helics::CommonCore::addSourceTarget(), helics::CommonCore::closeHandle(), helics::FilterFederate::destinationProcessMessage(), errorMessageString(), helicsMessageGetFlagOption(), prettyPrintString(), helics::TimeCoordinator::processConfigUpdateMessage(), helics::BaseTimeCoordinator::processDependencyUpdateMessage(), helics::FilterFederate::processFilterReturn(), helics::FilterFederate::processMessageFilter(), helics::CommonCore::sendMessage(), helics::CommonCore::sendTo(), helics::CommonCore::sendToAt(), helics::FederateState::setInterfaceProperty(), helics::FederateState::setProperties(), helics::CommonCore::setValue(), helics::ActionMessage::to_string(), and toggleActionFlag().

## ◆ cleanupHelicsLibrary()

HELICS_CXX_EXPORT void helics::cleanupHelicsLibrary | ( |  | ) |

function to do some housekeeping work

this runs some cleanup routines and tries to close out any residual thread that haven't been shutdown yet

References helics::BrokerFactory::cleanUpBrokers(), and helics::CoreFactory::cleanUpCores().

Referenced by helicsCleanupLibrary(), and helicsCloseLibrary().

## ◆ clearActionFlag()

template<class FlagContainer , class FlagIndex >

void helics::clearActionFlag | ( | FlagContainer & | M,
|  | FlagIndex | flag
| ) |  |
| inline

template function to clear a flag in an object containing a flags field

Referenced by helicsMessageSetFlagOption(), and toggleActionFlag().

## ◆ commandErrorString()

const char * helics::commandErrorString | ( | int | errorCode | ) |

return a string associated with a particular error code

Parameters

  [in,out] | errorCode | The error to get the string for

Returns
  a pointer to string with the name

Referenced by errorMessageString().

## ◆ coreTypeFromString()

HELICS_CXX_EXPORT CoreType helics::coreTypeFromString | ( | std::string_view | type | ) |
| noexcept

generate a core type value from a std::string

Parameters

  type | a string describing the desired core type

Returns
  a value of the helics::CoreType enumeration helics::CoreType::unrecognized if the type is not valid

## ◆ createMessageFromCommand() [1/2]

std::unique_ptr< Message > helics::createMessageFromCommand | ( | ActionMessage && | cmd | ) |

create a new multiMessage object that moves all the information from the ActionMessage into newly allocated memory for the multiMessage

## ◆ createMessageFromCommand() [2/2]

std::unique_ptr< Message > helics::createMessageFromCommand | ( | const ActionMessage & | cmd | ) |

create a new multiMessage object that copies all the information from the ActionMessage into newly allocated memory for the multiMessage

Referenced by helics::FilterFederate::destinationProcessMessage(), and helics::FilterFederate::processMessageFilter().

## ◆ doubleExtractAndConvert()

HELICS_CXX_EXPORT double helics::doubleExtractAndConvert | ( | const data_view & | dv,
|  | const std::shared_ptr< units::precise_unit > & | inputUnits,
|  | const std::shared_ptr< units::precise_unit > & | outputUnits
| ) |  |

convert a dataview to a double and do a unit conversion if appropriate

References helics::ValueConverter< X >::interpret().

## ◆ errorMessageString()

std::string helics::errorMessageString | ( | const ActionMessage & | command | ) |

generate a string representing an error from an ActionMessage

Parameters

  command | the command to generate the error string for

Returns
  a string describing the error, if the string is not an error the string is empty

References checkActionFlag(), commandErrorString(), error_flag, and helics::ActionMessage::messageID.

## ◆ fedStateString()

const std::string & helics::fedStateString | ( | FederateStates | state | ) |

convert the state into a human readable string

Referenced by helics::FederateState::logMessage(), and helics::FederateState::processQuery().

## ◆ filterTypeFromString()

HELICS_CXX_EXPORT FilterTypes helics::filterTypeFromString | ( | std::string_view | filterType | ) |
| noexcept

get the filter type from a string

## ◆ generateFullCoreInitString()

HELICS_CXX_EXPORT std::string helics::generateFullCoreInitString | ( | const FederateInfo & | fedInfo | ) |

generate string for passing arguments to the core

References helics::FederateInfo::autobroker, helics::FederateInfo::broker, helics::FederateInfo::brokerInitString, helics::FederateInfo::brokerPort, helics::FederateInfo::configString, helics::FederateInfo::coreInitString, helics::FederateInfo::debugging, helics::FederateInfo::encrypted, helics::FederateInfo::encryptionConfig, helics::FederateInfo::key, helics::FederateInfo::localport, helics::FederateInfo::profilerFileName, and helics::FederateInfo::useJsonSerialization.

## ◆ generateInterfaceQueryResults()

std::string helics::generateInterfaceQueryResults | ( | std::string_view | request,
|  | const HandleManager & | handles,
|  | const GlobalFederateId | fed,
|  | const std::function< void(nlohmann::json &)> & | addHeaderInfo
| ) |  |

generate results from a query related to interfaces

References ENDPOINT, FILTER, INPUT, helics::GlobalFederateId::isValid(), PUBLICATION, and TRANSLATOR.

## ◆ generateJsonErrorResponse()

std::string helics::generateJsonErrorResponse | ( | JsonErrorCodes | code,
|  | const std::string & | message
| ) |  |
| inline

generate a json error response string

Referenced by helics::CommonCore::query(), helics::EmptyCore::query(), helics::CoreApp::query(), helics::CoreBroker::query(), and helics::Federate::queryComplete().

## ◆ getBrokerObject()

BrokerObject * helics::getBrokerObject | ( | HelicsBroker | broker,
|  | HelicsError * | err
| ) |  |
| noexcept

get the brokerObject from a HelicsBroker and verify it is valid

References HELICS_ERROR_INVALID_OBJECT.

Referenced by helicsBrokerClone(), helicsBrokerFree(), and helicsBrokerIsValid().

## ◆ getCleanedTypeName()

HELICS_CXX_EXPORT std::string_view helics::getCleanedTypeName | ( | std::string_view | typeName | ) |

convert to a string and also get a cleaned view of the string if it were a specific typeid

returns the input if not changed

References getCleanedTypeName(), and typeNameStringRef().

Referenced by getCleanedTypeName(), and helics::ValueFederateManager::registerInput().

## ◆ getComplexFromString()

HELICS_CXX_EXPORT std::complex< double > helics::getComplexFromString | ( | std::string_view | val | ) |

get a complex number from a string

References getComplexFromString(), helicsGetComplex(), and helicsGetVector().

Referenced by getComplexFromString(), and valueExtract().

## ◆ getCoreObject()

CoreObject * helics::getCoreObject | ( | HelicsCore | core,
|  | HelicsError * | err
| ) |  |
| noexcept

get the CoreObject from a HelicsCore and verify it is valid

References HELICS_ERROR_INVALID_OBJECT.

Referenced by helicsCoreClone(), helicsCoreFree(), and helicsCoreIsValid().

## ◆ getDoubleFromString()

HELICS_CXX_EXPORT double helics::getDoubleFromString | ( | std::string_view | val | ) |

get a double from a string

References getDoubleFromString().

Referenced by getDoubleFromString(), getIntFromString(), and valueExtract().

## ◆ getFedObject()

FedObject * helics::getFedObject | ( | HelicsFederate | fed,
|  | HelicsError * | err
| ) |  |
| noexcept

get the FedObject from a HelicsBroker and verify it is valid

References HELICS_ERROR_INVALID_OBJECT.

Referenced by helicsFederateClearMessages(), helicsFederateClone(), helicsFederateCreateMessage(), helicsFederateFree(), helicsFederateGetCommand(), helicsFederateGetCommandSource(), helicsFederateGetMessage(), helicsFederateProtect(), helicsFederateRegisterEndpoint(), helicsFederateRegisterGlobalEndpoint(), helicsFederateRegisterGlobalTargetedEndpoint(), helicsFederateRegisterTargetedEndpoint(), and helicsFederateWaitCommand().

## ◆ getFlagIndex()

HELICS_CXX_EXPORT int helics::getFlagIndex | ( | std::string | val | ) |

get a flag index from a string name of the flag

Parameters

  val | a name of a flag option to get an integer index code for use in /ref CoreFederateInfo::setFlagOption

Returns
  the integer code for a given flag

Referenced by getPropertyIndex(), and helicsGetFlagIndex().

## ◆ getIntFromString()

HELICS_CXX_EXPORT std::int64_t helics::getIntFromString | ( | std::string_view | val | ) |

get an int from a string

References getDoubleFromString(), and getIntFromString().

Referenced by getIntFromString(), and valueExtract().

## ◆ getOptionIndex()

HELICS_CXX_EXPORT int helics::getOptionIndex | ( | std::string | val | ) |

get an integer option index for a binary flag option

Parameters

  val | a name of flag option to get an integer index code for used in /ref CoreFederateInfo::setOptionFlag

Returns
  the integer code for a given property (-1) if not found

Referenced by helicsGetOptionIndex().

## ◆ getOptionValue()

HELICS_CXX_EXPORT int helics::getOptionValue | ( | std::string | val | ) |

get a numerical value for a string option value

Parameters

  val | a value from an enumeration or flag used as part of a value

Returns
  the integer code of a given option value (-1) if not found

Referenced by helicsGetOptionValue().

## ◆ getPropertyIndex()

HELICS_CXX_EXPORT int helics::getPropertyIndex | ( | std::string | val | ) |

get an integer/time property/flag from a string name of the property or flag

Parameters

  val | a name of property to get an integer index code for used in /ref CoreFederateInfo::setProperty

Returns
  the integer code for a given property

References getFlagIndex().

Referenced by helicsGetPropertyIndex().

## ◆ getSpecialFederateId()

constexpr GlobalFederateId helics::getSpecialFederateId | ( | GlobalBrokerId | broker,
|  | GlobalBrokerId::BaseType | index
| ) |  |
| constexpr

generate a special federate id for a broker/core

References helics::GlobalBrokerId::baseValue(), gGlobalBrokerIdShift, and gRootBrokerID.

## ◆ getTypeFromString()

HELICS_CXX_EXPORT DataType helics::getTypeFromString | ( | std::string_view | typeName | ) |

convert a string to a type

References getTypeFromString().

Referenced by getTypeFromString(), helicsGetDataType(), and helics::Publication::Publication().

## ◆ gLocalCoreId()

constexpr LocalFederateId helics::gLocalCoreId | ( | - | 259 | ) |
| constexpr

constant to use for indicating that a command is for the core itself from the Core Public API

Referenced by helics::CoreFactory::abortAllCores(), helics::CommonCore::getFederateTag(), helics::CommonCore::getFlagOption(), helics::CommonCore::getIntegerProperty(), helics::CoreApp::getTag(), helics::CoreApp::globalError(), helics::CoreApp::haltInit(), helicsCoreGlobalError(), helics::CommonCore::logMessage(), helics::CommonCore::registerCloningFilter(), helics::CommonCore::registerFilter(), helics::CommonCore::registerTranslator(), helics::CommonCore::setCoreReadyToInit(), helics::CommonCore::setFederateTag(), helics::CommonCore::setFlagOption(), helics::CommonCore::setIntegerProperty(), helics::CommonCore::setLoggingCallback(), and helics::CoreApp::setTag().

## ◆ helicsBoolValue()

HELICS_CXX_EXPORT bool helics::helicsBoolValue | ( | std::string_view | val | ) |

get the boolean value of a string

References helicsBoolValue().

Referenced by helicsBoolValue(), and valueExtract().

## ◆ helicsComplexString() [1/2]

HELICS_CXX_EXPORT std::string helics::helicsComplexString | ( | double | real,
|  | double | imag
| ) |  |

generate a string representation of a complex number from separate real and imaginary parts

References helicsComplexString().

Referenced by helicsComplexString(), and valueExtract().

## ◆ helicsComplexString() [2/2]

HELICS_CXX_EXPORT std::string helics::helicsComplexString | ( | std::complex< double > | val | ) |

generate a string representation of a complex number

References helicsComplexString().

## ◆ helicsComplexVectorString()

HELICS_CXX_EXPORT std::string helics::helicsComplexVectorString | ( | const std::vector< std::complex< double >> & | val | ) |

generate a string representation of a complex vector

string will look like cv[1.02+2j,45]

References helicsComplexVectorString().

Referenced by helicsComplexVectorString(), and valueExtract().

## ◆ helicsDoubleString()

HELICS_CXX_EXPORT std::string helics::helicsDoubleString | ( | double | val | ) |

generate a string representation of a double

References helicsDoubleString().

Referenced by helicsDoubleString(), and typeConvert().

## ◆ helicsGetComplex()

HELICS_CXX_EXPORT std::complex< double > helics::helicsGetComplex | ( | std::string_view | val | ) |

convert a string to a complex number

References helicsGetComplex().

Referenced by getComplexFromString(), helicsGetComplex(), helicsGetComplexVector(), and helics::apps::PhasorGenerator::setString().

## ◆ helicsGetComplexVector() [1/2]

HELICS_CXX_EXPORT std::vector< std::complex< double > > helics::helicsGetComplexVector | ( | std::string_view | val | ) |

convert a string to a complex vector

References helicsGetComplexVector().

Referenced by helicsGetComplexVector(), and valueExtract().

## ◆ helicsGetComplexVector() [2/2]

HELICS_CXX_EXPORT void helics::helicsGetComplexVector | ( | std::string_view | val,
|  | std::vector< std::complex< double >> & | data
| ) |  |

convert a string to a complex vector using an existing vector

References helicsGetComplex(), helicsGetComplexVector(), and invalidValue().

## ◆ helicsGetNamedPoint()

HELICS_CXX_EXPORT NamedPoint helics::helicsGetNamedPoint | ( | std::string_view | val | ) |

convert a string to a named point

References helicsGetNamedPoint(), helics::NamedPoint::name, and helics::NamedPoint::value.

Referenced by helicsGetNamedPoint(), and valueExtract().

## ◆ helicsGetVector()

HELICS_CXX_EXPORT std::vector< double > helics::helicsGetVector | ( | std::string_view | val | ) |

convert a string to a vector

References helicsGetVector().

Referenced by getComplexFromString(), helicsGetVector(), and valueExtract().

## ◆ helicsIntString()

HELICS_CXX_EXPORT std::string helics::helicsIntString | ( | std::int64_t | val | ) |

generate a string representation of an int

References helicsIntString().

Referenced by helicsIntString().

## ◆ helicsNamedPointString()

HELICS_CXX_EXPORT std::string helics::helicsNamedPointString | ( | const NamedPoint & | point | ) |

generate a named point string

string will look like {"<name>":val}

References helicsNamedPointString(), helics::NamedPoint::name, and helics::NamedPoint::value.

Referenced by helicsNamedPointString(), and valueExtract().

## ◆ helicsType()

template<class X >

constexpr DataType helics::helicsType | ( |  | ) |
| constexpr

template function for generating a known name of a type

## ◆ helicsVectorString() [1/2]

HELICS_CXX_EXPORT std::string helics::helicsVectorString | ( | const double * | vals,
|  | size_t | size
| ) |  |

generate a string representation of a vector from pointer and size

string will look like v[1.02,45]

References helicsVectorString().

## ◆ helicsVectorString() [2/2]

HELICS_CXX_EXPORT std::string helics::helicsVectorString | ( | const std::vector< double > & | val | ) |

generate a string representation of a vector

string will look like v[1.02,45]

References helicsVectorString().

Referenced by helicsVectorString(), and valueExtract().

## ◆ invalidValue()

template<class X >

X helics::invalidValue | ( |  | ) |
| inline

generate an invalid value for the various types

Referenced by helicsGetComplexVector().

## ◆ isBlockSizeValid()

bool helics::isBlockSizeValid | ( | int | size,
|  | const publication_info & | pubI
| ) |  |
| inline

function to check if the size is valid for the given type

References isBlockSizeValid(), and helics::publication_info::size.

Referenced by isBlockSizeValid().

## ◆ isCoreTypeAvailable()

HELICS_CXX_EXPORT bool helics::isCoreTypeAvailable | ( | CoreType | type | ) |
| noexcept

Returns true if core/broker type specified is available in current compilation.

## ◆ isDisconnectCommand()

bool helics::isDisconnectCommand | ( | const ActionMessage & | command | ) |
| inline noexcept

check if a command is a disconnect command

Referenced by isIgnoreableCommand().

## ◆ isErrorCommand()

bool helics::isErrorCommand | ( | const ActionMessage & | command | ) |
| inline noexcept

check if a command is an error command

Referenced by isIgnoreableCommand().

## ◆ isIgnoreableCommand()

bool helics::isIgnoreableCommand | ( | const ActionMessage & | command | ) |
| inline noexcept

check if the command can be ignored by a missing route

References isDisconnectCommand(), and isErrorCommand().

## ◆ isPriorityCommand()

bool helics::isPriorityCommand | ( | const ActionMessage & | command | ) |
| inline noexcept

check if a command is a priority command

References helics::action_message_def::cmd_ignore.

Referenced by helics::BrokerBase::addActionMessage(), and helics::CommsInterface::transmit().

## ◆ isProtocolCommand()

bool helics::isProtocolCommand | ( | const ActionMessage & | command | ) |
| inline noexcept

check if a command is a protocol command

Referenced by helics::NetworkCommsInterface::generateReplyToIncomingMessage().

## ◆ isTrueString()

HELICS_CXX_EXPORT bool helics::isTrueString | ( | std::string_view | str | ) |

detect if a string is not a string that represents false

## ◆ isValidCommand()

bool helics::isValidCommand | ( | const ActionMessage & | command | ) |
| inline noexcept

check if a command is a valid command

References helics::action_message_def::cmd_invalid.

## ◆ isValidIndex()

template<class sizeType , class SizedDataType >

bool helics::isValidIndex | ( | sizeType | testSize,
|  | const SizedDataType & | vec
| ) |  |
| inline

helper template to check whether an index is actually valid for a particular vector

Template Parameters

  SizedDataType | a vector like data type that must have a size function

Parameters

  testSize | an index to test
  vec | a reference to a vector like object that has a size method

Returns
  true if it is a valid index false otherwise

Referenced by helics::HandleManager::addHandleAtIndex(), helics::MultiBroker::addRoute(), helics::InputInfo::getData(), helics::HandleManager::getHandleInfo(), helics::ValueFederateManager::getInput(), helics::HandleManager::getInterfaceHandle(), helics::apps::Clone::getMessage(), helics::apps::Recorder::getMessage(), helics::apps::Clone::getValue(), helics::apps::Recorder::getValue(), and helics::apps::Player::runTo().

## ◆ loadCores()

bool helics::loadCores | ( |  | ) |

load the available core and Broker types into the factory

## ◆ loadFederateInfo()

HELICS_CXX_EXPORT FederateInfo helics::loadFederateInfo | ( | const std::string & | configString | ) |

generate a FederateInfo object from a config file or string (JSON, TOML)

Referenced by helicsCreateApp().

## ◆ loadTimeFromString() [1/2]

HELICS_CXX_EXPORT Time helics::loadTimeFromString | ( | std::string_view | timeString | ) |

generate a time from a string

the string can be a double or with units for example "1.234", or "1032ms" or "10423425 ns"

Returns
  a helics time generated from the string

Exceptions

  invalid_argument | if the string is not a valid time

## ◆ loadTimeFromString() [2/2]

HELICS_CXX_EXPORT Time helics::loadTimeFromString | ( | std::string_view | timeString,
|  | time_units | defUnit
| ) |  |

generate a time from a string

the string can be a double or with units for example "1.234" or "1032ms"

Parameters

  timeString | the string containing the time
  defUnit | the units to apply to a string with no other units specified

Returns
  a helics time generated from the string

Exceptions

  invalid_argument | if the string is not a valid time

## ◆ make_cloning_filter() [1/4]

HELICS_CXX_EXPORT std::unique_ptr< CloningFilter > helics::make_cloning_filter | ( | FilterTypes | type,
|  | Core * | core,
|  | std::string_view | delivery,
|  | std::string_view | name = `EMPTY_STRING`
| ) |  |

create a cloning filter with a delivery location

Parameters

  type | the type of filter to create
  core | the core to create the filter through
  delivery | the endpoint to deliver the cloned message to
  name | the name of the filter (optional)

Returns
  a unique pointer to a source Filter object, note destroying the object does not deactivate the filter

References addOperations().

## ◆ make_cloning_filter() [2/4]

HELICS_CXX_EXPORT std::unique_ptr< CloningFilter > helics::make_cloning_filter | ( | FilterTypes | type,
|  | CoreApp & | core,
|  | std::string_view | delivery,
|  | std::string_view | name = `EMPTY_STRING`
| ) |  |

create a cloning filter with a delivery location

Parameters

  type | the type of filter to create
  core | the core to create the filter through
  delivery | the endpoint to deliver the cloned message to
  name | the name of the filter (optional)

Returns
  a unique pointer to a source Filter object, note destroying the object does not deactivate the filter

References helics::CoreApp::getCopyofCorePointer(), and make_cloning_filter().

## ◆ make_cloning_filter() [3/4]

HELICS_CXX_EXPORT CloningFilter & helics::make_cloning_filter | ( | FilterTypes | type,
|  | Federate * | fed,
|  | std::string_view | delivery,
|  | std::string_view | name = `EMPTY_STRING`
| ) |  |

create a filter

Parameters

  type | the type of filter to create
  fed | the federate to create the filter through
  delivery | the endpoint to deliver the cloned message to
  name | the name of the filter (optional)

Returns
  a unique pointer to a destination Filter object, note destroying the object does not deactivate the filter

References addOperations(), helics::Federate::getCorePointer(), and helics::Federate::registerCloningFilter().

Referenced by helicsCoreRegisterCloningFilter(), helicsFederateRegisterCloningFilter(), helicsFederateRegisterGlobalCloningFilter(), make_cloning_filter(), and helics::ConnectorFederateManager::registerCloningFilter().

## ◆ make_cloning_filter() [4/4]

HELICS_CXX_EXPORT CloningFilter & helics::make_cloning_filter | ( | InterfaceVisibility | locality,
|  | FilterTypes | type,
|  | Federate * | fed,
|  | std::string_view | delivery,
|  | std::string_view | name = `EMPTY_STRING`
| ) |  |

create a cloning filter with a specified visibility

Parameters

  locality | can be global or local
  type | the type of filter to create
  fed | the federate to create the filter through
  delivery | the endpoint to deliver the cloned message to
  name | the name of the filter (optional)

Returns
  a unique pointer to a destination Filter object, note destroying the object does not deactivate the filter

## ◆ make_filter() [1/4]

HELICS_CXX_EXPORT std::unique_ptr< Filter > helics::make_filter | ( | FilterTypes | type,
|  | Core * | core,
|  | std::string_view | name = `EMPTY_STRING`
| ) |  |

create a filter

Parameters

  type | the type of filter to create
  core | the core to create the filter through
  name | the name of the filter (optional)

Returns
  a unique pointer to a source Filter object, note destroying the object does not deactivate the filter

## ◆ make_filter() [2/4]

HELICS_CXX_EXPORT std::unique_ptr< Filter > helics::make_filter | ( | FilterTypes | type,
|  | CoreApp & | core,
|  | std::string_view | name = `EMPTY_STRING`
| ) |  |

create a filter

Parameters

  type | the type of filter to create
  core | the core to create the filter through
  name | the name of the filter (optional)

Returns
  a unique pointer to a source Filter object, note destroying the object does not deactivate the filter

References helics::CoreApp::getCopyofCorePointer(), and make_filter().

## ◆ make_filter() [3/4]

HELICS_CXX_EXPORT Filter & helics::make_filter | ( | FilterTypes | type,
|  | Federate * | fed,
|  | std::string_view | name = `EMPTY_STRING`
| ) |  |

create a filter

Parameters

  type | the type of filter to create
  fed | the federate to create the filter through
  name | the name of the filter (optional)

Returns
  a unique pointer to a destination Filter object, note destroying the object does not deactivate the filter

Referenced by helicsCoreRegisterFilter(), helicsFederateRegisterFilter(), helicsFederateRegisterGlobalFilter(), make_filter(), and helics::ConnectorFederateManager::registerFilter().

## ◆ make_filter() [4/4]

HELICS_CXX_EXPORT Filter & helics::make_filter | ( | InterfaceVisibility | locality,
|  | FilterTypes | type,
|  | Federate * | fed,
|  | std::string_view | name = `EMPTY_STRING`
| ) |  |

create a filter

Parameters

  locality | the visibility of the filter global or local
  type | the type of filter to create
  fed | the federate to create the filter through
  name | the name of the filter (optional)

Returns
  a unique pointer to a destination Filter object, note destroying the object does not deactivate the filter

## ◆ make_flags() [1/3]

constexpr uint16_t helics::make_flags | ( | unsigned int | flag | ) |
| inline constexpr

helper function to facilitate make a flag variable

Referenced by helics::UnknownHandleManager::hasNonOptionalUnknowns(), helics::UnknownHandleManager::hasRequiredUnknowns(), make_flags(), helics::UnknownHandleManager::processNonOptionalUnknowns(), helics::UnknownHandleManager::processRequiredUnknowns(), helics::CommonCore::registerCloningFilter(), helics::CommonCore::registerDataSink(), helics::CommonCore::registerTargetedEndpoint(), and toggle_flag().

## ◆ make_flags() [2/3]

constexpr uint16_t helics::make_flags | ( | unsigned int | flag1,
|  | unsigned int | flag2
| ) |  |
| inline constexpr

helper function to facilitate make a flag variable out of two flags

References make_flags().

## ◆ make_flags() [3/3]

constexpr uint16_t helics::make_flags | ( | unsigned int | flag1,
|  | unsigned int | flag2,
|  | unsigned int | flag3
| ) |  |
| inline constexpr

helper function to facilitate make a flag variable out of three flags

References make_flags().

## ◆ make_valid() [1/3]

int64_t helics::make_valid | ( | bool | obj | ) |
| inline

directly convert the boolean to integer

## ◆ make_valid() [2/3]

int64_t helics::make_valid | ( | uint64_t | val | ) |
| inline

directly convert the boolean to integer

## ◆ make_valid() [3/3]

template<class X >

decltype(auto) helics::make_valid | ( | X && | obj | ) |

this template should do nothing for most classes the specific overloads are the important ones

## ◆ operator!=()

bool helics::operator!= | ( | const SmallBuffer & | sb1,
|  | const SmallBuffer & | sb2
| ) |  |
| inline

operator to check if small buffers are not equal to each other

References helics::SmallBuffer::to_string().

## ◆ operator<<() [1/5]

std::ostream & helics::operator<< | ( | std::ostream & | os,
|  | GlobalBrokerId | id
| ) |  |

stream operator for a federate_id

## ◆ operator<<() [2/5]

std::ostream & helics::operator<< | ( | std::ostream & | os,
|  | GlobalFederateId | id
| ) |  |

stream operator for a federate_id

## ◆ operator<<() [3/5]

std::ostream & helics::operator<< | ( | std::ostream & | os,
|  | GlobalHandle | id
| ) |  |

stream operator for a federate_id

## ◆ operator<<() [4/5]

std::ostream & helics::operator<< | ( | std::ostream & | os,
|  | route_id | id
| ) |  |

stream operator for a route_id

## ◆ operator<<() [5/5]

std::ostream & helics::operator<< | ( | std::ostream & | out,
|  | const ActionMessage & | command
| ) |  |

stream operator for a command

References prettyPrintString().

## ◆ operator==()

bool helics::operator== | ( | const SmallBuffer & | sb1,
|  | const SmallBuffer & | sb2
| ) |  |
| inline

operator to check if small buffers are equal to each other

References helics::SmallBuffer::to_string().

## ◆ prettyPrintString()

std::string helics::prettyPrintString | ( | const ActionMessage & | command | ) |

generate a human readable string with information about a command

Parameters

  command | the command to generate the string for

Returns
  a string representing information about the command

References helics::ActionMessage::action(), actionMessageType(), helics::ActionMessage::actionTime, helics::GlobalFederateId::baseValue(), helics::InterfaceHandle::baseValue(), checkActionFlag(), helics::ActionMessage::dest_handle, helics::ActionMessage::dest_id, error_flag, helics::ActionMessage::name(), helics::ActionMessage::payload, helics::SmallBuffer::size(), helics::ActionMessage::source_handle, helics::ActionMessage::source_id, helics::ActionMessage::Tdemin, and helics::ActionMessage::Te.

Referenced by operator<<(), and helics::CommonCore::sendMessage().

## ◆ publish()

template<class... Us>

void helics::publish | ( | ValueFederate & | fed,
|  | std::string_view | pubName,
|  | Us... | pargs
| ) |  |

publish directly from the publication name

this is a convenience function to publish directly from the publication name this function should not be used as the primary means of publications as it does involve an additional map find operation vs the member publish calls

Parameters

  fed | a reference to a valueFederate
  pubName | the name of the publication
  pargs | any combination of arguments that go into the other publish commands

References helics::ValueFederate::getPublication(), and helics::Publication::publish().

## ◆ queryFederateSubscriptions()

HELICS_CXX_EXPORT std::string helics::queryFederateSubscriptions | ( | helics::Federate * | fed,
|  | std::string_view | fedName
| ) |  |

helper function to get a list of all the publications a federate subscribes to

Parameters

  fed | a pointer to the federate
  fedName | the name of the federate we are querying

Returns
  a string vector of the names of the publication that are subscribed to

References HELICS_SEQUENCING_MODE_ORDERED, and helics::Federate::query().

## ◆ returnableResult()

bool helics::returnableResult | ( | MessageProcessingResult | result | ) |
| inline

function to check if the message processing result should be returned or processing continued

References NEXT_STEP.

## ◆ setActionFlag()

template<class FlagContainer , class FlagIndex >

void helics::setActionFlag | ( | FlagContainer & | M,
|  | FlagIndex | flag
| ) |  |
| inline

template function to set a flag in an object containing a flags field

Template Parameters

  FlagContainer | an object with a .flags field
  FlagIndex | a type that can be used as part of a shift to index into a flag object

Parameters

  M | the container to set the flag in
  flag | the flag to set

Referenced by helics::CommonCore::addDestinationFilterToEndpoint(), helics::CoreBroker::addDestinationFilterToEndpoint(), helics::CommonCore::addDestinationTarget(), helics::CommonCore::addSourceTarget(), helics::CoreBroker::clearTimeBarrier(), helics::FilterCoordinator::closeFilter(), helics::CommonCore::closeHandle(), helics::CommonCore::connect(), helics::FederateState::enterExecutingMode(), helics::CommonCore::enterExecutingMode(), helics::TimeCoordinator::enteringExecMode(), helics::BaseTimeCoordinator::generateTimeRequest(), helicsMessageSetFlagOption(), helics::TimeoutMonitor::pingSub(), helics::CommonCore::registerCloningFilter(), helics::CommonCore::registerFederate(), helics::CommonCore::requestTimeIterative(), helics::BaseTimeCoordinator::sendTimingInfo(), helics::TimeCoordinator::sendUpdatedExecRequest(), helics::CommonCore::setFlagOption(), helics::CommonCore::setHandleOption(), setIterationFlags(), helics::CommonCore::setLoggingCallback(), helics::CoreBroker::setLoggingCallback(), helics::CommonCore::timeRequest(), and toggleActionFlag().

## ◆ setIterationFlags()

void helics::setIterationFlags | ( | ActionMessage & | command,
|  | IterationRequest | iterate
| ) |  |

set the flags for an iteration request

References ERROR_CONDITION, error_flag, FORCE_ITERATION, ITERATE_IF_NEEDED, iteration_requested_flag, NO_ITERATIONS, required_flag, and setActionFlag().

Referenced by helics::FederateState::enterExecutingMode(), helics::CommonCore::enterExecutingMode(), helics::TimeCoordinator::enteringExecMode(), helics::CommonCore::enterInitializingMode(), helics::BaseTimeCoordinator::generateTimeRequest(), helics::CommonCore::requestTimeIterative(), and helics::TimeCoordinator::sendUpdatedExecRequest().

## ◆ stateString()

const std::string & helics::stateString | ( | OperatingState | state | ) |

function to print string for the state

## ◆ systemInfo()

HELICS_CXX_EXPORT std::string helics::systemInfo | ( |  | ) |

get a string with the system info

## ◆ timeUnitsFromString()

HELICS_CXX_EXPORT time_units helics::timeUnitsFromString | ( | std::string_view | unitString | ) |

generate a time related unit,

Returns
  a time_units enumeration value

Exceptions

  invalid_argument | if the string is not a valid unit

## ◆ to_string()

HELICS_CXX_EXPORT std::string helics::to_string | ( | CoreType | type | ) |

generate a string based on the core type

## ◆ toggle_flag()

constexpr uint16_t helics::toggle_flag | ( | uint16_t | base,
|  | unsigned int | flag
| ) |  |
| inline constexpr

helper function to toggle a bit in a uint16_t value

References make_flags().

## ◆ toggleActionFlag()

template<class FlagContainer , class FlagIndex >

void helics::toggleActionFlag | ( | FlagContainer & | M,
|  | FlagIndex | flag
| ) |  |
| inline

template function to clear a flag in an object containing a flags field

References checkActionFlag(), clearActionFlag(), and setActionFlag().

## ◆ translatorTypeFromString()

HELICS_CXX_EXPORT TranslatorTypes helics::translatorTypeFromString | ( | std::string_view | translatorType | ) |
| noexcept

get the translator type from a string

## ◆ typeConvert()

HELICS_CXX_EXPORT SmallBuffer helics::typeConvert | ( | DataType | type,
|  | double | val
| ) |  |

convert a value to a data block to be interpreted using the specified type

Parameters

  type | the type used for the data conversion
  val | a double to convert

References helicsDoubleString(), typeConvert(), and typeNameStringRef().

Referenced by helics::Publication::publish(), helics::Publication::publishComplex(), and typeConvert().

## ◆ typeNameString()

template<class X >

constexpr const char* helics::typeNameString | ( |  | ) |
| inline constexpr

template class for generating a known name of a type

## ◆ typeNameString< bool >()

template<>

constexpr const char* helics::typeNameString< bool > | ( |  | ) |
| inline constexpr

for boolean

## ◆ typeNameString< char >()

template<>

constexpr const char* helics::typeNameString< char > | ( |  | ) |
| inline constexpr

for character

## ◆ typeNameString< double >()

template<>

constexpr const char* helics::typeNameString< double > | ( |  | ) |
| inline constexpr

for float

## ◆ typeNameString< float >()

template<>

constexpr const char* helics::typeNameString< float > | ( |  | ) |
| inline constexpr

for float

## ◆ typeNameString< int64_t >()

template<>

constexpr const char* helics::typeNameString< int64_t > | ( |  | ) |
| inline constexpr

for 64 bit unsigned integer

## ◆ typeNameString< std::complex< double > >()

template<>

constexpr const char* helics::typeNameString< std::complex< double > > | ( |  | ) |
| inline constexpr

for complex double

## ◆ typeNameString< std::complex< float > >()

template<>

constexpr const char* helics::typeNameString< std::complex< float > > | ( |  | ) |
| inline constexpr

for complex double

## ◆ typeNameString< std::int32_t >()

template<>

constexpr const char* helics::typeNameString< std::int32_t > | ( |  | ) |
| inline constexpr

for integer

## ◆ typeNameString< std::uint32_t >()

template<>

constexpr const char* helics::typeNameString< std::uint32_t > | ( |  | ) |
| inline constexpr

for unsigned integer

## ◆ typeNameString< std::uint64_t >()

template<>

constexpr const char* helics::typeNameString< std::uint64_t > | ( |  | ) |
| inline constexpr

for 64 bit unsigned integer

## ◆ typeNameString< unsigned char >()

template<>

constexpr const char* helics::typeNameString< unsigned char > | ( |  | ) |
| inline constexpr

for unsigned character

## ◆ typeNameStringRef()

HELICS_CXX_EXPORT const std::string & helics::typeNameStringRef | ( | DataType | type | ) |

sometimes we just need a ref to a string for the basic types

References typeNameStringRef().

Referenced by getCleanedTypeName(), helicsFederateRegisterGlobalInput(), helicsFederateRegisterGlobalPublication(), helicsFederateRegisterInput(), helicsFederateRegisterPublication(), typeConvert(), and typeNameStringRef().

## ◆ valueExtract() [1/10]

template<class X >

std::enable_if_t<std::is_arithmetic<X>::value && (!std::is_same<X, char>::value)> helics::valueExtract | ( | const data_view & | data,
|  | DataType | baseType,
|  | X & | val
| ) |  |

assume it is some numeric type (int or double)

## ◆ valueExtract() [2/10]

HELICS_CXX_EXPORT void helics::valueExtract | ( | const defV & | data,
|  | bool & | val
| ) |  |

extract the value from a variant to a bool

References helicsBoolValue(), and vectorNorm().

## ◆ valueExtract() [3/10]

HELICS_CXX_EXPORT void helics::valueExtract | ( | const defV & | data,
|  | char & | val
| ) |  |

extract the value from a variant to a character

References getDoubleFromString(), and invalidDouble.

## ◆ valueExtract() [4/10]

HELICS_CXX_EXPORT void helics::valueExtract | ( | const defV & | data,
|  | NamedPoint & | val
| ) |  |

extract the value from a variant to a named point

References helicsComplexString(), helicsComplexVectorString(), helicsGetNamedPoint(), helicsVectorString(), helics::NamedPoint::name, and helics::NamedPoint::value.

## ◆ valueExtract() [5/10]

HELICS_CXX_EXPORT void helics::valueExtract | ( | const defV & | data,
|  | std::complex< double > & | val
| ) |  |

extract the value from a variant to a complex number

References getComplexFromString().

## ◆ valueExtract() [6/10]

HELICS_CXX_EXPORT void helics::valueExtract | ( | const defV & | data,
|  | std::string & | val
| ) |  |

extract the value from a variant to a string

References helicsComplexString(), helicsComplexVectorString(), helicsNamedPointString(), and helicsVectorString().

Referenced by helicsPublicationPublishDataBuffer().

## ◆ valueExtract() [7/10]

HELICS_CXX_EXPORT void helics::valueExtract | ( | const defV & | data,
|  | std::vector< double > & | val
| ) |  |

extract the value from a variant to a vector of doubles

References helicsGetVector().

## ◆ valueExtract() [8/10]

HELICS_CXX_EXPORT void helics::valueExtract | ( | const defV & | data,
|  | std::vector< std::complex< double >> & | val
| ) |  |

extract the value from a variant to a complex vector of doubles

References helicsGetComplexVector().

## ◆ valueExtract() [9/10]

HELICS_CXX_EXPORT void helics::valueExtract | ( | const defV & | data,
|  | Time & | val
| ) |  |

extract the value from a variant to a named point

References getDoubleFromString(), getIntFromString(), and timeZero.

## ◆ valueExtract() [10/10]

template<class X >

std::enable_if_t<std::is_arithmetic<X>::value && (!std::is_same<X, char>::value)> helics::valueExtract | ( | const defV & | data,
|  | X & | val
| ) |  |

extract the value from a variant to a numerical type

References getDoubleFromString(), getIntFromString(), and vectorNorm().

## ◆ vectorizeAndSortQueryResult()

HELICS_CXX_EXPORT std::vector< std::string > helics::vectorizeAndSortQueryResult | ( | std::string_view | queryres | ) |

function takes a query result, vectorizes and sorts it if the query is a vector result, if not the results go into the first element of the vector

References vectorizeQueryResult().

## ◆ vectorizeIndexQuery()

HELICS_CXX_EXPORT std::vector< int > helics::vectorizeIndexQuery | ( | std::string_view | queryres | ) |

function takes a query result and vectorizes it if the query is a vector result of integer indices, if not the results are an empty vector

## ◆ vectorizeQueryResult()

HELICS_CXX_EXPORT std::vector< std::string > helics::vectorizeQueryResult | ( | std::string_view | queryres | ) |

function takes a query result and vectorizes it if the query is a vector result, if not the results go into the first element of the vector

Referenced by helics::apps::Probe::initialize(), and vectorizeAndSortQueryResult().

## ◆ vectorNorm() [1/2]

HELICS_CXX_EXPORT double helics::vectorNorm | ( | const std::vector< double > & | vec | ) |

compute the L2 norm of a vector

References vectorNorm().

Referenced by valueExtract(), and vectorNorm().

## ◆ vectorNorm() [2/2]

HELICS_CXX_EXPORT double helics::vectorNorm | ( | const std::vector< std::complex< double >> & | vec | ) |

compute the L2 norm of a magnitudes of a complex vector

References vectorNorm().

## ◆ waitForFed()

HELICS_CXX_EXPORT bool helics::waitForFed | ( | helics::Federate * | fed,
|  | std::string_view | fedName,
|  | std::chrono::milliseconds | timeout = `std::chrono::milliseconds(10000)`
| ) |  |

helper function to wait for a particular federate to be created

this is useful if some reason we need to make sure a federate is created before proceeding

Parameters

  fed | a pointer to the federate
  fedName | the name of the federate we are querying
  timeout | the amount of time in ms to wait before returning false

Returns
  true if the federate exists, false if the timeout occurred

References helics::Federate::query().

## ◆ waitForInit()

HELICS_CXX_EXPORT bool helics::waitForInit | ( | helics::Federate * | fed,
|  | std::string_view | fedName,
|  | std::chrono::milliseconds | timeout = `std::chrono::milliseconds(10000)`
| ) |  |

helper function to wait for a particular federate has requested initialization mode

this is useful for querying information and being reasonably certain the federate is done adding to its interface

Parameters

  fed | a pointer to the federate
  fedName | the name of the federate we are querying
  timeout | the time to wait for the fed to initialize

Returns
  true if the federate is now trying to enter initialization false if the timeout was reached

References HELICS_SEQUENCING_MODE_ORDERED, and helics::Federate::query().

## Variable Documentation

## ◆ buildFlags

constexpr auto helics::buildFlags = HELICS_BUILD_FLAGS_DEBUG
| constexpr

build flags used to compile helics

Referenced by helicsGetBuildFlags(), and helics::core::systemInfo().

## ◆ cBigTime

constexpr Time helics::cBigTime = Time{static_cast<int64_t>(HELICS_BIG_NUMBER * 1000000)}
| constexpr

definition of large time representing simulation end

Referenced by helics::TimeDependencies::checkIfReadyForTimeGrant(), helics::InterfaceInfo::disconnectFederate(), helics::TimeDependencies::getMinDependency(), helics::TimeDependencies::resetDependency(), helics::GlobalTimeCoordinator::updateTimeFactors(), and helics::TimeCoordinator::updateTimeFactors().

## ◆ compiler

constexpr auto helics::compiler = HELICS_COMPILER_VERSION
| constexpr

compiler used to build helics

Referenced by helicsGetCompilerVersion(), and helics::core::systemInfo().

## ◆ defBrokerInterface

constexpr const char* helics::defBrokerInterface[]
| constexpr

Initial value:
= {"127.0.0.1",
"127.0.0.1",
"tcp://127.0.0.1",
"_ipc_broker",
""}

## ◆ defInterface

constexpr const char* helics::defInterface[]
| constexpr

Initial value:
= {"127.0.0.1",
"127.0.0.1",
"tcp://127.0.0.1",
"_ipc_broker",
""}

## ◆ gDirectCoreId

constexpr GlobalFederateId helics::gDirectCoreId {-235262}
| constexpr

identifier to target the local core even if the global id hasn't been assigned yet

Referenced by helics::CommonCore::setGlobal().

## ◆ gDirectSendHandle

constexpr InterfaceHandle helics::gDirectSendHandle
| constexpr

Initial value:
{
-1'745'234}

this special handle can be used to directly send a message in a core

Referenced by helics::CommonCore::sendMessage().

## ◆ gGlobalBrokerIdShift

constexpr IdentifierBaseType helics::gGlobalBrokerIdShift {0x7000'0000}
| constexpr

a shift in the global id index to discriminate between global ids of brokers vs federates

Referenced by getSpecialFederateId(), helics::GlobalFederateId::isBroker(), and helics::GlobalFederateId::isFederate().

## ◆ gGlobalFederateIdShift

constexpr IdentifierBaseType helics::gGlobalFederateIdShift {0x0002'0000}
| constexpr

a shift in the global federate id numbers to allow discrimination between local ids and global ones this value allows 131072 federates to be available in each core 1,878,917,120 allowable federates in the system and 268,435,455 brokers allowed if we need more than that this, HELICS as a program has been phenomenally successful beyond all wildest imaginations and we can probably afford to change these to 64 bit numbers to accommodate. Of the available federates there are 2 federate numbers that can be defined per core/broker for various purposes. These are the upper number of federate id's so 536,870,910 reserved federate id's. An ID of 1 is reserved for the root broker

Referenced by helics::GlobalFederateId::isFederate(), and helics::GlobalFederateId::localIndex().

## ◆ gGlobalPriorityBlockSize

constexpr IdentifierBaseType helics::gGlobalPriorityBlockSize {100'000'000}
| constexpr

the block size for global priority levels

## ◆ gRootBrokerID

constexpr GlobalBrokerId helics::gRootBrokerID {1}
| constexpr

constant to use for indicating the id of the root broker

Referenced by getSpecialFederateId(), helics::CoreBroker::setAsRoot(), and helics::CommonCore::setGlobal().

## ◆ initializationTime

constexpr Time helics::initializationTime = negEpsilon
| constexpr

common definition of currentTime in initialization mode

Referenced by helics::Federate::enteringExecutingMode(), helics::MessageFederateManager::initializeToExecuteStateTransition(), and helics::ValueFederateManager::initializeToExecuteStateTransition().

## ◆ invalid_id_value

constexpr IdentifierType helics::invalid_id_value
| constexpr

Initial value:
=
static_cast<IdentifierType>(-1)
helics::IdentifierType
std::uint32_t IdentifierType
specify the underlying type used in the identifiers
Definition: helicsTypes.hpp:22

defining an invalid id value

## ◆ levelMaps

const std::map<LogLevels, std::string_view> helics::levelMaps

Initial value:
{{static_cast<LogLevels>(-999999), "no_print"},
{LogLevels::NO_PRINT, "no_print"},
{LogLevels::ERROR_LEVEL, "error"},
{LogLevels::PROFILING, "profiling"},
{LogLevels::WARNING, "warning"},
{LogLevels::SUMMARY, "summary"},
{LogLevels::CONNECTIONS, "connections"},
{LogLevels::INTERFACES, "interfaces"},
{LogLevels::TIMING, "timing"},
{LogLevels::DATA, "data"},
{LogLevels::DEBUG, "debug"},
{LogLevels::TRACE, "trace"}}
helics::LogLevels
LogLevels
Definition: logging.hpp:20
helics::ERROR_LEVEL
@ ERROR_LEVEL
only print errors
Definition: logging.hpp:23
helics::PROFILING
@ PROFILING
profiling log level
Definition: logging.hpp:24
helics::SUMMARY
@ SUMMARY
print/log summary information
Definition: logging.hpp:26
helics::WARNING
@ WARNING
print/log warning and errors
Definition: logging.hpp:25
helics::DATA
@ DATA
print timing+data transmissions
Definition: logging.hpp:32
helics::DEBUG
@ DEBUG
print data+additional debug info
Definition: logging.hpp:33
helics::NO_PRINT
@ NO_PRINT
never print
Definition: logging.hpp:22
helics::CONNECTIONS
@ CONNECTIONS
print summary+federate level connection information
Definition: logging.hpp:27
helics::INTERFACES
@ INTERFACES
print connections+interface level connection information
Definition: logging.hpp:29
helics::TIMING
@ TIMING
print interfaces+timing(exec/grant/disconnect)
Definition: logging.hpp:31
helics::TRACE
@ TRACE
trace level printing (all processed messages)
Definition: logging.hpp:34

## ◆ negEpsilon

constexpr Time helics::negEpsilon = -Time::epsilon()
| constexpr

definition of the smallest negative increment of time

Referenced by helics::TimeDependencies::addDependency().

## ◆ parent_broker_id

constexpr GlobalBrokerId helics::parent_broker_id {0}
| constexpr

constant to use for indicating that a command is for the parent object

Referenced by helics::FilterFederate::createFilter(), helics::TranslatorFederate::createTranslator(), helics::TimeCoordinator::enteringExecMode(), helics::BaseTimeCoordinator::enteringExecMode(), helics::CommonCore::processDisconnect(), helics::FilterFederate::processMessageFilter(), helics::BaseTimeCoordinator::processTimeMessage(), helics::CommonCore::registerFederate(), helics::BrokerBase::saveProfilingData(), helics::CommonCore::sendCommand(), helics::TimeoutMonitor::tick(), and helics::BrokerBase::writeProfilingData().

## ◆ timeEpsilon

constexpr Time helics::timeEpsilon = Time::epsilon()
| constexpr

definition of the minimum time resolution

Referenced by helics::apps::Source::runTo().

## ◆ timeZero

constexpr Time helics::timeZero = Time::zeroVal()
| constexpr

constexpr definition for starting time

Referenced by helics::InputInfo::addData(), helics::TimeDependencies::addDependency(), helics::AsyncTimeCoordinator::checkExecEntry(), helics::TimeCoordinator::checkExecEntry(), helics::PublicationInfo::CheckSetValue(), helics::Message::clear(), helics::BrokerBase::configureBase(), helics::FederateState::enterExecutingMode(), helics::FederateState::finalize(), helics::ActionMessage::fromByteArray(), helics::TimeCoordinator::generateConfig(), helics::BaseTimeCoordinator::getLastGrant(), helics::FederateState::logMessage(), helics::Federate::requestNextStep(), helics::CommonCore::requestTimeIterative(), helics::FederateState::reset(), helics::apps::Clone::runTo(), helics::apps::Recorder::runTo(), helics::apps::Player::runTo(), helics::apps::Source::runTo(), helics::DelayFilterOperation::set(), helics::BrokerBase::setErrorState(), helics::CommonCore::setTimeProperty(), helics::TimeCoordinator::updateMessageTime(), helics::TimeCoordinator::updateValueTime(), and valueExtract().

## ◆ tstr

constexpr const char* helics::tstr[]
| constexpr

Initial value:
= {"default",
"ZeroMQ",
"MPI",
"TEST",
"IPC",
"interprocess",
"TCP",
"UDP",
"undef",
"nng",
"ZMQ_SS",
"TCPSS",
"undef",
"undef",
"http",
"unknown"}

## ◆ versionBuild

constexpr auto helics::versionBuild = HELICS_VERSION_BUILD
| constexpr

the build string if any

Referenced by helics::core::systemInfo().

## ◆ versionMajor

constexpr int helics::versionMajor = HELICS_VERSION_MAJOR
| constexpr

get the Major version number

Referenced by helics::core::systemInfo().

## ◆ versionMinor

constexpr int helics::versionMinor = HELICS_VERSION_MINOR
| constexpr

get the Minor version number

Referenced by helics::core::systemInfo().

## ◆ versionPatch

constexpr int helics::versionPatch = HELICS_VERSION_PATCH
| constexpr

get the patch number

Referenced by helics::core::systemInfo().

## ◆ versionString

constexpr auto helics::versionString = HELICS_VERSION_STRING
| constexpr

a string representation of the HELICS version

Referenced by helicsGetVersion(), and helics::core::systemInfo().