Syntalos

Syntalos

Namespaces

Classes

Types

Functions

Attributes

Types Documentation

enum ModuleState

The ModuleState enum.

Describes the state a module can be in. The state is usually displayed to the user via a module indicator widget.

enum ControlCommandKind

The ControlCommandKind enum.

Basic operations to control a module from another module.

enum LineCommandKind

The LineCommandKind enum.

Type of operation requested on a hardware signal line / channel / pin.

enum LineModeFlag

Individual mode bits for LineCommandKind::SetMode.

Composable bit flags describing how a line should be configured. Only meaningful for SetMode; ignored for other command kinds.

enum SignalDataType

Type of a signal from a signal source.

This is usually set in the metadata of a data stream.

enum EDLUnitKind

Type of an EDL unit.

enum EDLCreateFlag

Flag to influence how EDL units are loaded.

enum TimeSyncStrategy

The time synchronization strategy.

enum TSyncFileMode

Timepoint storage of a TSync file.

enum TSyncFileTimeUnit

Unit types for time representation in a TSync file.

enum TSyncFileDataType

Data types use for storing time values in the data file.

enum SysInfoCheckResult

enum ColorMode

enum ModuleWorkerMode

Worker mode for out-of-process modules.

enum PortAction

Action performed to modify a module port.

enum ConnectionHeatLevel

Connection heat level.

Warning level dependent on how full the buffer that is represented by a connection is. A high heat means lots of pending stuff and potentially a slow receiving module or not enough system resources. This state is managed internally by Syntalos.

enum ModuleFeature

The ModuleFeature flags List of basic features this module may or may not support, or may request from the engine to be available.

enum ModuleDriverKind

The ModuleDriverKind enum.

enum UsbHotplugEventKind

The UsbHotplugEventKind enum.

enum ModuleCategory

Categorization for modules.

enum ModuleModifier

The ModuleModifier flags Flags set by Syntalos or the user to modify the behavior of the module in the wider context of the running experiment.

enum PortDirection

Enum specifying directionality of a port (in or out)

enum MetaTypeTag

Type tag used in MetaValue binary serialization.

enum PyVirtualEnvStatus

using LineModeFlags

using Syntalos::LineModeFlags = typedef Flags<LineModeFlag>;

using StreamTypeList

using Syntalos::StreamTypeList = typedef std:: tuple<ControlCommand, TableRow, Frame, LineCommand, LineReading, SignalBlockI32, SignalBlockU16, SignalBlockF32>;

Compile-time list of all stream data types.

Append a new type here when adding it to the TypeId enum.

typedef EdlDateTime

typedef std::chrono::zoned_time< std::chrono::system_clock::duration > Syntalos::EdlDateTime;

using symaster_timepoint

using Syntalos::symaster_timepoint = typedef std::chrono::time_point<symaster_clock>;

A timepoint on the master clock.

using seconds_t

using Syntalos::seconds_t = typedef std::chrono::seconds;

Shorthand for seconds.

using milliseconds_t

using Syntalos::milliseconds_t = typedef std::chrono::milliseconds;

Shorthand for milliseconds.

using microseconds_t

using Syntalos::microseconds_t = typedef std::chrono::duration<int64_t, std::micro>;

Shorthand for microseconds.

using nanoseconds_t

using Syntalos::nanoseconds_t = typedef std::chrono::duration<int64_t, std::nano>;

Shorthand for nanoseconds.

typedef VectorXi32

typedef Eigen::Matrix<int32_t, Eigen::Dynamic, 1> Syntalos::VectorXi32;

typedef VectorXi64

typedef Eigen::Matrix<int64_t, Eigen::Dynamic, 1> Syntalos::VectorXi64;

typedef VectorXu16

typedef Eigen::Matrix<uint16_t, Eigen::Dynamic, 1> Syntalos::VectorXu16;

typedef VectorXu64

typedef Eigen::Matrix<uint64_t, Eigen::Dynamic, 1> Syntalos::VectorXu64;

typedef VectorXf

typedef Eigen::Matrix<float, Eigen::Dynamic, 1> Syntalos::VectorXf;

typedef VectorXd

typedef Eigen::Matrix<double, Eigen::Dynamic, 1> Syntalos::VectorXd;

typedef MatrixXi32

typedef Eigen::Matrix<int32_t, Eigen::Dynamic, Eigen::Dynamic, Eigen::RowMajor> Syntalos::MatrixXi32;

