Macros#

Macro to add other [almost identical] variants of the add() and operator+=() functions.

Macro to creaete a memory barrier in an operation.

Pretend we have builtin for documentation builds.

Defines the current major version of the Carbonite framework.

Defines the current minor version of the Carbonite framework.

A macro defined as 1 if compilation is targeting the AArch64 platform; 0 otherwise. May not be overridden on the command line or by defining before including this file. Set to 1 if __aarch64__ is defined, 0 if __x86_64__ or _M_X64 are defined, and left undefined otherwise.

Defined as __cdecl on Windows and an empty define on Linux. Used to explicitly state ABI calling convention for API functions. Update: Deprecated. Define left for compatibility.

Aligns a number or pointer to the next multiple of a provided alignment.

Aligns a size to the given alignment.

Defined as alignas(T) .

Returns the required alignment of a type.

This is a wrapper for the platform-specific call to the non-standard but almost universal alloca() function.

Instructs the compiler to force inline of the decorated function.

A helper macro that appends a number to the given name to create a unique name.

The name of the current architecture as a string.

A macro defined as 1 if the toolchain is building the current file with -fsanitize=address , that is, if __SANITIZE_ADDRESS__ is defined; 0 otherwise. May be overridden by defining a different value before including this file or by specifying a different value on the compiler command line. Microsoft Visual Studio supports address sanitizer starting with 2019 (v16.9) by specifying /fsanitize=address on the compiler command line. See https://learn.microsoft.com/en-us/cpp/sanitizers/asan?view=msvc-160 .

Optionally performs an assertion, by default for debug builds only.

A macro that is used to assert that a scope is running in task context in debug builds only.

Indicates whether asserts are enabled. May be overridden by defining this before including this file. By default, is set to 1 if CARB_DEBUG is non-zero. If this is overridden to a non-zero value and CARB_ASSERT is not defined, CARB_ASSERT will receive the default implementation.

Placeholder macro for any work that needs to be done at the global level for any IAssert related functionality.

A macro to ensure interop safety by assertion.

A helper to determine if member A.a matches the offset and size of B.b , causing a static assert if unmatched.

A helper to determine if the size and alignment of two given structures match, causing a static assert if unmatched.

Registers an asset type.

A macro used to help the compiler optimize the code better, by assuming that the condition b is true.

A macro that can be used to mark a function as async, that is, it always executes in the context of a task.

GCC only, defined as __attribute__((__VA_ARGS__)) ; ignored on non-GCC compilers.

Declare a compilation unit as script language bindings.

Declare a compilation unit as script language bindings.

On Windows platforms, defined as __debugbreak() ; on Linux, raise(SIGTRAP) . Used to break into the debugger.

Defined as CARB_ALIGN_AS(CARB_CACHELINE_SIZE) .

Minimum offset between two objects to avoid false sharing, i.e. cache line size. If C++17 is not supported, falls back to the default value of 64 bytes.

Optionally performs a runtime check assertion, by default for both debug and release builds.

A macro that is used to assert that a scope is running in task context in debug and checked builds.

Indicates whether runtime checking is enabled. May be overridden by defining this before including this file. By default, is set to 1 always. If this is overridden to a non-zero value and CARB_CHECK is not defined, CARB_CHECK will receive the default implementation.

A macro the returns the largest of two values.

Clang only, defined as __VA_ARGS__ ; ignored on non-Clang compilers including GCC.

A macro defined as 1 if compilation is using GNU C Compiler (GCC), that is, if _MSC_VER is not defined but __GNUC__ is defined. May be overridden by defining a different value before including this file or by specifying a different value on the compiler command line, however, only one of CARB_COMPILER_MSC and CARB_COMPILER_GNUC must be set to 1 ; the other macro(s) must be set to 0 .

A macro defined as 1 if compilation is using Microsoft Visual C++, that is, if _MSC_VER is defined. May be overridden by defining a different value before including this file or by specifying a different value on the compiler command line, however, only one of CARB_COMPILER_MSC and CARB_COMPILER_GNUC must be set to 1 ; the other macro(s) must be set to 0 .

A macro to mark a function as compile-time-only function.

Returns the count of an array as a size_t at compile time.

Returns the count of an array as a uint32_t at compile time.

Defined as constexpr because the current compiler supports C++17.

