Inheritance diagram for helics::NetworkBroker< COMMS, baseline, tcode >:

Public Member Functions
	NetworkBroker (bool rootBroker=false) noexcept

	NetworkBroker (std::string_view broker_name)

virtual std::string	generateLocalAddressString () const override

Public Member Functions inherited from helics::CommsBroker< COMMS, CoreBroker >
	CommsBroker () noexcept

	CommsBroker (bool arg) noexcept

	CommsBroker (std::string_view obj_name)

	~CommsBroker ()

virtual void	transmit (route_id rid, const ActionMessage &cmd) override

virtual void	transmit (route_id rid, ActionMessage &&cmd) override

virtual void	addRoute (route_id rid, int interfaceId, std::string_view routeInfo) override

virtual void	removeRoute (route_id rid) override

COMMS *	getCommsObjectPointer ()

Public Member Functions inherited from helics::CoreBroker
virtual bool	connect () override final

virtual void	disconnect () override final

void	unregister ()

virtual void	processDisconnect (bool skipUnregister=false) override final

virtual bool	isConnected () const override final

virtual void	setAsRoot () override final

virtual bool	isRoot () const override final

virtual bool	isOpenToNewFederates () const override

virtual void	setLoggingCallback (std::function< void(int, std::string_view, std::string_view)> logFunction) override final

virtual bool	waitForDisconnect (std::chrono::milliseconds msToWait=std::chrono::milliseconds(0)) const override final

virtual void	setTimeBarrier (Time barrierTime) override final

virtual void	clearTimeBarrier () override final

virtual void	globalError (int32_t errorCode, std::string_view errorString) override final

	CoreBroker (bool setAsRootBroker=false) noexcept

	CoreBroker (std::string_view broker_name)

virtual	~CoreBroker ()

virtual void	configure (std::string_view configureString) override final

virtual void	configureFromArgs (int argc, char *argv[]) override final

virtual void	configureFromVector (std::vector< std::string > args) override final

bool	allInitReady () const

ConnectionState	getAllConnectionState () const

void	setIdentifier (std::string_view name)

virtual const std::string &	getIdentifier () const override final

virtual const std::string &	getAddress () const override final

virtual void	setLoggingLevel (int logLevel) override final

virtual void	setLogFile (std::string_view lfile) override final

virtual std::string	query (std::string_view target, std::string_view queryStr, HelicsSequencingModes mode=HELICS_SEQUENCING_MODE_FAST) override final

virtual void	setGlobal (std::string_view valueName, std::string_view value) override final

virtual void	sendCommand (std::string_view target, std::string_view commandStr, HelicsSequencingModes mode) override final

virtual void	makeConnections (const std::string &file) override final

virtual void	linkEndpoints (std::string_view source, std::string_view target) override final

virtual void	dataLink (std::string_view publication, std::string_view input) override final

virtual void	addSourceFilterToEndpoint (std::string_view filter, std::string_view endpoint) override final

virtual void	addDestinationFilterToEndpoint (std::string_view filter, std::string_view endpoint) override final

virtual void	addAlias (std::string_view interfaceKey, std::string_view alias) override final

Public Member Functions inherited from helics::Broker
	Broker ()=default

virtual	~Broker ()=default

Public Member Functions inherited from helics::BrokerBase
	BrokerBase (bool DisableQueue=false) noexcept

	BrokerBase (std::string_view broker_name, bool DisableQueue=false)

void	loadInfoFromToml (const std::string &toml, bool runArgParser=true)

void	loadInfoFromJson (const std::string &json, bool runArgParser=true)

int	parseArgs (int argc, char *argv[])

int	parseArgs (std::vector< std::string > args)

int	parseArgs (std::string_view initializationString)

virtual void	configureBase ()

void	addActionMessage (const ActionMessage &message)

void	addActionMessage (ActionMessage &&message)

void	setLoggerFunction (std::function< void(int level, std::string_view identifier, std::string_view message)> logFunction)

void	logFlush ()

bool	isRunning () const

void	setLogLevel (int32_t level)

void	setLogLevels (int32_t consoleLevel, int32_t fileLevel)

GlobalBrokerId	getGlobalId () const

std::function< void(int, std::string_view, std::string_view)>	getLoggingCallback () const

void	joinAllThreads ()

std::size_t	currentMessageCounter () const

Protected Member Functions
virtual std::shared_ptr< helicsCLI11App >	generateCLI () override

virtual bool	brokerConnect () override

Protected Member Functions inherited from helics::CoreBroker
virtual double	getSimulationTime () const override

Protected Member Functions inherited from helics::BrokerBase
void	setTickForwarding (TickForwardingReasons reason, bool value=true)

BrokerState	getBrokerState () const

bool	setBrokerState (BrokerState newState)

bool	transitionBrokerState (BrokerState expectedState, BrokerState newState)

bool	sendToLogger (GlobalFederateId federateID, int logLevel, std::string_view name, std::string_view message, bool fromRemote=false) const

void	saveProfilingData (std::string_view message)

void	writeProfilingData ()

void	generateNewIdentifier ()

void	setErrorState (int eCode, std::string_view estring)

void	setLoggingFile (std::string_view lfile)

bool	getFlagValue (int32_t flag) const

std::pair< bool, std::vector< std::string_view > >	processBaseCommands (ActionMessage &command)