typedef MatrixXu16

typedef Eigen::Matrix<uint16_t, Eigen::Dynamic, Eigen::Dynamic, Eigen::RowMajor> Syntalos::MatrixXu16;

typedef MatrixXf

typedef Eigen::Matrix<float, Eigen::Dynamic, Eigen::Dynamic, Eigen::RowMajor> Syntalos::MatrixXf;

typedef MatrixXd

typedef Eigen::Matrix<double, Eigen::Dynamic, Eigen::Dynamic, Eigen::RowMajor> Syntalos::MatrixXd;

using TimeSyncStrategies

using Syntalos::TimeSyncStrategies = typedef Flags<TimeSyncStrategy>;

using SyncDetailsChangeNotifyFn

using Syntalos::SyncDetailsChangeNotifyFn = typedef std::function< void(const std::string &id, const TimeSyncStrategies &strategies, const microseconds_t &tolerance)>;

Function to call when synchronizer details have changed.

using OffsetChangeNotifyFn

using Syntalos::OffsetChangeNotifyFn = typedef std::function<void(const std::string &id, const microseconds_t &currentOffset)>;

Function to call to notify about an offset change.

using QuillLogger

using Syntalos::QuillLogger = typedef quill::Logger;

using intervalEventFunc_t

using Syntalos::intervalEventFunc_t = typedef void (AbstractModule::*)(int &);

Event function type for timed callbacks.

using recvDataEventFunc_t

using Syntalos::recvDataEventFunc_t = typedef std::function<void()>;

Callable type used for subscription new-data callbacks.

using ByteVector

using Syntalos::ByteVector = typedef std::pmr::vector<std::byte>;

ByteVector is a vector of bytes using the polymorphic allocator.

In Syntalos’ heavily threaded environment, where in the worst case a ton of these vectors may be created and destroyed in quick succession, the default glibc allocator is less than optimal. Mimalloc has shown to perform a lot better for this burst-like, threaded activity, therefore we prefer it. Please try to reuse buffers whenever possible though - while mimalloc is a significant improvement, reusing memory segments is even better.

We do use the C++ polymorphic allocator since datactl is used in places where swapping the allocator is undesirable, e.g. in mlink that may be linked into non-Syntalos processes. These processes may use the default allocator instead of Syntalos’ mimalloc-based one.

using LoadScriptFn

using Syntalos::LoadScriptFn = typedef std::function<void(const std::string &script, const fs::path &wdir)>;

using SaveSettingsFn

using Syntalos::SaveSettingsFn = typedef std::function<bool(ByteVector &settings, const fs::path &baseDir)>;

using LoadSettingsFn

using Syntalos::LoadSettingsFn = typedef std::function<bool(const ByteVector &settings, const fs::path &baseDir)>;

using PrepareRunFn

using Syntalos::PrepareRunFn = typedef std::function<bool()>;

using StartFn

using Syntalos::StartFn = typedef std::function<void()>;

using StopFn

using Syntalos::StopFn = typedef std::function<void()>;

using ShutdownFn

using Syntalos::ShutdownFn = typedef std::function<void()>;

using NewDataRawFn

using Syntalos::NewDataRawFn = typedef std::function<void(const void *data, size_t size)>;

using NewDataFn

using Syntalos::NewDataFn = typedef std::function<void(BaseDataType &data)>;

using ShowSettingsFn

using Syntalos::ShowSettingsFn = typedef std::function<void(void)>;

using ShowDisplayFn

using Syntalos::ShowDisplayFn = typedef std::function<void(void)>;

Functions Documentation

function toString

std::string toString(
    ModuleState state
)

function registerStreamMetaTypes

void registerStreamMetaTypes()

Helper function to register all meta types for stream data.

This function registers all types with the meta object system and also creates a global map of all available stream types.

function streamTypeIdIndex

std::vector< std::pair< std::string, int > > streamTypeIdIndex()

Get a mapping of type names to their IDs.

function syDataTypeId

template <typename T >
constexpr int syDataTypeId()

Helper function to get the type ID of a data type.

function deserializeFromMemory

template <typename T >
T deserializeFromMemory(
    const void * memory,
    size_t size
)

Convenience function to deserialize a data type from memory.

function forEachStreamType