Defined as constexpr if the current compiler supports C++20; empty otherwise.

Defined as [[likely]] if the current compiler supports C++20 (that is, CARB_HAS_CPP20 is non-zero) and the compiler reports the presence of the likely attributes.

Defined as [[unlikely]] if the current compiler supports C++20 (that is, CARB_HAS_CPP20 is non-zero) and the compiler reports the presence of the unlikely attributes.

Defines global symbols specifically related to the crash reporter.

A macro indicating whether the current compilation unit is built in debug mode. Always defined as either 0 or 1. Can be overridden by defining before this file is included or by passing on the compiler command line. Defined as 0 if NDEBUG is defined; 1 otherwise.

MSVC only, defined as __declspec(__VA_ARGS__) ; ignored on non-MSVC compilers.

Plugin helper macro to define boiler-plate code to register and unregister the plugin with various other components in the system (e.g. logging channels, profiler, localization, etc.).

De-parenthesize the contents of pack_ . CARB_DEPAREN((x, y)) becomes x, y . An unparenthesized pack will cause cause a compilation failure; e.g.: CARB_DEPAREN(foo) will not work, but CARB_DEPAREN((foo)) will.

Declares a function as deprecated.

Create a "deferred loader" function.

Divides size by divisor and returns the closest integer greater than or equal to the division result.

Macro to work around Exhale tripping over constexpr sometimes and reporting things like: Invalid C++ declaration: Expected identifier in nested name, got keyword: static

Conditionally includes text only when documenting (i.e. when DOXYGEN_BUILD is defined).

Conditional (import/export) dynamic linking.

Compile-time conversion of string to carb::events::EventType .

Indicates whether exceptions are enabled for the current compilation unit. Value depends on parameters passed to the compiler.

The default executable file extension for the current platform.

UTF-16 version of the dynamic library extension.

Grants a function external linkage in a dynamic library or executable.

Instructs CARB_DYNAMICLINK to export instead of import.

Defined as extern "C" for C++ compilation, that is, when __cplusplus is defined; empty define otherwise.

A printf that will never be executed but allows the compiler to test if there are format errors.

Defined as [[fallthrough]] because the current compiler supports C++17.

Terminates the application if a check fails.

A macro that is used to assert that a scope is running in task context.

Declares a file as deprecated.

The maximum value that can be represented by float .

Formats a string as if by vsnprintf and invokes a callable with the result.

Formats a string as if by vsnprintf and invokes a callable with the result and the length.

Formats a string as if by vsnprintf and invokes a callable with the result and the length.

Formats a string as if by vsnprintf and invokes a callable with the result.

Defines global variables for use by Carbonite. Call this macro from the global namespace.

Frees memory previously allocated using CARB_MALLOC() .

Defines global variables of the framework and built-in plugins.

Defines global variables of the framework and built-in plugins.

GCC only, defined as gnuc_only_block ; ignored on non-GCC compilers including Clang.

Instructs the underlying hardware to idle the CPU pipelines and reduce the penalty from memory order violations.

Computes a literal string hash at compile time.

Syntactic sugar for CARB_HASH_STRING(CARB_STRINGIFY(T)) .

Always defined as 1 because the current compiler supports C++14.

Always defined as 1 because the current compiler supports C++17.

Defined as 1 if the current compiler supports C++20; 0 otherwise.

Indicates whether RTTI is enabled.

A macro to construct a hex-version.

Syntactic sugar for CARB_ATTRIBUTE(visibility("hidden")) ; ignored on compilers other than GCC.

Return exactly the arguments. This is useful for expansion of the tokens.

Macro declaring code that should be instantiated if TSan is NOT enabled.

Macro declaring code that should be instantiated if TSan is enabled.

For Clang only, disables a specific compiler warning for the current compilation warning configuration. Defined as _Pragma("GCC diagnostic ignored <warning>") for Clang only; ignored by other compilers.

For Clang only, pops the compilation warning configuration previously pushed with CARB_IGNOREWARNING_CLANG_PUSH , overwriting the current state. Defined as _Pragma("GCC diagnostic pop") for Clang only; ignored by other compilers.

For Clang only, pushes the current compilation warning configuration. Defined as _Pragma("GCC diagnostic push") for Clang only; ignored by other compilers.