void	addBaseInformation (nlohmann::json &base, bool hasParent) const

Protected Attributes
std::mutex	dataMutex
	mutex protecting the configuration information

NetworkBrokerData	netInfo {baseline}
	structure containing the networking information

Protected Attributes inherited from helics::CommsBroker< COMMS, CoreBroker >
std::atomic< int >	disconnectionStage
	the stage of disconnection

std::unique_ptr< COMMS >	comms
	the actual comms object

std::atomic< bool >	brokerInitialized
	atomic protecting local initialization

Protected Attributes inherited from helics::CoreBroker
bool	_gateway = false
	set to true if this broker should act as a gateway.

Protected Attributes inherited from helics::BrokerBase
std::atomic< GlobalBrokerId >	global_id {parent_broker_id}

GlobalBrokerId	global_broker_id_local {}

GlobalBrokerId	higher_broker_id {0}
	the id code of the broker 1 level about this broker

std::atomic< int32_t >	maxLogLevel {HELICS_LOG_LEVEL_NO_PRINT}

int32_t	minFederateCount {1}

int32_t	minBrokerCount {0}

int32_t	maxFederateCount {(std::numeric_limits<int32_t>::max)()}

int32_t	maxBrokerCount {(std::numeric_limits<int32_t>::max)()}

int32_t	minChildCount {0}

int32_t	maxIterationCount {10000}
	the maximum number of iterative loops that are allowed

Time	tickTimer {5.0}
	the length of each heartbeat tick

Time	timeout {30.0}
	timeout to wait to establish a broker connection before giving up

Time	networkTimeout {-1.0}
	timeout to establish a socket connection before giving up

Time	queryTimeout {15.0}

Time	errorDelay {0.0}
	time to delay before terminating after error state

Time	grantTimeout {-1.0}
	timeout for triggering diagnostic action waiting for a time grant

Time	maxCoSimDuration {-1.0}
	the maximum lifetime (wall clock time) of the co-simulation

std::string	identifier
	an identifier for the broker

std::string	brokerKey

std::string	address
	network location of the broker

std::thread	queueProcessingThread

std::atomic< bool >	haltOperations {false}
	flag indicating that no further message should be processed

bool	restrictive_time_policy {false}
	flag indicating the broker should use a conservative time policy

bool	terminate_on_error {false}
	flag indicating that the federation should halt on any error

bool	debugging {false}
	flag indicating operation in a user debugging mode

bool	observer {false}
	flag indicating that the broker is an observer only

bool	globalTime {false}
	flag indicating that the broker should use a global time coordinator

bool	asyncTime {false}
	flag indicating the use of async time keeping

bool	dynamicFederation {false}
	flag indicating that the broker supports dynamic federates

bool	disableDynamicSources {false}
	flag disabling dynamic data sources

std::unique_ptr< BaseTimeCoordinator >	timeCoord
	object managing the time control

gmlc::containers::BlockingPriorityQueue< ActionMessage >	actionQueue
	primary routing queue

std::shared_ptr< LogManager >	mLogManager
	object to handle the logging considerations

bool	noAutomaticID {false}
	the broker should not automatically generate an ID

bool	hasTimeDependency {false}

bool	enteredExecutionMode {false}
	flag indicating that the broker has entered execution mode

bool	waitingForBrokerPingReply {false}
	flag indicating we are waiting for a ping reply

bool	hasFilters {false}
	flag indicating filters come through the broker

bool	no_ping {false}
	indicator that the broker is not very responsive to ping requests

bool	uuid_like {false}
	will be set to true if the name looks like a uuid

bool	useJsonSerialization {false}

bool	enable_profiling {false}
	indicator that profiling is enabled

bool	allowRemoteControl {true}

bool	errorOnUnmatchedConnections {false}
	error if there are unmatched connections on init

bool	globalDisconnect {false}

decltype(std::chrono::steady_clock::now())	errorTimeStart
	time when the error condition started; related to the errorDelay

decltype(std::chrono::steady_clock::now())	disconnectTime
	time when the disconnect started

std::atomic< int >	lastErrorCode {0}
	storage for last error code

std::string	lastErrorString
	storage for last error string

std::string	configString
	storage for a config file location

bool	fileInUse {false}

Additional Inherited Members
Protected Types inherited from helics::BrokerBase
enum class	BrokerState : int16_t { CREATED = -10 , CONFIGURING = -7 , CONFIGURED = -6 , CONNECTING = -4 , CONNECTED = -3 , INITIALIZING = -1 , OPERATING = 0 , CONNECTED_ERROR = 3 , TERMINATING = 4 , TERMINATING_ERROR = 5 , TERMINATED = 6 , ERRORED = 7 }

enum class	TickForwardingReasons : uint32_t { NONE = 0 , NO_COMMS = 0x01 , PING_RESPONSE = 0x02 , QUERY_TIMEOUT = 0x04 , GRANT_TIMEOUT = 0x08 , DISCONNECT_TIMEOUT = 0x10 }

Static Protected Member Functions inherited from helics::BrokerBase
static bool	isReasonForTick (std::uint32_t code, TickForwardingReasons reason)

Static Protected Attributes inherited from helics::BrokerBase
static constexpr double	mInvalidSimulationTime {-98763.2}