template <typename Fn >
constexpr bool forEachStreamType(
    Fn && fn
)

Call fn(std::type_identity<T>{}) for every T in StreamTypeList.

The lambda must return bool: true to stop iterating (typically “I found what I was looking for”), false to keep going.

function numToString

template <typename T >
inline std::string numToString(
    T x
)

Convert a numeric value to a string using Syntalos’ default notation.

This function converts arithmetic types to strings in a locale-independent way. For floating-point types, it uses the “general” format (shortest representation). Special values (NaN, infinity) are handled consistently across all types.

function edlCurrentDateTime

EdlDateTime edlCurrentDateTime()

function makeAnimalMoniker

std::string makeAnimalMoniker()

function makeAnimalMonikerForString

std::string makeAnimalMonikerForString(
    const std::string & source
)

function makeMonikerForUuid

std::string makeMonikerForUuid(
    const Uuid & uuid
)

function makeMonikerForString

std::string makeMonikerForString(
    const std::string & source
)

function operator«

inline std::ostream & operator<<(
    std::ostream & os,
    const MetaSize & sz
)

function operator«

inline std::ostream & operator<<(
    std::ostream & os,
    const MetaArray & arr
)

function operator«

inline std::ostream & operator<<(
    std::ostream & os,
    const MetaValue & v
)

function operator«

inline std::ostream & operator<<(
    std::ostream & os,
    const MetaStringMap & map
)

function writeJson

void writeJson(
    std::ostream & os,
    const MetaValue & val
)

Write a MetaValue as JSON to the given stream (RFC-8259, compact).

function writeJsonObject

void writeJsonObject(
    std::ostream & os,
    const std::map< std::string, MetaValue > & obj
)

Write a MetaValue map as a JSON object to the given stream.

function toJsonString

std::string toJsonString(
    const MetaValue & v
)

function toJsonObjectString

std::string toJsonObjectString(
    const MetaStringMap & m
)

function stringMapFromJson

std::expected< MetaStringMap, std::string > stringMapFromJson(
    const std::string & json
)

Rudimentary JSON object parser: handles {“key”: “str”} and {“key”: 123}

function makeAnimalMonikerFromRng

static std::string makeAnimalMonikerFromRng(
    std::mt19937_64 & rng
)

function makeMonikerFromSeed

static std::string makeMonikerFromSeed(
    uint64_t seed
)

function newUuid7

Uuid newUuid7()

Generate a Version 7 UUID (UUIDv7) based on a timestamp and random data.

Return: A new UUIDv7.

The function generates a UUID conforming to Version 7 of the UUID format.

function writeJsonString

static void writeJsonString(
    std::ostream & os,
    const std::string & s
)

function usecToMsec

inline auto usecToMsec(
    const microseconds_t & usec
)

Convert microseconds to milliseconds.

Shorthand for duration-case to increase code readability.

function msecToUsec

inline auto msecToUsec(
    const milliseconds_t & msec
)

Convert milliseconds microseconds.

Shorthand for duration-case to increase code readability.

function nsecToUsec

inline auto nsecToUsec(
    const nanoseconds_t & msec
)

Convert nanoseconds microseconds.

Shorthand for duration-case to increase code readability.

function timeDiffSec

inline auto timeDiffSec(
    const symaster_timepoint & timePoint1,
    const symaster_timepoint & timePoint2
)

function timeDiffMsec

inline auto timeDiffMsec(
    const symaster_timepoint & timePoint1,
    const symaster_timepoint & timePoint2
)

function timeDiffUsec

inline auto timeDiffUsec(
    const symaster_timepoint & timePoint1,
    const symaster_timepoint & timePoint2
)

function timeDiffToNowMsec

inline auto timeDiffToNowMsec(
    const std::chrono::time_point< symaster_clock > & timePoint
)

function timeDiffToNowUsec

inline auto timeDiffToNowUsec(
    const std::chrono::time_point< symaster_clock > & timePoint
)

function currentTimePoint

inline symaster_timepoint currentTimePoint()

function vectorMedian

template <typename T >
double vectorMedian(
    const Eigen::Matrix< T, Eigen::Dynamic, 1 > & vec
)

function vectorMedianInplace

template <typename T >
double vectorMedianInplace(
    Eigen::Matrix< T, Eigen::Dynamic, 1 > & vec
)

function vectorVariance