Syntactic sugar for CARB_IGNOREWARNING_CLANG_PUSH followed by CARB_IGNOREWARNING_CLANG .

For GCC only, disables a specific compiler warning for the current compilation warning configuration. Defined as _Pragma("GCC diagnostic ignored <warning>") for GCC only; ignored by other compilers.

For GCC only, pops the compilation warning configuration previously pushed with CARB_IGNOREWARNING_GNUC_PUSH , overwriting the current state. Defined as _Pragma("GCC diagnostic pop") for GCC only; ignored by other compilers.

For GCC only, pushes the current compilation warning configuration. Defined as _Pragma("GCC diagnostic push") for GCC only; ignored by other compilers.

Syntactic sugar for CARB_IGNOREWARNING_GNUC_PUSH followed by CARB_IGNOREWARNING_GNUC .

For MSVC only, disables a specific compiler warning for the current compilation warning configuration. Defined as __pragma(warning(disable : <w>)) for MSVC only; ignored by other compilers.

For MSVC only, pops the compilation warning configuration previously pushed with CARB_IGNOREWARNING_MSC_PUSH , overwriting the current state. Defined as __pragma(warning(pop)) for MSVC only; ignored by other compilers.

For MSVC only, pushes the current compilation warning configuration. Defined as __pragma(warning(push)) for MSVC only; ignored by other compilers.

Syntactic sugar for CARB_IGNOREWARNING_MSC_PUSH followed by CARB_IGNOREWARNING_MSC .

Imports a function with external linkage from a shared object or DLL.

Returns whether it is safe to access a member of a versioned struct.

A macro that is used only for public includes to define a function which will instantiate templates.

Helper macro to implement default behavior of carb::IObject interface functions IObject::addRef() and IObject::release().

Helper macro that results in a boolean expression which is true if the current thread is running in task context.

Tests whether the Carbonite SDK headers match the version of used to build the framework.

A macro that joins two parts to create one symbol allowing one or more parameters to be a macro, as if by the ## preprocessor operator. Example: CARB_JOIN(test, __LINE__) on line 579 produces test579 .

The default library file extension for the current platform.

UTF-16 version of the dynamic library extension.

A macro to build a library file's name as a string literal.

Retrieves the default library file prefix for the current platform.

If the current compiler is GCC, defined as __builtin_expect(!!(<expr>), 1) . Otherwise, defined as (!!(<expr>)) .

A helper for using both the CARB_LIKELY macro as well as the CARB_CPP20_LIKELY macro.

Placeholder for global scope work that needs to be done for localization.

Look up a string from the localization database for the current plugin.

Logging macro if the level is dynamic.

Logging macro for static log level.

Single-time logging macro for static log level.

Logging macro for static log level.

Single-time logging macro for static log level.

Placeholder macro for any globals that must be declared for the logging system.

Logging macro for static log level.

Single-time logging macro for static log level.

Single-time logging macro if the level is dynamic.

Logging macro for static log level.

Single-time logging macro for static log level.

Logging macro for static log level.

Single-time logging macro for static log level.

A macro to mark placeholder functions on MacOS while the porting effort is in progress.

A macro for producing a carb::FourCC value from four characters.

Allocates memory from the heap.

A macro the returns the largest of two values.

A macro that can be used to mark a function as possibly async, that is, it may execute in the context of a task.

Defined as [[maybe_unused]] because the current compiler supports C++17.

A macro that returns the least of two values.

MSVC only, defined as __VA_ARGS__ ; ignored on non-MSVC compilers.

Records the name of a thread.

Defined as [[nodiscard]] because the current compiler supports C++17.

Defined as [[nodiscard(msg)]] if the current compiler supports C++20; falls back to [[nodiscard]] without the message pre-C++20.

Defined as [[nodiscard]] because the current compiler supports C++17.

Defined as [[nodiscard(msg)]] if the current compiler supports C++20; falls back to CARB_NODISCARD_TYPE without the message pre-C++20.

Declares that a function will not throw any exceptions.

A macro that declares that a function may not be inlined.

Only non-Clang compilers including GCC, defined as __VA_ARGS__ ; ignored on Clang.

Only non-GCC compilers including Clang, defined as __VA_ARGS__ ; ignored on GCC.

