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 MetaTypeTag

Type tag used in MetaValue binary serialization.

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 PyVirtualEnvStatus

using LineModeFlags

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

using SignalBlockTypeList

using Syntalos::SignalBlockTypeList = typedef std::tuple<SignalBlockI16, SignalBlockU16, SignalBlockI32, SignalBlockF32>;

Compile-time list of all SignalBlock* types.

Append a new signal block type here when adding it to the TypeId enum. Code that works on signal blocks generically (writers, filters, type selectors) iterates this list, so it needs no per-type changes.

using StreamTypeList

using Syntalos::StreamTypeList = typedef decltype(std::tuple_cat( std::declval<std::tuple<ControlCommand, TableRow, Frame, LineCommand, LineReading> >(), std::declval<SignalBlockTypeList>()));

Compile-time list of all stream data types.

Append a new (non-signal-block) type here when adding it to the TypeId enum. Note that this list contains Frame, which is only forward-declared in this header: code instantiating templates over the full list must also include [datactl/frametype.h].

using signal_block_scalar_t

template <SignalBlockType T>
using Syntalos::signal_block_scalar_t = typedef typename std::remove_cvref_t<decltype(std::declval<T>().data)>::Scalar;

Scalar element type of a SignalBlock* type.

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 VectorXi16

typedef Eigen::Matrix<int16_t, Eigen::Dynamic, 1> Syntalos::VectorXi16;

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 MatrixXi16

typedef Eigen::Matrix<int16_t, Eigen::Dynamic, Eigen::Dynamic, Eigen::RowMajor> Syntalos::MatrixXi16;

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 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 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 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 forEachTypeIn

template <typename List ,
typename Fn >
constexpr bool forEachTypeIn(
    Fn && fn
)

Call fn(std::type_identity<T>{}) for every T in the type list List.

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

function forEachStreamType

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

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

function forEachSignalBlockType

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

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

function withTypeIn

template <typename List ,
typename Fn >
constexpr bool withTypeIn(
    int typeId,
    Fn && fn
)

Call fn(std::type_identity<T>{}) for the type in List with the given ID.

Return: True if a type with this ID exists in the list (and fn was called), false otherwise.

function visitDataIn

template <typename List ,
typename Fn >
bool visitDataIn(
    BaseDataType & data,
    Fn && fn
)

Call fn(static_cast<T &>(data)) with the concrete type of data, if it is in List.

Return: True if the type was found in the list (and fn was called), false otherwise.

This lets code that only holds a BaseDataType reference (e.g. obtained via VariantStreamSubscription::callIfNextVar) dispatch to a generic lambda.

function withSignalBlockType

template <typename Fn >
constexpr bool withSignalBlockType(
    int typeId,
    Fn && fn
)

Call fn(std::type_identity<T>{}) for the signal block type with the given ID.

function visitSignalBlock

template <typename Fn >
bool visitSignalBlock(
    BaseDataType & data,
    Fn && fn
)

Call fn(static_cast<T &>(data)) if data is a signal block, with T its concrete type.

Return: True if data was a signal block (and fn was called), false otherwise.

function scalarTypeName

template <typename Scalar >
inline std::string scalarTypeName(
    bool abbreviated =false
)

Human-readable name of an arithmetic scalar type, e.g. “Int16”, “UInt16”, “Float32”.

With abbreviated set, a short lowercase form is returned instead (“i16”, “u16”, “f32”), which is suitable for port IDs and similar identifiers.

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 matEnsureExclusive

inline void matEnsureExclusive(
    cv::Mat & mat,
    int rows,
    int cols,
    int type
)

Make mat an exclusively owned matrix of the given shape.

Reuses the existing pixel buffer if it already has the requested dimensions and type and we are its sole owner, otherwise a fresh buffer is allocated. This keeps a steady-state producer from allocating once per frame, while staying safe when a consumer lags behind: if the refcount is greater than one, subscriber queues still hold shallow copies of the previously published frame, and overwriting the buffer in place would corrupt them. Assigning a new matrix drops our reference instead, so those queued copies stay valid until their owners are done with them.

Any producer that wants to recycle its output buffer must go through this. cv::Mat::create() alone is NOT sufficient: it keeps an existing buffer whenever the requested dimensions and type already match, no matter how many other references to it exist.

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 serializedEigenSize

template <typename EigenType >
inline ssize_t serializedEigenSize(
    const EigenType & matrix
)

Exact number of bytes serializeEigen() writes for matrix: a uint64 row and col count, followed by row*col scalars. Used to size buffers in advance.

function writeEigenPairToMemory

template <typename TsType ,
typename DataType >
inline bool writeEigenPairToMemory(
    void * memory,
    ssize_t size,
    const TsType & timestamps,
    const DataType & data
)

Serialize a (timestamps, data) matrix pair straight into a caller-provided memory block, using the identical wire format as serializeEigen(). When size is < 0 it is derived from the matrices. Returns true on success.

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 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 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()

Retrieve the default (“root”) logger.

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,
    const QString & logDir =QString(),
    const QString & logName =QStringLiteral("syntalos")
)

Parameters:

• consoleLogLevel Minimum log level for all loggers (and thereby the console).
• logDir If not empty, log output is also written to <logDir>/<logName>.log. Logs of previous sessions are kept as rotated files (<logName>.1.log, …).
• logName Base name of the log file, without extension.

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

function currentLogFilePath

QString currentLogFilePath()

Absolute path to the log file of the current session, or an empty string if logging to a file is disabled.

function currentLogDir

QString currentLogDir()

Directory containing the current and rotated log files, or an empty string if logging to a file is disabled.

function shutdownSyLogSystem

void shutdownSyLogSystem()

Shut the logging system down and flush all pending messages. Must be called last in a program, as logging is not possible afterwards.

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 setupLogFileSink

static void setupLogFileSink(
    const QString & logDir,
    const QString & logName
)

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 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" 
)

function kTextEditorInstance

inline KTextEditor::Editor * kTextEditorInstance()

Obtain the global KTextEditor instance.

This wraps KTextEditor::Editor::instance() and applies workarounds for known issues in the underlying libraries. Always use this function instead of calling KTextEditor::Editor::instance() directly.

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;