template <typename T >
double vectorVariance(
    const Eigen::Matrix< T, Eigen::Dynamic, 1 > & vec,
    const double & mean,
    bool unbiased =true
)

function vectorVariance

template <typename T >
double vectorVariance(
    const Eigen::Matrix< T, Eigen::Dynamic, 1 > & vec,
    bool unbiased =true
)

function serializeEigen

template <typename EigenType >
void serializeEigen(
    BinaryStreamWriter & stream,
    const EigenType & matrix
)

function deserializeEigen

template <typename EigenType >
EigenType deserializeEigen(
    BinaryStreamReader & stream
)

function timeSyncStrategyToHString

const std::string timeSyncStrategyToHString(
    const TimeSyncStrategy & strategy
)

function timeSyncStrategiesToHString

const std::string timeSyncStrategiesToHString(
    const TimeSyncStrategies & strategies
)

function safeStopSynchronizer

template <typename T >
void safeStopSynchronizer(
    const T & synchronizerSmartPtr
)

function safeStopSynchronizer

template <typename T >
void safeStopSynchronizer(
    const T & synchronizer,
    const microseconds_t & lastValidMasterTimestamp
)

function tsyncFileTimeUnitToString

std::string tsyncFileTimeUnitToString(
    const TSyncFileTimeUnit & tsftunit
)

function tsyncFileDataTypeToString

std::string tsyncFileDataTypeToString(
    const TSyncFileDataType & dtype
)

function tsyncFileModeToString

std::string tsyncFileModeToString(
    const TSyncFileMode & mode
)

function cvMatToQImage

std::optional< QImage > cvMatToQImage(
    const cv::Mat & mat
)

Converts an OpenCV Mat to a QImage.

Parameters:

• mat The OpenCV Mat to convert.

Return: An optional containing the converted QImage, or std::nullopt if conversion fails.

This function attempts to convert the given OpenCV Mat to a QImage. It supports grayscale (1 channel), RGB (3 channels), and RGBA (4 channels) images. If the conversion is successful, it returns a QImage wrapped in std::optional. If the conversion fails (e.g., unsupported number of channels), it returns std::nullopt.

function cvMatToQPixmap

std::optional< QPixmap > cvMatToQPixmap(
    const cv::Mat & mat
)

function qRectToCvRect

inline cv::Rect qRectToCvRect(
    const QRect & r
)

Helper to convert a QRect into a cv::Rect

For a cv::Rect, right and bottom edges are exclusive, while they are inclusive for a QRect. This helper just ensures we don’t accidentally make any conversion mistakes.

function shellQuote

QString shellQuote(
    const QString & str
)

Shell-escape a string.

function findHostExecutable

QString findHostExecutable(
    const QString & exe
)

Find executable on the host system (if running in a sandbox)

Parameters:

• exe Name of the executable to look for

Return: Executable name, or empty string if not found

function runHostExecutable

int runHostExecutable(
    const QString & exe,
    const QStringList & args,
    bool waitForFinished
)

Run command on the host.

Parameters:

• exe The program to run
• args Program arguments
• waitForFinished Wait for the command to finish

Return: Exit status of the program (if waiting for finished)

function runInTerminal

int runInTerminal(
    const QString & cmd,
    const QStringList & args,
    const QString & wdir,
    const QString & title
)

function launchProgramNC3Fallback

static bool launchProgramNC3Fallback(
    const QString & exePath,
    int * pidfd_out
)

Fallback for launchProgram() if the clone3() syscall was not available or is blocked by seccomp filters.

function launchProgramPidFd

bool launchProgramPidFd(
    const QString & exePath,
    int * pidfd_out
)

Launch a program in a new process, and return the PID of the new process as pidfd.

Parameters:

• exePath The path to the executable to launch.
• pidfd_out A pointer to an integer, which will be set to the PID of the new process.

Return: true if the program was successfully launched, false otherwise.

This function is used to launch a new program in a new process, and return the PID as pidfd.

function isProcessRunning

bool isProcessRunning(
    int pidfd
)

Check if a process is still running using a pidfd.

Parameters:

• pidfd The PIDFD of the process to check.

Return: true if the process is still running, false otherwise.

This function checks if a process is still running, by checking if the process has exited or not.

function getLogger

quill::Logger * getLogger(
    const std::string & name
)

function getLogger

quill::Logger * getLogger(
    const QString & name
)