Only non-MSVC compilers, defined as __VA_ARGS__ ; ignored on MSVC.

Declares a value or statement in a way that prevents Doxygen and Sphinx from getting confused about matching symbols. There seems to be a bug in Sphinx that prevents at least templated symbols from being matched to the ones generated by Doxygen when keywords such as decltype are used. This is effectively the opposite operation as CARB_DOC_ONLY() .

Disables optimizations for the function that is tagged with this attribute. This only affects the single function that it tags. Optimizations will be restored to the previous settings for the translation unit outside of the tagged function.

Defined as [[no_unique_address]] if the current compiler supports C++20; empty otherwise.

Returns the offset of a member of a class at compile time.

Returns the offset of a member m of a class t at compile time.

Turns optimizations off at the function level until a CARB_OPTIMIZE_ON_MSC() call is seen. This must be called outside of the body of any function and will remain in effect until either a CARB_OPTIMIZE_ON_MSC() call is seen or the end of the translation unit. This unfortunately needs to be a separate set of macros versus the one for GCC and Clang due to the different style of disabling and enabling optimizations under the MSC compiler.

Restores previous optimizations that were temporarily disable due to an earlier call to CARB_OPTIMIZE_OFF_MSC() . This must be called outside the body of any function. If this call is not made, the previous optimization state will remain until the end of the current translation unit.

A macro defined as 1 if compilation is targeting Linux; 0 otherwise. Exactly one of the CARB_PLATFORM_* macros will be set to 1 . May be overridden by defining before this file is included or by passing on the compiler command line. By default, set to 1 if _WIN32 is not defined and __linux__ is defined.

A macro defined as 1 if compilation is targeting Mac OS; 0 otherwise. Exactly one of the CARB_PLATFORM_* macros will be set to 1 . May be overridden by defining before this file is included or by passing on the compiler command line. By default, set to 1 if _WIN32 and __linux__ are not defined and __APPLE__ is defined.

The name of the current platform as a string.

A macro defined as 1 if compilation is targeting Windows; 0 otherwise. Exactly one of the CARB_PLATFORM_* macros will be set to 1 . May be overridden by defining before this file is included or by passing on the compiler command line. By default, set to 1 if _WIN32 is defined.

Main macro to declare a plugin implementation where multiple interface versions are not required.

Macros to declare a plugin implementation dependencies.

Main macro to declare a plugin implementation where multiple interface versions are required.

Macro to declare a "minimal" plugin.

Macro to declare a plugin without dependencies.

Macro to declare a struct as a Carbonite interface.

Macro to declare a struct as a Carbonite interface that allows for a different current version than latest.

This is set to _POSIX_VERSION platforms that are mostly-compliant with POSIX.

Generic pragma, only to be used for pragmas that are the same on all supported compilers.

GCC only, defined as _Pragma(__VA_ARGS__) ; ignored on non-GCC compilers.

MSVC only, defined as __pragma(__VA_ARGS__) ; ignored on non-MSVC compilers.

Attempts to prefetch from memory using a compiler intrinsic.

Acts as a char[] with the current full function signature.

A macro that deletes the copy-construct and copy-assign functions for the given classname.

Syntactic sugar for both CARB_PREVENT_COPY and CARB_PREVENT_MOVE .

A macro that deletes the move-construct and move-assign functions for the given classname.

Requests that the compiler validate any variadic arguments as printf-style format specifiers, if supported by the compiler. Causes a compilation error if the printf-style format specifier doesn't match the given variadic types.

Placeholder macro for any work that needs to be done at the global scope for the profiler.

Records an allocation event for profilers that support them.

Records an allocation event for a named memory pool for profilers that support them.

Marks the beginning of a profiling zone.

Submit context calibration information that allows correlating CPU and GPU clocks.

Create a new GPU profiling context that allows injecting timestamps coming from a GPU in a deferred manner.

Declares a channel that can be used with the profiler.

Destroy a previously created GPU Context.

Marks the end of a profiling zone previously started with CARB_PROFILE_BEGIN() .

Records an instant event on a thread's timeline at the current time.

References a channel declared in another compilation unit.

Records the beginning of a flow event on the timeline at the current time for the current thread.

Records the end of a flow event on the timeline at the current time for the current thread.

Inserts a frame marker for the calling thread in the profiling output, for profilers that support frame markers.

Inserts an anonymous frame marker along with an RGBA image (for profilers that support it).

Records a free event for profilers that support them.

Records a free event for a named memory pool for profilers that support them.

A helper for CARB_PROFILE_ZONE() that automatically uses the function name as from CARB_PRETTY_FUNCTION .

Record the beginning of a new GPU timestamp query.

Record the end of a new GPU timestamp query.

Set the value we've received from the GPU for a query (begin or end) we've issued in the past.

Create a lockable context which we can use to tag lock operation.

Destroy a lockable context.

Records a lockable operation on a thread's timeline at the current time.

Registers a static string for use with the profiler.

A helper to set the capture mask.

Shuts down the profiler that has been registered with carb::profiler::registerProfilerForClient() and previously started with CARB_PROFILE_STARTUP() .

Starts the profiler that has been registered with carb::profiler::registerProfilerForClient() .

Writes a named numeric value to the profiling output for profilers that support them.

Creates a profiling zone over a scope.

When set to a non-zero value, profiling macros in include/carb/profiler/Profile.h will report to the profiler; otherwise the profiling macros have no effect. Always set to 1 by default, but may be overridden by defining a different value before including this file or by specifying a different value on the compiler command line.

Changes how the carbReallocate symbol is acquired.

Undocumented.

A macro to retry operations if they return -1 and errno is set to EINTR.

Rounds a given value to the next highest multiple of another given value.

Version string for this SDK build. This string is also returned by carbGetSdkVersion(). This value can be passed to CARB_IS_SAME_SDK_VERSION() to verify that the loaded version of the Carbonite framework library matches the headers that are in use.

Attempts to allocate an array of the given type on the stack.

Macro to mark static and global variables to keep them when plugin is hot-reloaded.

Turns a name into a string, resolving macros (i.e. CARB_STRINGIFY(__LINE__) on line 815 will produce "815" ).

A macro defined as 1 if compilation is targeting the Tegra platform. By default set to 1 only if __aarch64__ and __LINARO_RELEASE__ are defined; 0 otherwise. May be overridden by defining a different value before including this file or by specifying a different value on the compiler command line.

A macro defined as 1 if a Clang-infrastructure toolchain is building the current file, that is, if __clang__ is defined; 0 if not. May be overridden by defining a different value before including this file or by specifying a different value on the compiler command line.

A macro defined as 1 if the toolchain is building the current file with -fsanitize=thread , that is, if __SANITIZE_THREAD__ is defined; 0 otherwise. May be overridden by defining a different value before including this file or by specifying a different value on the compiler command line. Microsoft Visual Studio does not support thread sanitizer.

The maximum value that can be represented by uint16_t .

The maximum value that can be represented by uint32_t .

The maximum value that can be represented by uint64_t .

The maximum value that can be represented by unsigned long long .

A macro to mark functionality that has not been implemented yet.

If the current compiler is GCC, defined as __builtin_expect(!!(<expr>), 0) . Otherwise, defined as (!!(<expr>)) .

A helper for using both the CARB_UNLIKELY macro as well as the CARB_CPP20_UNLIKELY macro.

A macro used to express that the current code position is unreachable.

A macro to put into the #else branches when writing CPU architecture specific code.

A macro to put into the #else branches when writing compiler specific code.

A macro to put into #else branches when writing platform-specific code.

The maximum value that can be represented by unsigned short .

A macro meant to be used in preprocessor #if statements.

A macro that can be used to indicate classes and members that participate in visualizers, such as carb.natvis . This is a reminder that these classes, members and types will require visualizer fixup if changes are made.

Syntactic sugar for CARB_DECLSPEC(selectany) CARB_ATTRIBUTE(weak) , used to enable weak linking.

A macro defined as 1 if compilation is targeting the x86-64 platform; 0 otherwise. May not be overridden on the command line or by defining before including this file. Set to 0 if __aarch64__ is defined, 1 if __x86_64__ or _M_X64 are defined, and left undefined otherwise.

Used when declaring opaque types to prevent Doxygen from getting confused about not finding any implementation.

Declares a symbol that is marked as externally exported. The symbol will be exported with C decorations. On Windows, this is expected to be exported from the containing DLL. On Linux, this is exported as having default visibility from the module instead of being hidden. This export tag should only be used when tagging exported symbols from within omni.core itself. Exported symbols in other modules (such as omniGetModuleExports() functions in implementation libraries) should use OMNI_MODULE_API instead.