function getLogger

quill::Logger * getLogger(
    const char * name
)

function logModTmp

quill::Logger * logModTmp(
    const char * name
)

Parameters:

• name A custom-defined module name.

Return: A logger for the module ID.

Get a temporary logger for an arbitrary module name. This is not for high-volume logging and mostly for compatibility with older code, think twice before using it in any new code.

Usually there is a better solution.

function getDefaultLogger

inline quill::Logger * getDefaultLogger()

function removeLogger

void removeLogger(
    quill::Logger * logger
)

Remove a logger explicitly. Should usually not be needed.

function initializeSyLogSystem

void initializeSyLogSystem(
    quill::LogLevel consoleLogLevel =quill::LogLevel::Info
)

Initialize Syntalos logging. Must only ever be called once, at program startup. Purely internal API.

function shutdownSyLogSystem

void shutdownSyLogSystem()

function qstr

inline const QString & qstr(
    const QString & s
)

function qstr

inline QString qstr(
    QStringView s
)

function qstr

inline QString qstr(
    const char * s
)

function qstr

inline QString qstr(
    std::string_view s
)

function qstr

inline QString qstr(
    const std::string & s
)

function colorModeToString

QString colorModeToString(
    ColorMode mode
)

function colorModeFromString

ColorMode colorModeFromString(
    const QString & str
)

function findSyntalosLibraryPaths

void findSyntalosLibraryPaths(
    QString & pkgConfigPath,
    QString & ldLibraryPath,
    QString & includePath
)

function findSyntalosMlinkPyModulePaths

QStringList findSyntalosMlinkPyModulePaths()

Build an ordered list of directories that can contain syntalos_mlink. Dev/build paths are preferred over installed paths.

function datactlLogHandler

static void datactlLogHandler(
    const datactl::LogMessage & m
)

function qtLogHandler

static void qtLogHandler(
    QtMsgType type,
    const QMessageLogContext & ctx,
    const QString & msg
)

function glibLogWriter

static GLogWriterOutput glibLogWriter(
    GLogLevelFlags log_level,
    const GLogField * fields,
    gsize n_fields,
    gpointer 
)

function makeIpcServiceTopology

inline constexpr IpcServiceTopology makeIpcServiceTopology(
    uint senderCount,
    uint receiverCount
)

Helper to create a Syntalos IPC service topology, for setting limits on IOX connections.

function connectionHeatToHumanString

QString connectionHeatToHumanString(
    ConnectionHeatLevel heat
)

function toString

QString toString(
    ModuleCategory category
)

function moduleCategoryFromString

ModuleCategory moduleCategoryFromString(
    const QString & categoryStr
)

function moduleCategoriesFromVariant

ModuleCategories moduleCategoriesFromVariant(
    const QVariant & value
)

function qHash

inline uint qHash(
    ModuleModifier key,
    uint seed
)

function newStreamForType

VariantDataStream * newStreamForType(
    int typeId
)

Create a new DataStream for the type identified by the given ID.

function newInputPortForType

VarStreamInputPort * newInputPortForType(
    int typeId,
    AbstractModule * mod,
    const QString & id,
    const QString & title
)

Create a new Input Port for the type identified by the given ID.

function operator|

template <typename E ,
typename  =std::enable_if_t<std::is_scoped_enum_v<E>>>
constexpr Flags< E > operator|(
    E lhs,
    E rhs
)

Allow E | E to produce Flags<E> for any scoped enum.

Restricted to scoped enums so we don’t shadow the built-in int-returning operator| that plain (unscoped) enums rely on - most notably Eigen’s internal storage-option enums, which are evaluated inside Syntalos namespace scope when Eigen templates are instantiated against our types.

function pythonVEnvDirForName

QString pythonVEnvDirForName(
    const QString & venvName
)

Get the absolute directory path of a virtual environment with the given name.

function pythonVirtualEnvExists

static bool pythonVirtualEnvExists(
    const QString & venvName
)

function requirementsHashMetadataPath

static QString requirementsHashMetadataPath(
    const QString & venvDir
)

function writeRequirementsHashMetadata

static bool writeRequirementsHashMetadata(
    const QString & venvDir,
    const QByteArray & requirementsHash
)

function readRequirementsHashMetadata

static bool readRequirementsHashMetadata(
    const QString & venvDir,
    QString & requirementsHashOut
)