Helper macro to declare globals needed my the omni library when using the omni library in an application.

Like std::assert. Basically OMNI_FATAL_UNLESS, but compiles to a no-op in debug builds.

Set to 1 to indicate that assertion checks are enabled. Set to 0 if assertion checks will just be ignored. This value will always be defined regardless of the current mode.

Provides additional contextual information to the 'omni.bind' code generation tool. This information is used to generated efficient bindings to the interface.

Triggers a breakpoint. If no debugger is attached, the program terminates.

Helper macro to catch exceptions and return them as omni::core::Result codes. Useful when writing ABI code.

Checks if the given condition is true, if not, the given optional message is printed to stdout and the program is terminated.

Indicates whether runtime checking is enabled. For the time being this is always set to 1 indicating that the default implementation should not be overridden. This may change in the future.

Initializes the omni library along with Carbonite. Ensures that both libraries will be cleaned up upon exit.

Helper macro to startup the Carbonite framework and Omni type factory.

Helper macro to shutdown the Carbonite framework and Omni type factory.

Helper macro to shutdown the Carbonite framework and Omni type factory, for script bindings.

Used to forward declare an interface.

Used to extend the omni.bind generated API layer.

Grants a function external linkage in a dynamic library or executable.

Declares a "C" exported external symbol. This uses the "C" name decoration style of adding an underscore to the start of the exported name.

Returns true if the given omni::core::Result is a failure code.

This macro is surprisingly complex mainly because it accepts a variable number of arguments. If a single argument is given, a message in the following form is printed:

Helper to force a symbol to be linked.

Macro to access generated API of an interface.

Adds the name_ as the default logging channel.

Implementation detail. Do not directly use. Use OMNI_GLOBALS_ADD_DEFAULT_CHANNEL .

Format code to use for the carb::launcher::ProcessId data type in printf() style format strings.

Defines the properties of a channel and adds it to a module specific list of channels.

Given a channel name (as a string), declares a global variable to identify the channel.

The default channel variable to use when no channel is supplied to the OMNI_LOG_* macros.

Defines the properties of a channel.

Logs a message at omni::log::Level::eError level.

Logs a message at omni::log::Level::eFatal level.

Logs a message at omni::log::Level::eInfo level.

Logs a message at omni::log::Level::eVerbose level.

Logs a message at omni::log::Level::eWarn level.

Logs a message.

Adds a log channel to the logging system. The channel will be removed when the module is unloaded.

adds a new schema to be registered after core startup.

Declares a function that is marked as externally exported. The symbol will be exported with C decorations. On Windows, this is expected to be exported from the containing DLL. On Linux, this is exported as having default visibility from the module instead of being hidden. This is intended for exported symbols in implementation libraries.

Defines default implementations of global Carbonite functions for an Omni module.

Defines functions centered around determining the current module's disk location.

Defines default implementations of global omni functions for a module.

Helper macro for defining an entry (i.e. omni::core::ModuleExportEntry ) in the export table (i.e. omni::core::ModuleExports ).

Helper macro for defining an entry in the export table.

Registers the function responsible for advertising the plugin's interface dependencies.

Helper macro to declare globals needed by modules (i.e. plugins).

Defines global symbols intended to be used to statically analyze whether a given plugin is a debug or release build. In a debug build, the g_carbIsDebugConfig symbol will be present. In a release build, the g_carbIsReleaseConfig symbol will be present. These symbols are not intended to be used at runtime, but rather to be able to determine the build configuration without having to load up the module in a process first.

Helper macro to declare globals needed by modules (i.e. plugins).

Registers the plugin's function that determines if the plugin can be unloaded. See omni::core::OnModuleCanUnloadFn for details.

Registers the plugin's function who is responsible for cleaning up the plugin when the plugin unload is being skipped during a quick shutdown.

Registers the plugin's function who is responsible for advertising the available interface implementations in the plugin.

Registers the plugin's function that will be called once the plugin is loaded. See omni::core::OnModuleStartedFn for threading consideration with this function.

Registers the plugin's function who is responsible for cleaning up the plugin when the plugin is being unloaded.