function interpreterPathFromCfg

static QString interpreterPathFromCfg(
    const QString & venvDir
)

function pythonVirtualEnvStatus

PyVirtualEnvStatus pythonVirtualEnvStatus(
    const QString & venvName,
    const QString & requirementsFile
)

function injectSyntalosMlinkIntoVenv

static void injectSyntalosMlinkIntoVenv(
    const QString & venvDir
)

function createPythonVirtualEnv

auto createPythonVirtualEnv(
    const QString & venvName,
    const QString & requirementsFile,
    bool recreate
)

function streamDataFromRawMemory

template <typename T >
T streamDataFromRawMemory(
    const void * data,
    size_t size
)

Convert raw received bytes into their data type.

function initSyntalosModuleLink

std::unique_ptr< SyntalosLink > initSyntalosModuleLink(
    const ModuleInitOptions & optn ={}
)

function SY_DEFINE_LOG_CATEGORY

SY_DEFINE_LOG_CATEGORY(
    logSyLink ,
    "sylink" 
)

function safeReceive

template <typename Sub >
static auto safeReceive(
    Sub & sub
)

Safely receive from a subscriber on the client. Returns the inner optional (empty = no data available) and logs a warning instead of crashing when the receive itself fails.

function getenvSafe

static std::string getenvSafe(
    const char * name
)

function resolveTypedNewDataCallback

void resolveTypedNewDataCallback(
    InputPortInfo * iport
)

Resolve the variant (typed) callback into a per-sample raw callback once, using the recorded source-on-wire type ID and the declared input type ID. Compatible stream type castings are applied here.

Port has to be connected (sourceTypeId != 0) and d.newDataCb should be set.

function SY_DEFINE_LOG_CATEGORY

SY_DEFINE_LOG_CATEGORY(
    logIpc ,
    "ipc" 
)

function ipcLogMessageDispatch

static void ipcLogMessageDispatch(
    datactl::LogSeverity severity,
    const std::string & msg
)

function edlRelPath

static std::string edlRelPath(
    const EDLGroup & root,
    const EDLGroup & target
)

Helper: compute the relative path of target from the rootGroup. Returns "" if target IS the rootGroup (i.e., put at root level).

function SY_DEFINE_LOG_CATEGORY

SY_DEFINE_LOG_CATEGORY(
    logLinkMod ,
    "sylm" 
)

Attributes Documentation

variable g_streamTypeIdIndex

static std::vector< std::pair< std::string, int > > g_streamTypeIdIndex;

variable US_PER_MS

constexpr int64_t US_PER_MS = 1'000;

variable US_PER_S

constexpr int64_t US_PER_S = 1'000 * US_PER_MS;

variable US_PER_MIN

constexpr int64_t US_PER_MIN = 60 * US_PER_S;

variable US_PER_H

constexpr int64_t US_PER_H = 60 * US_PER_MIN;

variable NS_PER_US

constexpr int64_t NS_PER_US = 1'000;

variable MS_PER_S

constexpr int64_t MS_PER_S = 1'000;

variable MS_PER_MIN

constexpr int64_t MS_PER_MIN = 60 * MS_PER_S;

variable SECONDARY_CLOCK_TOLERANCE

static constexpr auto SECONDARY_CLOCK_TOLERANCE = microseconds_t(1000);

The amount of time a secondary clock is allowed to deviate from the master.

Since Syntalos uses millisecond time resolution, permitting (slightly more than) half a millisecond deviation for secondary clocks from the master clock is sensible.

IMPORTANT: Modules may override this value for their synchronizers to one that fits their device better. This is just a default for modules which do not change the default setting.

variable DEFAULT_CLOCKSYNC_CHECK_INTERVAL

static constexpr auto DEFAULT_CLOCKSYNC_CHECK_INTERVAL = milliseconds_t(4000);

Interval at which we check for external clock synchronization.

IMPORTANT: This is just a default value for modules which do not explicitly define a check interval. Individual modules may choose a different value that fits the device they are communicating with best.

variable g_consoleSink

static std::shared_ptr< quill::Sink > g_consoleSink = nullptr;

variable g_defaultLogLevel

static quill::LogLevel g_defaultLogLevel = quill::LogLevel::Info;

variable g_prevQtHandler

static QtMessageHandler g_prevQtHandler = nullptr;

variable SY_IOX_QUEUE_CAPACITY