Requires that the owning omni::core::ITypeFactory provides a Carbonite client name: g_carbClientName .

Requires that the owning omni::core::ITypeFactory provides a Carbonite carb::Framework g_carbFramework .

Requires that the owning omni::core::ITypeFactory provides a Carbonite carb::assert::IAssert g_carbAssert .

Requires that the owning omni::core::ITypeFactory provides a Carbonite carb::l10n::IL10n g_carbLocalization .

Requires that the owning omni::core::ITypeFactory provides a Carbonite carb::logging::ILogging g_carbLogging .

Requires that the owning omni::core::ITypeFactory provides a Carbonite carb::profiler::IProfiler g_carbProfiler .

Helper macro to set known export fields in omniModuleGetExports() related to Carbonite.

Helper macro to set known export fields in omniModuleGetExports() .

Helper macro to set known export fields in omniModuleGetExports() .

Set to 1 if compiling a Linux build. Set to 0 otherwise. This symbol will always be defined even when not on a Linux build. It can thus be used to pass as parameters or in if-statements to modify behavior based on the platform.

Set to 1 if compiling a MacOS build. Set to 0 otherwise. This symbol will always be defined even when not on a MacOS build. It can thus be used to pass as parameters or in if-statements to modify behavior based on the platform.

Set to 1 if compiling a Windows build. Set to 0 otherwise. This symbol will always be defined even when not on a Windows build. It can thus be used to pass as parameters or in if-statements to modify behavior based on the platform.

Provides a list of dependent interfaces for an ONI plugin.

Declares that the calling plugin has no dependencies on any other Carbonite or ONI interfaces.

Used to declare the interface description for an ONI object's API layer.

This is set to _POSIX_VERSION platforms that are mostly-compliant with POSIX.

The printf format macro to print a process ID.

The printf format macro to print a thread ID.

The printf format macro to print a process ID in hexadecimal.

The printf format macro to print a thread ID in hexadecimal.

Declare a compilation unit as script language bindings.

Helper macro used to return a omni::core::Result . When in debug mode and attached to a debugger, this macro will cause a debugger break. Useful for determining the origin of an error.

Helper macro to return an appropriate omni::core::Result when the given argument is nullptr . Useful when authoring ABI code.

If the given omni::core::Result is a failure code, calls return result to exit the current function.

Common entry point for sending an event.

Sets that a schema should be registered on module load.

Helper macro to piece together a unique event name to generate an ID from.

Returns true if the given omni::core::Result is not a failure code.

Helper macro to throw a omni::core::ResultError exception if a function argument is nullptr . Used heavily by omni.bind .

Helper macro to convert a omni::core::Result to a omni::core::ResultError exception. Useful when authoring API code. Used heavily by omni.bind .

Returns the type id of the given type name at compile time.

Used in cases when defined interface provides an overload for a function from generated API.

The settings prefix to indicate that a setting is persistent.

A placeholder for DWORD type.

A placeholder for DWORD type, in hexadecimal format.

The separator character used by carb.settings .

The Carbonite Framework default version.

The latest version of the Carbonite Framework available.

The default current version for carb::crashreporter::ICrashReporter .

Latest version for carb::crashreporter::ICrashReporter .

The default version number of the carb::eventdispatcher::IEventDispatcher interface to use for this build. This macro may be overridden in the project settings to instead use the latest version of the interface.

The version number of the latest carb::eventdispatcher::IEventDispatcher interface.

The default version number of the carb::events::IEvents interface to use for this build. This macro may be overridden in the project settings to instead use the latest version of the interface.

The default version number of the carb::events::IEventsAdapter interface to use for this build. This macro may be overridden in the project settings to instead use the latest version of the interface.

The version number of the latest carb::events::IEventsAdapter interface.

The version number of the latest carb::events::IEvents interface.

The default current version for carb::logging::ILogging .

Latest version for carb::logging::ILogging .

The default current version for carb::profiler::IProfiler .

Latest version for carb::crashreporter::IProfiler.

The current default IStats interface version.

Latest IStats interface version.

Default version of ITasking interface to use.

Latest version of ITasking interface available.

The default current version of carb::windowing::IWindowing .

Latest version for carb::windowing::IWindowing .

The default current version for omni::kit::IApp .

Latest version for omni::kit::IApp .