static constexpr uint64_t SY_IOX_QUEUE_CAPACITY = 16U;

variable SY_IOX_HISTORY_SIZE

static constexpr uint64_t SY_IOX_HISTORY_SIZE = 1U;

variable SY_IOX_INITIAL_SLICE_LEN

static constexpr uint64_t SY_IOX_INITIAL_SLICE_LEN = 4096;

variable SY_IOX_ID_MAX_LEN

static constexpr size_t SY_IOX_ID_MAX_LEN = IOX2_SERVICE_NAME_LENGTH;

variable SY_IOX_MAX_RESPONSE_BUF_SIZE

static constexpr uint64_t SY_IOX_MAX_RESPONSE_BUF_SIZE = 2U;

variable IN_PORT_CHANGE_CHANNEL_ID

static const std::string IN_PORT_CHANGE_CHANNEL_ID = "InPortChange";

variable OUT_PORT_CHANGE_CHANNEL_ID

static const std::string OUT_PORT_CHANGE_CHANNEL_ID = "OutPortChange";

variable IN_PORT_UPDATE_METADATA_ID

static const std::string IN_PORT_UPDATE_METADATA_ID = "UpdateInputPortMetadata";

variable WORKER_CTL_EVENT_ID

static const std::string WORKER_CTL_EVENT_ID = "worker-event";

Shared wakeup event service names for the control channel.

WORKER_CTL_EVENT_ID - the worker notifies the master whenever it publishes on a control channel (error, state, port-changes …). The master attaches one listener for this to its WaitSet.

MASTER_CTL_EVENT_ID - the master notifies the worker whenever it sends a request (request-response commands).

variable MASTER_CTL_EVENT_ID

static const std::string MASTER_CTL_EVENT_ID = "master-event";

variable ERROR_CHANNEL_ID

static const std::string ERROR_CHANNEL_ID = "Error";

variable STATE_CHANNEL_ID

static const std::string STATE_CHANNEL_ID = "State";

variable STATUS_MESSAGE_CHANNEL_ID

static const std::string STATUS_MESSAGE_CHANNEL_ID = "StatusMessage";

variable SYNC_DETAILS_CHANNEL_ID

static const std::string SYNC_DETAILS_CHANNEL_ID = "SyncDetails";

variable SYNC_OFFSET_CHANNEL_ID

static const std::string SYNC_OFFSET_CHANNEL_ID = "SyncOffset";

variable API_VERSION_CALL_ID

static const std::string API_VERSION_CALL_ID = "ApiVersion";

variable SET_NICENESS_CALL_ID

static const std::string SET_NICENESS_CALL_ID = "SetNiceness";

variable SET_MAX_RT_PRIORITY_CALL_ID

static const std::string SET_MAX_RT_PRIORITY_CALL_ID = "SetMaxRealtimePriority";

variable SET_CPU_AFFINITY_CALL_ID

static const std::string SET_CPU_AFFINITY_CALL_ID = "SetCPUAffinity";

variable DELETE_PORT_CALL_ID

static const std::string DELETE_PORT_CALL_ID = "DeletePort";

variable CONNECT_INPUT_CALL_ID

static const std::string CONNECT_INPUT_CALL_ID = "ConnectInputPort";

variable LOAD_SCRIPT_CALL_ID

static const std::string LOAD_SCRIPT_CALL_ID = "LoadScript";

variable SET_PORTS_PRESET_CALL_ID

static const std::string SET_PORTS_PRESET_CALL_ID = "SetPortsPresetRequest";

variable SAVE_SETTINGS_CALL_ID

static const std::string SAVE_SETTINGS_CALL_ID = "SaveSettings";

variable LOAD_SETTINGS_CALL_ID

static const std::string LOAD_SETTINGS_CALL_ID = "LoadSettings";

variable PREPARE_RUN_CALL_ID

static const std::string PREPARE_RUN_CALL_ID = "PrepareRun";

variable START_CALL_ID

static const std::string START_CALL_ID = "Start";

variable STOP_CALL_ID

static const std::string STOP_CALL_ID = "Stop";

variable SHUTDOWN_CALL_ID

static const std::string SHUTDOWN_CALL_ID = "Shutdown";

variable SHOW_SETTINGS_CALL_ID

static const std::string SHOW_SETTINGS_CALL_ID = "ShowSettings";