GXF Core C API#

上下文#

创建上下文#

type gxf_context_t#

上下文句柄的类型。

定义为 void*。

kNullContext#

无效的上下文。

定义为 nullptr。

kGxfCoreVersion#

GXF Core 版本

定义为 4.1.0。

enum gxf_result_t#

表示 GXF 错误和结果代码的枚举类型。

enumerator GXF_SUCCESS#

操作成功。

enumerator GXF_FAILURE#

操作失败。

enumerator GXF_NOT_IMPLEMENTED#

功能未实现。

enumerator GXF_FILE_NOT_FOUND#

文件未找到。

enumerator GXF_INVALID_ENUM#

无效的枚举值。

enumerator GXF_NULL_POINTER#

传递了空指针。

enumerator GXF_UNINITIALIZED_VALUE#

值未初始化。

enumerator GXF_ARGUMENT_NULL#

参数为空。

enumerator GXF_ARGUMENT_OUT_OF_RANGE#

参数超出范围。

enumerator GXF_ARGUMENT_INVALID#

无效的参数。

enumerator GXF_OUT_OF_MEMORY#

内存不足。

enumerator GXF_MEMORY_INVALID_STORAGE_MODE#

无效的内存存储模式。

enumerator GXF_CONTEXT_INVALID#

无效的上下文。

enumerator GXF_EXTENSION_NOT_FOUND#

未找到扩展。

enumerator GXF_EXTENSION_FILE_NOT_FOUND#

未找到扩展文件。

enumerator GXF_EXTENSION_NO_FACTORY#

扩展没有工厂。

enumerator GXF_FACTORY_TOO_MANY_COMPONENTS#

工厂中组件过多。

enumerator GXF_FACTORY_DUPLICATE_TID#

工厂中类型 ID 重复。

enumerator GXF_FACTORY_UNKNOWN_TID#

工厂中类型 ID 未知。

enumerator GXF_FACTORY_ABSTRACT_CLASS#

工厂抽象类。

enumerator GXF_FACTORY_UNKNOWN_CLASS_NAME#

工厂中类名未知。

enumerator GXF_FACTORY_INVALID_INFO#

无效的工厂信息。

enumerator GXF_FACTORY_INCOMPATIBLE#

工厂不兼容。

enumerator GXF_ENTITY_NOT_FOUND#

实体未找到。

enumerator GXF_ENTITY_NAME_EXCEEDS_LIMIT#

实体名称字符串超出指定限制。

enumerator GXF_ENTITY_COMPONENT_NOT_FOUND#

实体组件未找到。

enumerator GXF_ENTITY_CAN_NOT_ADD_COMPONENT_AFTER_INITIALIZATION#

初始化后无法向实体添加组件。

enumerator GXF_ENTITY_CAN_NOT_REMOVE_COMPONENT_AFTER_INITIALIZATION#

初始化后无法从实体移除组件。

enumerator GXF_ENTITY_MAX_COMPONENTS_LIMIT_EXCEEDED#

超出实体中组件数量的最大限制

enumerator GXF_PARAMETER_NOT_FOUND#

参数未找到。

enumerator GXF_PARAMETER_ALREADY_REGISTERED#

参数已注册。

enumerator GXF_PARAMETER_INVALID_TYPE#

无效的参数类型。

enumerator GXF_PARAMETER_OUT_OF_RANGE#

参数超出范围。

enumerator GXF_PARAMETER_NOT_INITIALIZED#

参数未初始化。

enumerator GXF_PARAMETER_CAN_NOT_MODIFY_CONSTANT#

无法修改常量参数。

enumerator GXF_PARAMETER_PARSER_ERROR#

参数解析器错误。

enumerator GXF_PARAMETER_NOT_NUMERIC#

参数不是数字。

enumerator GXF_PARAMETER_MANDATORY_NOT_SET#

强制参数未设置。

enumerator GXF_CONTRACT_INVALID_SEQUENCE#

无效的合同序列。

enumerator GXF_CONTRACT_PARAMETER_NOT_SET#

合同参数未设置。

enumerator GXF_CONTRACT_MESSAGE_NOT_AVAILABLE#

合同消息不可用。

enumerator GXF_INVALID_LIFECYCLE_STAGE#

无效的生命周期阶段。

enumerator GXF_INVALID_EXECUTION_SEQUENCE#

无效的执行顺序。

enumerator GXF_REF_COUNT_NEGATIVE#

引用计数为负数。

enumerator GXF_RESULT_ARRAY_TOO_SMALL#

结果数组太小。

enumerator GXF_INVALID_DATA_FORMAT#

无效的数据格式。

enumerator GXF_EXCEEDING_PREALLOCATED_SIZE#

超出预分配大小。

enumerator GXF_QUERY_NOT_ENOUGH_CAPACITY#

查询容量不足。

enumerator GXF_QUERY_NOT_APPLICABLE#

查询不适用。

enumerator GXF_QUERY_NOT_FOUND#

查询未找到。

enumerator GXF_NOT_FINISHED#

操作未完成。

enumerator GXF_HTTP_GET_FAILURE#

HTTP GET 请求失败。

enumerator GXF_HTTP_POST_FAILURE#

HTTP POST 请求失败。

enumerator GXF_ENTITY_GROUP_NOT_FOUND#

实体组未找到。

enumerator GXF_RESOURCE_NOT_INITIALIZED#

资源未初始化。

enumerator GXF_RESOURCE_NOT_FOUND#

资源未找到。

enumerator GXF_CONNECTION_BROKEN#

连接已断开。

enumerator GXF_CONNECTION_ATTEMPTS_EXCEEDED#

超出连接尝试次数。

enumerator GXF_IPC_CONNECTION_FAILURE#

IPC 连接失败。

enumerator GXF_IPC_CALL_FAILURE#

IPC 调用失败。

enumerator GXF_IPC_SERVICE_NOT_FOUND#

IPC 服务未找到。

gxf_result_t GxfContextCreate(gxf_context_t *context);#

创建一个新的 GXF 上下文

几乎所有 GXF 操作都需要 GXF 上下文。上下文必须使用 ‘GxfContextDestroy’ 销毁。可以在同一进程中创建多个上下文，但它们不能相互通信。

参数:

  • context – 新的 GXF 上下文将被写入到给定的指针。

返回值:

如果操作成功，则返回 GXF_SUCCESS，否则返回 GXF 错误代码之一。

从共享上下文中创建上下文#

gxf_result_t GxfContextCreateShared(
gxf_context_t shared,
gxf_context_t *context,
);#

从共享上下文中创建新的运行时上下文。

共享运行时上下文用于在同一进程中运行的图之间共享实体。

参数:

  • shared – 有效的 GXF 共享上下文。

  • context – 新的 GXF 上下文将被写入到给定的指针

返回值:

如果操作成功，则返回 GXF_SUCCESS，否则返回 GXF 错误代码之一。

从上下文中获取共享上下文#

gxf_result_t GxfGetSharedContext(
gxf_context_t context,
gxf_context_t *shared,
);#

从现有的运行时上下文中获取共享上下文。

参数:

  • context – 有效的 GXF 共享上下文。

  • shared – 共享上下文。

返回值:

如果操作成功，则返回 GXF_SUCCESS，否则返回 GXF 错误代码之一。

销毁上下文#

gxf_result_t GxfContextDestroy(gxf_context_t context);#

销毁 GXF 上下文

每个 GXF 上下文都必须通过调用此函数来销毁。上下文必须先前已使用 ‘GxfContextCreate’ 创建。 这也将销毁作为上下文一部分创建的所有实体和组件。

参数:

  • context – 有效的 GXF 上下文。

返回值:

如果操作成功，则返回 GXF_SUCCESS，否则返回 GXF 错误代码之一。

扩展#

kMaxExtensions#

上下文中扩展的最大数量。

定义为 1024。

GxfLoadExtensionsInfo#

type GxfLoadExtensionsInfo#

一个结构，用于指定加载扩展的参数。

const char *const *extension_filenames#

要加载的扩展文件名的可选列表。

uint32_t extension_filenames_count#

要加载的扩展数量。

const char *const *manifest_filenames#

要加载的清单文件名的可选列表。

uint32_t manifest_filenames_count#

要加载的清单数量。

const char *base_directory#

一个可选的基目录，它会被添加到所有扩展文件名的前面，包括通过清单文件加载的文件名。

加载扩展库#

gxf_result_t GxfLoadExtensions(
gxf_context_t context,
const GxfLoadExtensionsInfo *info,
);#

加载 GXF 扩展库

直接通过文件名或间接通过加载清单文件来加载一个或多个扩展。在将组件添加到 GXF 实体之前，必须加载提供该组件的 GXF 扩展共享库。一个扩展只能加载一次。

为了简化一次加载多个扩展，开发人员可以创建一个清单文件，其中列出他需要的所有扩展。然后，此函数将加载清单文件中列出的所有扩展。可以加载多个清单，但是每个扩展仍然只能加载一次。

清单文件是一个 YAML 文件，其中包含一个顶级条目 ‘extensions’，后跟 GXF 扩展共享库的文件名列表。

示例：----- 文件开始 ----- extensions: - gxf/std/libgxf_std.so - gxf/npp/libgxf_npp.so ----- 文件结束 -----

参数:

  • context – 有效的 GXF 上下文

  • filename – 有效的文件名。

返回值:

如果操作成功，则返回 GXF_SUCCESS，否则返回 GXF 错误代码之一。

从指针加载扩展#

gxf_result_t GxfLoadExtensionFromPointer(
gxf_context_t context,
void *extension_ptr,
);#

从指向 Extension 对象的指针加载扩展。

参数:

  • context – 有效的 GXF 上下文

  • extension_ptr – 指向 Extension 的指针

返回值:

如果操作成功，则返回 GXF_SUCCESS，否则返回 GXF 错误代码之一。

加载元数据文件#

gxf_result_t GxfLoadExtensionMetadataFiles(
gxf_context_t context,
const char *const *filenames,
uint32_t count,
);#

加载 gxf_registry 生成的元数据文件

gxf_registry 工具在注册期间生成扩展内容的元数据文件。这些元数据文件可以用于解析依赖于它们的其他扩展的组件的类型名称和 TID。元数据文件不包含扩展的实际实现，必须仅加载以在扩展库上运行扩展查询 API，这些库具有实际实现，并且仅依赖于元数据进行类型解析。

如果扩展 B 的某些组件依赖于扩展 A 中的某些组件：- 加载扩展 A 的元数据文件 - 使用 ‘GxfLoadExtensions’ 加载扩展 B 的扩展库 - 对扩展 B 及其组件运行扩展查询 API。

参数:

  • context – 有效的 GXF 上下文。

  • filenames – 注册期间由注册表生成的元数据文件的绝对路径

  • count – 要加载的元数据文件数量

返回值:

如果操作成功，则返回 GXF_SUCCESS，否则返回 GXF 错误代码之一。

注册组件#

gxf_result_t GxfRegisterComponent(
gxf_context_t context,
gxf_tid_t tid,
const char *name,
const char *base_name,
);#

向 GXF 扩展注册组件

GXF 扩展需要在扩展工厂函数中注册其所有组件。为了方便起见，可以使用 gxf/std/extension_factory_helper.hpp 中的辅助宏。

开发者必须使用两个随机 64 位整数选择唯一的 GXF tid。开发者必须确保每个 GXF 组件都有唯一的 tid。组件的名称必须是组件的完全限定 C++ 类型名称。一个组件只能有一个基类，并且该基类必须使用其完全限定 C++ 类型名称作为参数 ‘base_name’ 来指定。

参考: gxf/std/extension_factory_helper.hpp 参考: core/type_name.hpp

参数:

  • context – 有效的 GXF 上下文

  • tid – 选择的 GXF tid

  • name – 组件的类型名称

  • base_name – 组件基类的类型名称

返回值:

如果操作成功，则返回 GXF_SUCCESS，否则返回 GXF 错误代码之一。

在运行时注册组件#

gxf_result_t GxfRegisterComponentInExtension(
gxf_context_t context,
gxf_tid_t component_tid,
gxf_tid_t extension_tid,
);#

在运行时从扩展注册一个新组件

一旦加载了扩展，任何新添加到该扩展的组件都可以使用此函数在上下文中注册

参数:

  • context – 有效的 GXF 上下文

  • component_tid – 未注册的新组件的有效 GXF tid

  • extension_tid – 已加载的扩展的有效 GXF tid

返回值:

如果操作成功，则返回 GXF_SUCCESS，否则返回 GXF 错误代码之一。

图执行#

从 YAML 文件加载实体列表#

gxf_result_t GxfGraphLoadFile(
gxf_context_t context,
const char *filename,
const char *parameters_override[],
const uint32_t num_overrides,
);#
参数:

  • context – 有效的 GXF 上下文

  • filename – 有效的 YAML 文件名。

  • params_override – 用于覆盖 yaml 文件中参数的可选字符串数组。

  • num_overrides – 可选覆盖参数字符串的数量。

返回值:

如果操作成功，则返回 GXF_SUCCESS，否则返回 GXF 错误代码之一。

设置加载期间搜索 YAML 文件的根文件夹#

gxf_result_t GxfGraphSetRootPath(
gxf_context_t context,
const char *path,
);#
参数:

  • context – 有效的 GXF 上下文

  • path – 加载期间搜索 YAML 文件的根文件夹路径

返回值:

如果操作成功，则返回 GXF_SUCCESS，否则返回 GXF 错误代码之一。

从 YAML 文本加载实体列表#

gxf_result_t GxfGraphParseString(
gxf_context_t context,
const char *tex,
const char *parameters_override[],
const uint32_t num_overrides,
);#
参数:

  • context – 有效的 GXF 上下文

  • text – 有效的 YAML 文本。

  • params_override – 用于覆盖 yaml 文件中参数的可选字符串数组。

  • num_overrides – 可选覆盖参数字符串的数量。

返回值:

如果操作成功，则返回 GXF_SUCCESS，否则返回 GXF 错误代码之一。

激活所有系统组件#

gxf_result_t GxfGraphActivate(gxf_context_t context);#
参数:

  • context – 有效的 GXF 上下文

返回值:

如果操作成功，则返回 GXF_SUCCESS，否则返回 GXF 错误代码之一。

停用所有系统组件#

gxf_result_t GxfGraphDeactivate(gxf_context_t context);#
参数:

  • context – 有效的 GXF 上下文

返回值:

如果操作成功，则返回 GXF_SUCCESS，否则返回 GXF 错误代码之一。

异步启动图的执行#

gxf_result_t GxfGraphRunAsync(gxf_context_t context);#
参数:

  • context – 有效的 GXF 上下文

返回值:

如果操作成功，则返回 GXF_SUCCESS，否则返回 GXF 错误代码之一。

中断图的执行#

gxf_result_t GxfGraphInterrupt(gxf_context_t context);#
参数:

  • context – 有效的 GXF 上下文

返回值:

如果操作成功，则返回 GXF_SUCCESS，否则返回 GXF 错误代码之一。

等待图执行完成#

gxf_result_t GxfGraphWait(gxf_context_t context);#
参数:

  • context – 有效的 GXF 上下文

返回值:

如果操作成功，则返回 GXF_SUCCESS；否则返回其中一个 GXF 错误代码。`

运行所有系统组件并等待它们完成#

gxf_result_t GxfGraphRun(gxf_context_t context);#
参数:

  • context – 有效的 GXF 上下文

返回值:

如果操作成功，则返回 GXF_SUCCESS，否则返回 GXF 错误代码之一。

实体#

type gxf_uid_t#

唯一 GXF 对象标识符 (UID/uid) 的类型。

Uid 用于在整个 GXF API 中引用实体和组件。

定义为 int64_t。

kNullUid#

一个 GXF UID，可用于指示无效或未使用的 GXF UID。

定义为 0L。

kUnspecifiedUid#

一个 GXF UID，可用于指示图加载操作期间未指定的组件。此组件应在后续的图/参数文件中更新。否则将在图激活期间导致错误。

定义为 -1L。

type gxf_tid_t#

唯一 GXF 类型标识符 (TID/tid) 的类型

Tid 用于唯一标识组件的类型，而不是例如使用带有类型名称的字符串。

uint64_t hash1#

哈希的第一部分。

uint64_t hash2#

哈希的第二部分。

kMaxEntities#

上下文中实体的最大数量。

定义为 1024。

enum gxf_entity_status_t#

表示实体的各种生命周期状态的枚举。

enumerator GXF_ENTITY_STATUS_NOT_STARTED#

实体尚未启动。

enumerator GXF_ENTITY_STATUS_START_PENDING#

实体启动挂起中。

enumerator GXF_ENTITY_STATUS_STARTED#

实体已启动。

enumerator GXF_ENTITY_STATUS_TICK_PENDING#

实体 Tick 挂起中。

enumerator GXF_ENTITY_STATUS_TICKING#

实体正在 Tick。

enumerator GXF_ENTITY_STATUS_IDLE#

实体处于空闲状态。

enumerator GXF_ENTITY_STATUS_STOP_PENDING#

实体停止挂起中。

enumerator GXF_ENTITY_MAX#

实体最大值

type GxfFlags#

GXF 位掩码。

定义为 uint32_t。

type GxfEntityCreateFlags#

GxfEntityCreateFlagBits 的位掩码。

type GxfEntityCreateFlagBits#

指定实体存储模式的位掩码。

type GXF_ENTITY_CREATE_PROGRAM_BIT#

指定实体将被添加到程序实体中。程序实体在程序运行期间保持活动状态。它们在程序激活时自动激活，并在程序停用时停用。如果程序在实体创建时已激活，则实体仍必须手动激活。

type GxfEntityCreateInfo#

一个结构体，用于指定创建实体的参数。

const char *entity_name#

要创建的实体的名称。如果这是一个 nullptr，则选择一个未定义的唯一名称。名称不得以双下划线开头。

GxfEntityCreateFlags flags#

GxfEntityCreateFlagsBits 的位掩码，指示已创建实体的存储方法和使用行为。

创建实体#

gxf_result_t GxfCreateEntity(
gxf_context_t context,
const GxfEntityCreateInfo *info,
gxf_uid_t *eid,
);#

创建一个新的 GXF 实体。

实体是轻量级容器，用于保存组件并构成 GXF 应用程序的基本构建块。实体在加载 GXF 文件时创建，或者可以使用此函数手动创建。使用此函数创建的实体必须使用 ‘GxfEntityDestroy’ 销毁。实体创建后，可以使用 ‘GxfComponentAdd’ 向其添加组件。要启动实体上代码小程序的执行，需要先激活实体。这可以使用 ‘GXF_ENTITY_CREATE_PROGRAM_BIT’ 自动完成，也可以使用 ‘GxfEntityActivate’ 手动完成。

参数:

  • context – 创建实体的 GXF 上下文。

  • info – 指向 GxfEntityCreateInfo 结构的指针，该结构包含影响实体创建的参数。

  • eid – 指向 gxf_uid_t 句柄的指针，结果实体将返回到该句柄中。

返回值:

如果操作成功，则返回 GXF_SUCCESS，否则返回 GXF 错误代码之一。

gxf_result_t GxfCreateEntityAndGetItem(
gxf_context_t context,
const GxfEntityCreateInfo *info,
gxf_uid_t *eid,
void **item_ptr,
);#

创建一个新的 GXF 实体并返回实体项指针

实体是轻量级容器，用于保存组件并构成 GXF 应用程序的基本构建块。实体在加载 GXF 文件时创建，或者可以使用此函数手动创建。使用此函数创建的实体必须使用 ‘GxfEntityDestroy’ 销毁。实体创建后，可以使用 ‘GxfComponentAdd’ 向其添加组件。要启动实体上代码小程序的执行，需要先激活实体。这可以使用 ‘GXF_ENTITY_CREATE_PROGRAM_BIT’ 自动完成，也可以使用 ‘GxfEntityActivate’ 手动完成。此函数还返回指针实体项，该项可用于创建 C++ nvidia::gxf::Entity 类型对象。

参数:

  • context – 是创建实体的 GXF 上下文。

  • info – 是指向 GxfEntityCreateInfo 结构的指针，该结构包含影响实体创建的参数。

  • eid – 是指向 gxf_uid_t 句柄的指针，结果实体将返回到该句柄中。

  • item_ptr – 是指向已创建的实体项的指针的指针

返回值:

成功时，该函数返回 GXF_SUCCESS。

激活实体#

gxf_result_t GxfEntityActivate(gxf_context_t context, gxf_uid_t eid);#

激活先前创建的且未激活的实体

激活实体通常标志着其生命周期的正式开始，并具有多重含义：- 如果未设置强制性参数，即不带 “optional” 标志的参数，则操作将失败。

  • 实体上的所有组件都已初始化。

  • 实体上的所有代码小程序都已安排执行。调度器将按照调度条款的规定开始调用 start、tick 和 stop 函数。

  • 激活后，尝试更改动态参数将导致失败。

  • 激活后，添加或删除实体的组件将导致失败。

参数:

  • context – 有效的 GXF 上下文

  • eid – 有效实体的 UID

返回值:

GXF 错误代码

停用实体#

gxf_result_t GxfEntityDeactivate(
gxf_context_t context,
gxf_uid_t eid,
);#

停用先前激活的实体

停用实体通常标志着其生命周期的正式结束，并具有多重含义

  • 所有代码小程序都将从计划中删除。已运行的实体将运行至完成。

  • 实体上的所有组件都已取消初始化。

  • 一旦实体被停用，可以再次添加或删除组件。

  • 可以再次更改强制性和非动态参数。

注意：如果实体当前正在执行，则此函数将等待并阻塞，直到

当前执行完成。

参数:

  • context – 有效的 GXF 上下文

  • eid – 有效实体的 UID

返回值:

GXF 错误代码

销毁实体#

gxf_result_t GxfEntityDestroy(gxf_context_t context, gxf_uid_t eid);#

销毁先前创建的实体

立即销毁实体。即使引用计数尚未达到 0，实体也会被销毁。如果实体处于活动状态，则首先停用它。

注意：此函数可能会因与 ‘GxfEntityDeactivate’ 相同的原因而阻塞。

参数:

  • context – 有效的 GXF 上下文

  • eid – 返回的已创建实体的 UID

返回值:

如果操作成功，则返回 GXF_SUCCESS，否则返回 GXF 错误代码之一。

查找实体#

gxf_result_t GxfEntityFind(
gxf_context_t context,
const char *name,
gxf_uid_t *eid,
);#

按名称查找实体

参数:

  • context – 有效的 GXF 上下文

  • name – 带有实体名称的 C 字符串。所有权不转移。

  • eid – 返回的实体的 UID

返回值:

如果操作成功，则返回 GXF_SUCCESS，否则返回 GXF 错误代码之一。

查找所有实体#

gxf_result_t GxfEntityFindAll(
gxf_context_t context,
uint64_t *num_entities,
gxf_uid_t *entities,
);#

查找当前应用程序中的所有实体

查找并返回当前应用程序的所有实体 ID。如果存在超过 max_entities 个实体，则仅返回 max_entities 个。返回的实体的顺序和选择是任意的。

参数:

  • context – 有效的 GXF 上下文

  • num_entities – 输入/输出：可以容纳在缓冲区中的最大实体数/应用程序中存在的实体数

  • entities – 调用者分配的缓冲区，用于返回所有实体的 UID，容量为 num_entities。

返回值:

如果操作成功，则返回 GXF_SUCCESS；如果应用程序中存在的实体多于 max_entities，则返回 GXF_QUERY_NOT_ENOUGH_CAPACITY；否则返回其中一个 GXF 错误代码。

增加实体的引用计数#

gxf_result_t GxfEntityRefCountInc(
gxf_context_t context,
gxf_uid_t eid,
);#

将实体的引用计数增加 1。

默认情况下，实体的引用计数被禁用。这意味着使用 ‘GxfEntityCreate’ 创建的实体不会自动销毁。如果为禁用引用计数的实体调用此函数，则启用引用计数并将引用计数设置为 1。一旦启用引用计数，如果引用计数达到零，或者显式调用 ‘GxfEntityCreate’，实体将自动销毁。

参数:

  • context – 有效的 GXF 上下文

  • eid – 有效实体的 UID

返回值:

如果操作成功，则返回 GXF_SUCCESS，否则返回 GXF 错误代码之一。

减少实体的引用计数#

gxf_result_t GxfEntityRefCountDec(
gxf_context_t context,
gxf_uid_t eid,
);#

将实体的引用计数减少 1。

有关引用计数的更多详细信息，请参阅 ‘GxfEntityRefCountInc’。

参数:

  • context – 有效的 GXF 上下文

  • eid – 有效实体的 UID

返回值:

如果操作成功，则返回 GXF_SUCCESS，否则返回 GXF 错误代码之一。

获取实体的引用计数#

gxf_result_t GxfEntityGetRefCount(
gxf_context_t context,
gxf_uid_t eid,
int64_t *count,
);#

提供实体的引用计数。

有关引用计数的更多详细信息，请参阅 ‘GxfEntityRefCountInc’。

参数:

  • context – 有效的 GXF 上下文

  • eid – 有效实体的唯一对象 ID (UID)

  • count – 有效实体的引用计数

返回值:

如果操作成功，则返回 GXF_SUCCESS，否则返回 GXF 错误代码之一。

获取实体的状态#

gxf_result_t GxfEntityGetStatus(
gxf_context_t context,
gxf_uid_t eid,
gxf_entity_status_t *entity_status,
);#

获取实体的状态。

有关各种状态，请参阅 ‘gxf_entity_status_t’。

参数:

  • context – 有效的 GXF 上下文

  • eid – 有效实体的 UID

  • entity_status – 输出；实体 eid 的状态

返回值:

如果操作成功，则返回 GXF_SUCCESS，否则返回 GXF 错误代码之一。

const char *GxfEntityStatusStr(gxf_entity_status_t status);#

获取描述 GXF 实体状态的字符串。

调用者不拥有返回的 C 字符串的所有权，并且不得删除它。

参数:

  • status – 一个 GXF 实体状态

返回值:

指向带有实体状态描述的 C 字符串的指针。

获取实体的名称#

gxf_result_t GxfEntityGetName(
gxf_context_t context,
gxf_uid_t eid,
const char **entity_name,
);#
参数:

  • context – 有效的 GXF 上下文

  • eid – 有效实体的唯一对象 ID (UID)

  • entity_name – 输出；实体的名称

返回值:

如果操作成功，则返回 GXF_SUCCESS，否则返回 GXF 错误代码之一。

获取实体的状态#

enum entity_state_t#

行为树中行为父代码小程序使用的枚举，表示 codelet::tick() 的结果。

enumerator GXF_BEHAVIOR_INIT#

对于尚未开始运行的代码小程序。

enumerator GXF_BEHAVIOR_SUCCESS#

对于在 Tick 后成功终止的代码小程序。

enumerator GXF_BEHAVIOR_RUNNING#

对于需要多次 Tick 才能完成的代码小程序。

enumerator GXF_BEHAVIOR_FAILURE#

对于在 Tick 后以失败终止的代码小程序。

enumerator GXF_BEHAVIOR_UNKNOWN#

对于非行为树代码小程序，因为我们不关心控制器返回的行为状态（如果它不是 BT 代码小程序）。

gxf_result_t GxfEntityGetState(
gxf_context_t context,
gxf_uid_t eid,
entity_state_t *entity_state,
);#

获取实体的状态。

有关各种状态，请参阅 ‘gxf_entity_status_t’。

参数:

  • context – 有效的 GXF 上下文

  • eid – 有效实体的 UID

  • entity_state – 输出；行为树父代码小程序使用的实体 eid 的行为状态

返回值:

如果操作成功，则返回 GXF_SUCCESS，否则返回 GXF 错误代码之一。

通知实体发生事件#

gxf_result_t GxfEntityEventNotify(
gxf_context_t context,
gxf_uid_t eid,
);#

通知事件的发生并通知调度器检查实体的状态

实体必须具有 ‘AsynchronousSchedulingTerm’ 调度项组件，并且必须处于 “EVENT_WAITING” 状态才能确认通知。

有关各种状态，请参阅 ‘AsynchronousEventState’

参数:

  • context – 有效的 GXF 上下文

  • eid – 有效实体的 UID

返回值:

如果操作成功，则返回 GXF_SUCCESS，否则返回 GXF 错误代码之一。

通知实体发生事件，包括事件类型#

enum gxf_event_t#

用于与 GXF 调度器通信的各种事件类型的枚举。

所有 GXF 调度器都支持 GXF_EVENT_EXTERNAL，而基于事件的调度器仅支持其余事件类型。GXF_EVENT_EXTERNAL 通常旨在由 GXF 框架外部的事件（由非 GXF 拥有的线程）使用。所有其他事件类型都发生在 GXF 内部，并且每个事件类型都描述了特定的事件触发场景

enumerator GXF_EVENT_CUSTOM#
enumerator GXF_EVENT_EXTERNAL#
enumerator GXF_EVENT_MEMORY_FREE#
enumerator GXF_EVENT_MESSAGE_SYNC#
enumerator GXF_EVENT_TIME_UPDATE#
enumerator GXF_EVENT_STATE_UPDATE#
gxf_result_t GxfEntityNotifyEventType(
gxf_context_t context,
gxf_uid_t eid,
gxf_event_t event,
);#

通知事件类型事件的发生，并通知调度器检查实体的状态

所有 GXF 调度器都支持 GXF_EVENT_EXTERNAL，而其余事件类型仅由基于事件的调度器支持。

参数:

  • context – 有效的 GXF 上下文

  • eid – 有效实体的 UID

  • event – 事件的类型。可以是 GXF_EVENT_CUSTOM、GXF_EVENT_EXTERNAL、GXF_EVENT_MEMORY_FREE、GXF_EVENT_MESSAGE_SYNC、GXF_EVENT_TIME_UPDATE、GXF_EVENT_STATE_UPDATE。

返回值:

如果操作成功，则返回 GXF_SUCCESS，否则返回 GXF 错误代码之一。

const char *GxfEventStr(gxf_event_t event);#

获取描述 GXF 事件类型的字符串。

调用者不拥有返回的 C 字符串的所有权，并且不得删除它。

参数:

  • result – GXF 错误代码

返回值:

指向包含错误代码描述的 C 字符串的指针。

检查实体是否有效#

gxf_result_t GxfEntityIsValid(
gxf_context_t context,
gxf_uid_t eid,
bool *valid,
);#

检查实体 ID 当前在 GXF 运行时中是否有效。

参数:

  • context – 有效的 GXF 上下文

  • eid – 要检查的实体的 eid

  • valid – 返回的布尔值，指示实体在 Gxf 运行时 (warden) 中是否有效

返回值:

如果操作成功，则返回 GXF_SUCCESS，否则返回 GXF 错误代码之一。

组件#

kMaxComponents#

实体或扩展中的最大组件数。

定义为 1024。

kMaxEntityNameSize#

实体名称中的最大字符数。

定义为 2048。

kMaxComponentNameSize#

组件名称中的最大字符数。

定义为 256。

获取组件类型标识符#

gxf_result_t GxfComponentTypeId(
gxf_context_t context,
const char *name,
gxf_tid_t *tid,
);#

获取组件的 GXF 唯一类型 ID (TID)

获取用于在 GXF 中注册组件的唯一类型 ID。该函数需要组件的完全限定 C++ 类型名称，包括命名空间。

有效组件类型名称的示例：“nvidia::gxf::test::PingTx”

参数:

  • context – 有效的 GXF 上下文

  • name – 组件的完全限定 C++ 类型名称

  • tid – 返回的组件 TID

返回值:

如果操作成功，则返回 GXF_SUCCESS，否则返回 GXF 错误代码之一。

获取组件类型名称#

gxf_result_t GxfComponentTypeName(
gxf_context_t context,
gxf_tid_t tid,
const char **name,
);#

获取完全限定的 C++ 类型名称 GXF 组件类型名称

获取组件的唯一类型名称，该名称使用 GXF_EXT_FACTORY_ADD*() 宏之一注册

参数:

  • context – 有效的 GXF 上下文

  • tid – 组件的唯一类型 ID (TID)，组件使用该 ID 注册

  • name – 返回的组件名称

返回值:

如果操作成功，则返回 GXF_SUCCESS，否则返回 GXF 错误代码之一。

从组件 UID 获取组件类型名称#

gxf_result_t GxfComponentTypeNameFromUID(
gxf_context_t context,
gxf_uid_t cid,
const char **name,
);#

从组件 UID 获取完全限定的 C++ 类型名称 GXF 组件类型名称

获取组件的唯一类型名称，该名称使用 GXF_EXT_FACTORY_ADD*() 宏之一注册

参数:

  • context – 有效的 GXF 上下文

  • cid – 有效组件的 UID

  • name – 返回的组件名称

返回值:

如果操作成功，则返回 GXF_SUCCESS，否则返回 GXF 错误代码之一。

获取组件名称#

gxf_result_t GxfComponentName(
gxf_context_t context,
gxf_uid_t cid,
const char **name,
);#

获取组件的名称

每个组件都有一个用户定义的名称，该名称在调用 ‘GxfComponentAdd’ 时使用。通常，该名称在 GXF 应用程序文件中指定。

参数:

  • context – 有效的 GXF 上下文

  • cid – 组件的唯一对象 ID (UID)

  • name – 返回的组件名称

返回值:

如果操作成功，则返回 GXF_SUCCESS，否则返回 GXF 错误代码之一。

获取给定组件的实体的唯一标识符#

gxf_result_t GxfComponentEntity(
gxf_context_t context,
gxf_uid_t cid,
gxf_uid_t *eid,
);#

获取组件实体的唯一对象 ID

每个组件都有一个相对于上下文的唯一 ID，并存储在一个实体中。此函数可用于检索给定组件所属实体的 ID。

参数:

  • context – 有效的 GXF 上下文

  • cid – 组件的唯一对象 ID (UID)

  • eid – 返回的实体的 UID

返回值:

如果操作成功，则返回 GXF_SUCCESS，否则返回 GXF 错误代码之一。

获取指向实体项的指针#

gxf_result_t GxfEntityGetItemPtr(
gxf_context_t context,
gxf_uid_t eid,
void **ptr,
);#

每个实体都有一个相对于上下文的唯一 ID，并存储在实体 warden 中。此函数可用于检索指向存储在实体 warden 中给定实体 ID 的实体项的指针。

参数:

  • context – 有效的 GXF 上下文

  • eid – 实体的唯一对象 ID (UID)

  • ptr – 返回的指向实体项的指针

返回值:

如果操作成功，则返回 GXF_SUCCESS，否则返回 GXF 错误代码之一。

添加新组件#

gxf_result_t GxfComponentAdd(
gxf_context_t context,
gxf_uid_t eid,
gxf_tid_t tid,
const char *name,
gxf_uid_t *cid,
);#

向实体添加新组件

一个实体可以包含多个组件，此函数可用于向实体添加新组件。必须在实体激活之前或停用之后添加组件。不得向活动实体添加组件。组件的顺序是稳定的，并且与添加组件的顺序相同（请参阅 ‘GxfComponentFind’）。

参数:

  • context – 有效的 GXF 上下文

  • eid – 要向其添加组件的实体的唯一对象 ID (UID)。

  • tid – 要添加到实体的组件的唯一类型 ID (TID)。

  • name – 新组件的名称。所有权不转移。

  • cid – 返回的已创建组件的 UID

返回值:

如果操作成功，则返回 GXF_SUCCESS，否则返回 GXF 错误代码之一。

向实体添加新组件并返回指向该组件的指针#

gxf_result_t GxfComponentAddAndGetPtr(
gxf_context_t context,
void *item_ptr,
gxf_tid_t tid,
const char *name,
gxf_uid_t *cid,
void **comp_ptr,
);#

一个实体可以包含多个组件，此函数可用于向实体添加新组件。必须在实体激活之前或停用之后添加组件。不得向活动实体添加组件。组件的顺序是稳定的，并且与添加组件的顺序相同（请参阅 ‘GxfComponentFind’）。

参数:

  • context – 有效的 GXF 上下文

  • item_ptr – 指向实体项的指针

  • tid – 要添加到实体的组件的唯一类型 ID (TID)。

  • name – 新组件的名称。所有权不转移。

  • cid – 返回的已创建组件的 UID

  • comp_ptr – 返回的指向已创建组件对象的指针

返回值:

如果操作成功，则返回 GXF_SUCCESS，否则返回 GXF 错误代码之一。

移除组件#

gxf_result_t GxfComponentRemoveWithUID(
gxf_context_t context,
gxf_uid_t cid,
);#

从实体中移除组件

一个实体可以包含多个组件，此函数可用于从实体中移除组件。必须在实体激活之前或停用之后移除组件。不得从活动实体中移除组件。

参数:

  • context – 有效的 GXF 上下文

  • cid – 组件的 UID

返回值:

如果操作成功，则返回 GXF_SUCCESS，否则返回 GXF 错误代码之一。

gxf_result_t GxfComponentRemove(
gxf_context_t context,
gxf_uid_t eid,
gxf_tid_t tid,
const char *name,
);#

从实体中移除组件

一个实体可以包含多个组件，此函数可用于从实体中移除组件。必须在实体激活之前或停用之后移除组件。不得从活动实体中移除组件。

参数:

  • context – 有效的 GXF 上下文

  • eid – 要向其添加组件的实体的唯一对象 ID (UID)。

  • tid – 要添加到实体的组件的唯一类型 ID (TID)。

  • name – 新组件的名称。所有权不转移。

返回值:

如果操作成功，则返回 GXF_SUCCESS，否则返回 GXF 错误代码之一。

向实体接口添加组件#

gxf_result_t GxfComponentAddToInterface(
gxf_context_t context,
gxf_uid_t eid,
gxf_uid_t cid,
const char *name,
);#

将现有组件添加到实体的接口

实体可以在其接口中保存对其他组件的引用，以便在实体中查找组件时，将返回此实体保存的组件及其引用的组件。这支持实体包含子图的情况，然后子图接口中声明的那些组件将放入父实体的接口中。

参数:

  • context – 有效的 GXF 上下文

  • eid – 要向其添加组件的实体的唯一对象 ID (UID)。

  • cid – 组件的唯一对象 ID。

  • name – 新组件的名称。所有权不转移。

返回值:

如果操作成功，则返回 GXF_SUCCESS，否则返回 GXF 错误代码之一。

在实体中查找组件#

gxf_result_t GxfComponentFind(
gxf_context_t context,
gxf_uid_t eid,
gxf_tid_t tid,
const char *name,
int32_t *offset,
gxf_uid_t *cid,
);#

在实体中查找组件

在实体中搜索满足特定条件的组件：组件类型、组件名称和组件最小索引。所有三个条件都是可选的；如果未给出任何条件，则返回第一个组件。“组件最小索引”的主要用例是重复搜索，该搜索在上一次搜索返回的索引处继续。

如果未找到具有给定条件的实体，则返回 GXF_ENTITY_NOT_FOUND。

参数:

  • context – 有效的 GXF 上下文

  • eid – 要搜索的实体的唯一对象 ID (UID)。

  • tid – 要查找的组件的组件类型 ID (TID)（可选）

  • name – 要查找的组件的组件名称（可选）。所有权不转移。

  • offset – 实体中要搜索的第一个组件的索引。还包含找到的组件的索引。

  • cid – 返回的已搜索组件的 UID

返回值:

如果找到与条件匹配的组件，则为 GXF_SUCCESS；如果未找到与条件匹配的组件，则为 GXF_ENTITY_NOT_FOUND；否则为 GXF 错误代码之一。

在实体中查找组件并返回指向组件的指针#

gxf_result_t GxfComponentFindAndGetPtr(
gxf_context_t context,
gxf_uid_t eid,
void *item_ptr,
gxf_tid_t tid,
const char *name,
int32_t *offset,
gxf_uid_t *cid,
void **ptr,
);#

在实体中搜索满足特定条件的组件：组件类型、组件名称。所有两个条件都是可选的；如果未给出任何条件，则返回第一个组件。“组件最小索引”的主要用例是重复搜索，该搜索在上一次搜索返回的索引处继续。

如果未找到具有给定条件的实体，则返回 GXF_ENTITY_NOT_FOUND。

参数:

  • context – 有效的 GXF 上下文

  • eid – 要搜索的实体的唯一对象 ID (UID)。

  • item_ptr – 指向实体项的指针

  • tid – 要查找的组件的组件类型 ID (TID)（可选）

  • name – 要查找的组件的组件名称（可选）。所有权不转移。

  • offset – 实体中要搜索的第一个组件的索引。还包含找到的组件的索引。

  • cid – 返回的已搜索组件的 UID

  • ptr – 返回的已搜索组件的指针

返回值:

如果找到与条件匹配的组件，则为 GXF_SUCCESS；如果未找到与条件匹配的组件，则为 GXF_ENTITY_NOT_FOUND；否则为 GXF 错误代码之一。

查找实体中的所有组件#

gxf_result_t GxfComponentFindAll(
gxf_context_t context,
gxf_uid_t eid,
uint64_t *num_cids,
gxf_uid_t *cids,
);#

查找实体中的所有组件

查找并返回给定实体的所有组件 ID。如果存在超过 num_cids 个组件，则将返回 GXF_QUERY_NOT_ENOUGH_CAPACITY，并且 num_cids 将更新为实体中组件的实际数量。

参数:

  • context – 有效的 GXF 上下文

  • eid – 要搜索的实体的唯一对象 ID (UID)。

  • num_cids – 输入/输出：可以容纳在缓冲区中的最大组件数/实体中存在的组件数

  • cids – 调用者分配的缓冲区，用于返回所有组件的 UID，容量为 num_cids。

返回值:

如果操作成功，则为 GXF_SUCCESS；如果实体中存在的组件多于 num_cids，则为 GXF_QUERY_NOT_ENOUGH_CAPACITY；否则为 GXF 错误代码之一。

获取组件的类型标识符#

gxf_result_t GxfComponentType(
gxf_context_t context,
gxf_uid_t cid,
gxf_tid_t *tid,
);#

获取组件的组件类型 ID (TID)

参数:

  • context – 有效的 GXF 上下文

  • cid – 请求组件类型的组件对象 ID (UID)。

  • tid – 返回的组件 TID

返回值:

如果操作成功，则返回 GXF_SUCCESS，否则返回 GXF 错误代码之一。

获取指向组件的指针#

gxf_result_t GxfComponentPointer(
gxf_context_t context,
gxf_uid_t uid,
gxf_tid_t tid,
void **pointer,
);#

验证组件是否存在、是否具有给定类型，并获取指向它的指针。

参数:

  • context – 有效的 GXF 上下文

  • uid – 组件对象 ID (UID)。

  • tid – 组件的预期组件类型 ID (TID)

  • pointer – 返回的指向组件对象的指针。

返回值:

如果操作成功，则返回 GXF_SUCCESS，否则返回 GXF 错误代码之一。

检查组件是否派生自另一个组件#

gxf_result_t GxfComponentIsBase(
gxf_context_t context,
gxf_tid_t derived,
gxf_tid_t base,
bool *result,
);#

检查扩展中注册的类型是否派生自同一扩展或任何其他扩展中的另一个注册类型。

这对于使用组件的类型 ID 查询组件层次结构非常有用。派生类型和基类型都必须通过 GXF_EXT_FACTORY_ADD* 宏之一在扩展中注册。

参数:

  • context – 有效的 GXF 上下文

  • derived – 派生类型的类型 ID (TID)

  • base – 基类型的类型 ID (TID)

返回值:

如果操作成功，则返回 GXF_SUCCESS，否则返回 GXF 错误代码之一。

参数#

kMaxParameters#

组件中参数的最大数量。

定义为 1024。

enum gxf_parameter_flags_t_#

描述参数行为的标志。参数标志在注册参数作为组件接口的一部分时指定。多个标志可以进行 OR 组合。

enumerator GXF_PARAMETER_FLAGS_NONE#

未设置其他标志（默认值）。这意味着参数是强制性的和静态的。参数必须在实体激活之前设置，并且在实体激活之后不能更改。

enumerator GXF_PARAMETER_FLAGS_OPTIONAL#

参数值是可选的，并且在实体激活后可能不可用。这意味着不允许在 C++ API 中使用 ‘get()’ 访问参数。必须使用 ‘try_get’ 代替。

enumerator GXF_PARAMETER_FLAGS_DYNAMIC#

参数是动态的，并且可能在实体激活后更改。但是，仍然保证参数在 initialize、deinitialize、start、tick 或 stop 函数期间不会更改。

type gxf_parameter_flags_t#

typedef uint32_t gxf_parameter_flags_t

用于参数标志的类型。请参阅 gxf_parameter_flags_t_。

64 位浮点数#

设置#

gxf_result_t GxfParameterSetFloat64(
gxf_context_t context,
gxf_uid_t uid,
const char *key,
double value,
);#
参数:

  • context – 有效的 GXF 上下文。

  • uid – 有效的组件标识符。

  • key – 要设置的组件的有效名称。

  • value – 双精度值

返回值:

如果操作成功，则返回 GXF_SUCCESS，否则返回 GXF 错误代码之一。

获取#

gxf_result_t GxfParameterGetFloat64(
gxf_context_t context,
gxf_uid_t uid,
const char *key,
double *value,
);#
参数:

  • context – 有效的 GXF 上下文。

  • uid – 有效的组件标识符。

  • key – 要设置的组件的有效名称。

  • value – 指向获取双精度值的指针。

返回值:

如果操作成功，则返回 GXF_SUCCESS，否则返回 GXF 错误代码之一。

64 位有符号整数#

设置#

gxf_result_t GxfParameterSetInt64(
gxf_context_t context,
gxf_uid_t uid,
const char *key,
int64_t value,
);#
参数:

  • context – 有效的 GXF 上下文。

  • uid – 有效的组件标识符。

  • key – 要设置的组件的有效名称。

  • value – 要设置的 64 位整数值。

返回值:

如果操作成功，则返回 GXF_SUCCESS，否则返回 GXF 错误代码之一。

获取#

gxf_result_t GxfParameterGetInt64(
gxf_context_t context,
gxf_uid_t uid,
const char *key,
int64_t *value,
);#
参数:

  • context – 有效的 GXF 上下文。

  • uid – 有效的组件标识符。

  • key – 要设置的组件的有效名称。

  • value – 指向获取 64 位整数值的指针。

返回值:

如果操作成功，则返回 GXF_SUCCESS，否则返回 GXF 错误代码之一。

64 位无符号整数#

设置#

gxf_result_t GxfParameterSetUInt64(
gxf_context_t context,
gxf_uid_t uid,
const char *key,
uint64_t value,
);#
参数:

  • context – 有效的 GXF 上下文。

  • uid – 有效的组件标识符。

  • key – 要设置的组件的有效名称。

  • value – 要设置的无符号 64 位整数值。

返回值:

如果操作成功，则返回 GXF_SUCCESS，否则返回 GXF 错误代码之一。

获取#

gxf_result_t GxfParameterGetUInt64(
gxf_context_t context,
gxf_uid_t uid,
const char *key,
uint64_t *value,
);#
参数:

  • context – 有效的 GXF 上下文。

  • uid – 有效的组件标识符。

  • key – 要设置的组件的有效名称。

  • value – 指向获取无符号 64 位整数值的指针。

返回值:

如果操作成功，则返回 GXF_SUCCESS，否则返回 GXF 错误代码之一。

32 位有符号整数#

设置#

gxf_result_t GxfParameterSetInt32(
gxf_context_t context,
gxf_uid_t uid,
const char *key,
int32_t value,
);#
参数:

  • context – 有效的 GXF 上下文。

  • uid – 有效的组件标识符。

  • key – 要设置的组件的有效名称。

  • value – 要设置的 32 位整数值。

返回值:

如果操作成功，则返回 GXF_SUCCESS，否则返回 GXF 错误代码之一。

获取#

gxf_result_t GxfParameterGetInt32(
gxf_context_t context,
gxf_uid_t uid,
const char *key,
int32_t *value,
);#
参数:

  • context – 有效的 GXF 上下文。

  • uid – 有效的组件标识符。

  • key – 要设置的组件的有效名称。

  • value – 指向获取 32 位整数值的指针。

返回值:

如果操作成功，则返回 GXF_SUCCESS，否则返回 GXF 错误代码之一。

32 位无符号整数#

设置#

gxf_result_t GxfParameterSetUInt32(
gxf_context_t context,
gxf_uid_t uid,
const char *key,
uint32_t value,
);#
参数:

  • context – 有效的 GXF 上下文。

  • uid – 有效的组件标识符。

  • key – 要设置的组件的有效名称。

  • value – 要设置的 32 位无符号整数值。

返回值:

如果操作成功，则返回 GXF_SUCCESS，否则返回 GXF 错误代码之一。

获取#

gxf_result_t GxfParameterGetUInt32(
gxf_context_t context,
gxf_uid_t uid,
const char *key,
uint32_t *value,
);#
参数:

  • context – 有效的 GXF 上下文。

  • uid – 有效的组件标识符。

  • key – 要设置的组件的有效名称。

  • value – 指向获取 32 位无符号整数值的指针。

返回值:

如果操作成功，则返回 GXF_SUCCESS，否则返回 GXF 错误代码之一。

16 位无符号整数#

设置#

gxf_result_t GxfParameterSetUInt16(
gxf_context_t context,
gxf_uid_t uid,
const char *key,
uint16_t value,
);#
参数:

  • context – 有效的 GXF 上下文。

  • uid – 有效的组件标识符。

  • key – 要设置的组件的有效名称。

  • value – 要设置的 16 位无符号整数值。

返回值:

如果操作成功，则返回 GXF_SUCCESS，否则返回 GXF 错误代码之一。

获取#

gxf_result_t GxfParameterGetUInt16(
gxf_context_t context,
gxf_uid_t uid,
const char *key,
uint16_t *value,
);#
参数:

  • context – 有效的 GXF 上下文。

  • uid – 有效的组件标识符。

  • key – 要设置的组件的有效名称。

  • value – 指向获取 16 位无符号整数值的指针。

返回值:

如果操作成功，则返回 GXF_SUCCESS，否则返回 GXF 错误代码之一。

16 位有符号整数#

设置#

gxf_result_t GxfParameterSetInt16(
gxf_context_t context,
gxf_uid_t uid,
const char *key,
int16_t value,
);#
参数:

  • context – 有效的 GXF 上下文。

  • uid – 有效的组件标识符。

  • key – 要设置的组件的有效名称。

  • value – 要设置的 16 位有符号整数值。

返回值:

如果操作成功，则返回 GXF_SUCCESS，否则返回 GXF 错误代码之一。

8 位无符号整数#

设置#

gxf_result_t GxfParameterSetUInt8(
gxf_context_t context,
gxf_uid_t uid,
const char *key,
uint8_t value,
);#
参数:

  • context – 有效的 GXF 上下文。

  • uid – 有效的组件标识符。

  • key – 要设置的组件的有效名称。

  • value – 要设置的 8 位无符号整数值。

返回值:

如果操作成功，则返回 GXF_SUCCESS，否则返回 GXF 错误代码之一。

8 位有符号整数#

设置#

gxf_result_t GxfParameterSetInt8(
gxf_context_t context,
gxf_uid_t uid,
const char *key,
int8_t value,
);#
参数:

  • context – 有效的 GXF 上下文。

  • uid – 有效的组件标识符。

  • key – 要设置的组件的有效名称。

  • value – 要设置的 8 位有符号整数值。

返回值:

如果操作成功，则返回 GXF_SUCCESS，否则返回 GXF 错误代码之一。

字符串参数#

设置#

gxf_result_t GxfParameterSetStr(
gxf_context_t context,
gxf_uid_t uid,
const char *key,
const char *value,
);#
参数:

  • context – 有效的 GXF 上下文。

  • uid – 有效的组件标识符。

  • key – 要设置的组件的有效名称。

  • value – 包含要设置的值的字符数组。

返回值:

如果操作成功，则返回 GXF_SUCCESS，否则返回 GXF 错误代码之一。

获取#

gxf_result_t GxfParameterGetStr(
gxf_context_t context,
gxf_uid_t uid,
const char *key,
const char **value,
);#
参数:

  • context – 有效的 GXF 上下文。

  • uid – 有效的组件标识符。

  • key – 要设置的组件的有效名称。

  • value – 指向 char* 数组的指针，用于获取值。

返回值:

如果操作成功，则返回 GXF_SUCCESS，否则返回 GXF 错误代码之一。

布尔值#

设置#

gxf_result_t GxfParameterSetBool(
gxf_context_t context,
gxf_uid_t uid,
const char *key,
bool value,
);#
参数:

  • context – 有效的 GXF 上下文。

  • uid – 有效的组件标识符。

  • key – 要设置的组件的有效名称。

  • value – 要设置的布尔值。

返回值:

如果操作成功，则返回 GXF_SUCCESS，否则返回 GXF 错误代码之一。

获取#

gxf_result_t GxfParameterGetBool(
gxf_context_t context,
gxf_uid_t uid,
const char *key,
bool *value,
);#
参数:

  • context – 有效的 GXF 上下文。

  • uid – 有效的组件标识符。

  • key – 要设置的组件的有效名称。

  • value – 指针，用于获取布尔值。

返回值:

如果操作成功，则返回 GXF_SUCCESS，否则返回 GXF 错误代码之一。

句柄#

设置#

gxf_result_t GxfParameterSetHandle(
gxf_context_t context,
gxf_uid_t uid,
const char *key,
gxf_uid_t cid,
);#
参数:

  • context – 有效的 GXF 上下文。

  • uid – 有效的组件标识符。

  • key – 要设置的组件的有效名称。

  • cid – 要设置的唯一标识符。

返回值:

如果操作成功，则返回 GXF_SUCCESS，否则返回 GXF 错误代码之一。

获取#

gxf_result_t GxfParameterGetHandle(
gxf_context_t context,
gxf_uid_t uid,
const char *key,
gxf_uid_t *cid,
);#
参数:

  • context – 有效的 GXF 上下文。

  • uid – 有效的组件标识符。

  • key – 要设置的组件的有效名称。

  • value – 指向唯一标识符的指针，用于获取值。

返回值:

如果操作成功，则返回 GXF_SUCCESS，否则返回 GXF 错误代码之一。

向量参数#

要设置/获取组件的向量参数，用户可以使用以下 C-API，适用于各种数据类型

设置 1-D 向量参数#

gxf_result_t GxfParameterSet1DDataTypeVector(
gxf_context_t context,
gxf_uid_t uid,
const char *key,
data_type *value,
uint64_t length,
);#

value 应该指向要设置的相应类型数据的数组。存储数组的大小应与传递的 length 参数匹配。

请参阅下表，了解所有支持的数据类型及其对应的函数签名。

参数:

  • key – 参数的名称

  • value – 参数要设置的值

  • length – 向量参数的长度

返回值:

如果操作成功，则返回 GXF_SUCCESS，否则返回 GXF 错误代码之一。

支持设置 1D 向量参数的数据类型#

函数名称

data_type

GxfParameterSet1DFloat64Vector(...)

double

GxfParameterSet1DInt64Vector(...)

int64_t

GxfParameterSet1DUInt64Vector(...)

uint64_t

GxfParameterSet1DInt32Vector(...)

int32_t

设置 2-D 向量参数#

gxf_result_t GxfParameterSet2DDataTypeVector(
gxf_context_t context,
gxf_uid_t uid,
const char *key,
data_type **value,
uint64_t height,
uint64_t width,
);#

value 应该指向相应类型数据的数组的数组（而不是指向数据连续数组的地址）。数组第一维的长度应与传递的 height 参数匹配，类似地，数组第二维的长度应与传递的 width 匹配。

请参阅下表，了解所有支持的数据类型及其对应的函数签名。

参数:

  • key – 参数的名称

  • value – 参数要设置的值

  • height – 2-D 向量参数的高度

  • width – 2-D 向量参数的宽度

返回值:

如果操作成功，则返回 GXF_SUCCESS，否则返回 GXF 错误代码之一。

支持设置 2D 向量参数的数据类型#

函数名称

data_type

GxfParameterSet2DFloat64Vector(...)

double

GxfParameterSet2DInt64Vector(...)

int64_t

GxfParameterSet2DUInt64Vector(...)

uint64_t

GxfParameterSet2DInt32Vector(...)

int32_t

获取 1-D 向量参数#

使用 gxf_result_t GxfParameterGet1D"DataType"Vector(gxf_context_t context, gxf_uid_t uid, const char* key, data_type** value, uint64_t* length) 获取 1-D 向量的值。

在调用此方法之前，请使用 GxfParameterGet1D"DataType"VectorInfo(gxf_context_t context, gxf_uid_t uid, const char* key, uint64_t* length) 获取向量参数的 length，然后分配至少那么多内存来检索 value。

value 应该指向用户分配的、大小大于或等于 length 的相应类型的数组，以检索数据。如果 length 与存储向量的大小不匹配，则它将更新为预期的大小。

请参阅下表，了解所有支持的数据类型及其对应的函数签名。

param key:

参数的名称

param value:

参数要设置的值

param length:

通过调用 GxfParameterGet1D"DataType"VectorInfo(...) 获取的 1-D 向量参数的长度

支持获取 1D 向量参数值的数据类型#

函数名称

data_type

GxfParameterGet1DFloat64Vector(...)

double

GxfParameterGet1DInt64Vector(...)

int64_t

GxfParameterGet1DUInt64Vector(...)

uint64_t

GxfParameterGet1DInt32Vector(...)

int32_t

获取 2-D 向量参数#

使用 gxf_result_t GxfParameterGet2D"DataType"Vector(gxf_context_t context, gxf_uid_t uid, const char* key, data_type** value, uint64_t* height, uint64_t* width) 获取 -2D 向量的值。

在调用此方法之前，用户应调用 GxfParameterGet1D"DataType"VectorInfo(gxf_context_t context, gxf_uid_t uid, const char* key, uint64_t* height, uint64_t* width) 以获取 2D 向量参数的 height 和 width，然后分配至少那么多内存来检索 value。

value 应该指向用户分配的、高度（第一维的大小）大于或等于 height 且宽度（第二维的大小）大于或等于 width 的数组的数组，以获取数据。如果 height 或 width 与存储向量的高度和宽度不匹配，则它们将更新为预期值。

请参阅下表，了解所有支持的数据类型及其对应的函数签名。

parameter”: key 参数的名称

parameter”: value 用于获取参数值的已分配数组

parameter”: height 通过调用 GxfParameterGet2D"DataType"VectorInfo(...) 获取的 2-D 向量参数的高度

parameter”: width 通过调用 GxfParameterGet2D"DataType"VectorInfo(...) 获取的 2-D 向量参数的宽度

支持获取 2D 向量参数值的数据类型#

函数名称

data_type

GxfParameterGet2DFloat64Vector(...)

double

GxfParameterGet2DInt64Vector(...)

int64_t

GxfParameterGet2DUInt64Vector(...)

uint64_t

GxfParameterGet2DInt32Vector(...)

int32_t

YAML 参数#

从 YAML 设置参数#

gxf_result_t GxfParameterSetFromYamlNode(
gxf_context_t context,
gxf_uid_t uid,
const char *key,
void *yaml_node,
const char *prefix,
);#

从 YAML 设置参数。YAML 节点指针应为 ‘YAML::Node*’ 类型。

参数:

  • context – 有效的 GXF 上下文。

  • uid – 有效的组件标识符。

  • key – 要设置的组件的有效名称。

  • yaml_node – yaml 节点指针

  • prefix – 前缀

返回值:

如果操作成功，则返回 GXF_SUCCESS，否则返回 GXF 错误代码之一。

文件参数#

设置 FilePath 参数#

gxf_result_t GxfParameterSetPath(
gxf_context_t context,
gxf_uid_t uid,
const char *key,
const char *value,
);#

设置 FilePath 参数。

参数:

  • context – 有效的 GXF 上下文。

  • uid – 有效的组件标识符。

  • key – 要设置的组件的有效名称。

  • value – 文件路径

返回值:

如果操作成功，则返回 GXF_SUCCESS，否则返回 GXF 错误代码之一。

实体组#

kDefaultEntityGroupName#

kDefaultEntityGroupName#

默认实体组的名称。

定义为 “default_entity_group”。

创建实体组#

gxf_result_t GxfCreateEntityGroup(
gxf_context_t context,
const char *name,
gxf_uid_t *gid,
);#

创建一个新的 GXF EntityGroup。

EntityGroup 是 EntityItem 的组，因此这些实体绑定到某些共同的属性。目前，共同的属性是各种资源。

参数:

  • context – 有效的 GXF 上下文

  • name – 用于创建 EntityGroup 的名称

  • gid – 指向为创建的 EntityGroup 返回的 uid 的指针，group id 的缩写

返回值:

如果操作成功，则返回 GXF_SUCCESS，否则返回 GXF 错误代码之一。

更新实体的 EntityGroup#

gxf_result_t GxfUpdateEntityGroup(
gxf_context_t context,
gxf_uid_t gid,
gxf_uid_t eid,
);#

通过将实体 eid 添加到目标 EntityGroup 来更新实体的 EntityGroup；并从之前的 EntityGroup 中删除实体 eid。

每个实体始终只有一个 EntityGroup。实体持有实体组 gid，而 EntityGroup 持有一组具有此实体 eid 的实体 eid。每个实体都使用默认的 EntityGroup 创建。当更新实体的 EntityGroup 时：1. 更新当前 EntityItem 中的 EntityGroup uid 为新的组 id gid；2. 从其之前的 EntityGroup 中删除 eid；3. 将 eid 添加到其新的 EntityGroup

参数:

  • context – 有效的 GXF 上下文

  • gid – 现有（新的）EntityGroup 的 UID

  • eid – Entity 的 eid

返回值:

如果操作成功，则返回 GXF_SUCCESS，否则返回 GXF 错误代码之一。

从 EntityGroup 中查找所有资源#

gxf_result_t GxfEntityGroupFindResources(
gxf_context_t context,
gxf_uid_t eid,
uint64_t *num_resource_cids,
gxf_uid_t *resource_cids,
);#

从 EntityGroup 中查找所有资源

查找并返回 eid 指向的 EntityGroup 的所有资源组件 cid。如果存在超过 max_entities，则仅返回 max_entities。

参数:

  • context – 有效的 GXF 上下文

  • eid – Entity 的 eid

  • num_resource_cids – 输入/输出：可以容纳在缓冲区中的最大组件数/eid 的 EntityGroup 中的资源数

  • resource_cids – 调用者为返回的所有资源的 UID 分配的缓冲区，容量为 num_resource_cids。

返回值:

如果操作成功，则为 GXF_SUCCESS；如果 eid 的 EntityGroup 中存在更多资源，则为 GXF_QUERY_NOT_ENOUGH_CAPACITY；否则为 GXF 错误代码之一。

查找实体所属的 EntityGroup gid#

gxf_result_t GxfEntityGroupId(
gxf_context_t context,
gxf_uid_t eid,
gxf_uid_t *gid,
);#

EntityGroup 是 EntityItem 的组，因此这些实体绑定到某些共同的属性。目前，共同的属性是各种资源。在每个实体的生命周期中，它始终对应于一个 EntityGroup。例如，新创建的 EntityItem 指向默认的 EntityGroup，用户可以将其 EntityGroup 更新为有效的 EntityGroup。

参数:

  • context – 有效的 GXF 上下文

  • eid – EntityItem 的 eid，其 EntityGroup id 字段用于查找 EntityGroup 名称

  • gid – 返回的实体组 id。

返回值:

如果操作成功，则返回 GXF_SUCCESS，否则返回 GXF 错误代码之一。

获取 EntityGroup 的名称#

gxf_result_t GxfEntityGroupName(
gxf_context_t context,
gxf_uid_t eid,
const char **name,
);#

获取实体持有的 EntityGroup 的名称

EntityGroup 是 EntityItem 的组，因此这些实体绑定到某些共同的属性。目前，共同的属性是各种资源。在每个实体的生命周期中，它始终对应于一个 EntityGroup。例如，新创建的 Entity item 指向默认的 EntityGroup，用户可以将其 EntityGroup 更新为有效的 EntityGroup。

参数:

  • context – 有效的 GXF 上下文

  • eid – Entity item 的 eid，其 EntityGroup id 字段用于查找 EntityGroup 名称

  • name – 返回的 EntityGroup 名称

返回值:

如果操作成功，则返回 GXF_SUCCESS，否则返回 GXF 错误代码之一。

从 EntityGroup 获取资源组件 id#

gxf_result_t GxfEntityResourceGetHandle(
gxf_context_t context,
gxf_uid_t eid,
const char *type,
const char *resource_key,
gxf_uid_t *resource_cid,
);#

获取与给定实体分组的资源组件的 cid

参数:

  • context – 有效的 GXF 上下文

  • eid – Entity 的 eid

  • type – 组件的完全限定 C++ 类型名称

  • resource_key – 资源的键或名称

  • resource_cid – 返回的资源组件 cid

返回值:

如果操作成功，则返回 GXF_SUCCESS，否则返回 GXF 错误代码之一。

信息查询#

获取有关 GXF 运行时的元数据#

type gxf_runtime_info#

一个结构体，表示 GXF Runtime 的版本和加载的扩展列表。

const char *version#

GXF Runtime 版本。

uint64_t num_extensions#

扩展的输入/输出容量/扩展类型数量。

gxf_tid_t *extensions#

扩展 ID 列表。

gxf_result_t GxfRuntimeInfo(
gxf_context_t context,
gxf_runtime_info *info,
);#
参数:

  • context – 有效的 GXF 上下文。

  • info – 指向 gxf_runtime_info 对象的指针，用于获取元数据。

返回值:

如果操作成功，则返回 GXF_SUCCESS，否则返回 GXF 错误代码之一。

获取加载的扩展中的描述和组件列表#

type gxf_extension_info_t#

一个结构体，表示加载的扩展的描述和组件列表。

gxf_tid_t id#

通过 GXF_EXT_FACTORY_SET_INFO 注册的扩展 ID (UUID)。

const char *name#

通过 GXF_EXT_FACTORY_SET_INFO 注册的扩展名称。

const char *description#

通过 GXF_EXT_FACTORY_SET_INFO 注册的描述。

const char *version#

通过 GXF_EXT_FACTORY_SET_INFO 注册的扩展版本。

const char *runtime_version#

扩展编译时使用的 GXF Core 版本。

const char *license#

通过 GXF_EXT_FACTORY_SET_INFO 注册的扩展许可证。

const char *author#

通过 GXF_EXT_FACTORY_SET_INFO 注册的扩展作者。

const char *display_name#

通过 GXF_EXT_FACTORY_SET_DISPLAY_INFO 注册的扩展显示名称。

const char *category#

通过 GXF_EXT_FACTORY_SET_DISPLAY_INFO 注册的扩展类别。

const char *brief#

通过 GXF_EXT_FACTORY_SET_DISPLAY_INFO 注册的扩展摘要。

uint64_t num_components#

组件的输入/输出容量/组件数量。

gxf_tid_t *components#

提供的组件的 ID 列表。

gxf_result_t GxfExtensionInfo(
gxf_context_t context,
gxf_tid_t tid,
gxf_extension_info_t *info,
);#
参数:

  • context – 有效的 GXF 上下文。

  • tid – 扩展的唯一标识符。

  • info – 指向 gxf_extension_info_t 对象的指针，用于获取元数据。

返回值:

如果操作成功，则返回 GXF_SUCCESS，否则返回 GXF 错误代码之一。

获取组件的描述和参数列表#

type gxf_component_info_t#

一个结构体，表示组件的描述和参数列表。

gxf_tid_t cid#

通过 GXF_EXT_FACTORY_ADD 注册的组件 ID。

const char *base_name#

通过 GXF_EXT_FACTORY_ADD 注册的基类名称。

int is_abstract#

组件是否为抽象的且无法实例化。

const char *type_name#

通过 GXF_EXT_FACTORY_ADD 注册的组件名称。

const char *display_name#

通过 GXF_EXT_FACTORY_SET_DISPLAY_INFO 注册的组件显示名称，最多 30 个字符。

const char *brief#

通过 GXF_EXT_FACTORY_SET_DISPLAY_INFO 注册的组件摘要，最多 50 个字符。

const char *description#

通过 GXF_EXT_FACTORY_ADD 注册的描述。

uint64_t num_parameters#

参数的输入/输出容量/参数数量。

const char **parameters#

参数的名称列表。

gxf_result_t GxfComponentInfo(
gxf_context_t context,
gxf_tid_t tid,
gxf_component_info_t *info,
);#

注意：参数仅在为组件创建至少一个实例后才可用。

参数:

  • context – 有效的 GXF 上下文。

  • tid – 组件的唯一标识符。

  • info – 指向 gxf_component_info_t 对象的指针，用于获取元数据。

返回值:

如果操作成功，则返回 GXF_SUCCESS，否则返回 GXF 错误代码之一。

获取参数类型描述#

enum gxf_parameter_type_t#

一个枚举，表示参数的类型。

enumerator GXF_PARAMETER_TYPE_CUSTOM#

GXF 本身不支持的自定义类型。

enumerator GXF_PARAMETER_TYPE_HANDLE#

GXF 句柄。句柄类型单独指定。

enumerator GXF_PARAMETER_TYPE_STRING#

以 null 结尾的字符串 (const char*)。

enumerator GXF_PARAMETER_TYPE_INT64#

64 位有符号整数 (int64_t)。

enumerator GXF_PARAMETER_TYPE_UINT64#

64 位无符号整数 (uint64_t)。

enumerator GXF_PARAMETER_TYPE_FLOAT64#

64 位浮点数 (double)。

enumerator GXF_PARAMETER_TYPE_BOOL#

布尔类型 (bool)。

enumerator GXF_PARAMETER_TYPE_INT32#

32 位有符号整数 (int32_t)。

enumerator GXF_PARAMETER_TYPE_FILE#

文件系统路径（字符串）。

enumerator GXF_PARAMETER_TYPE_INT8#

8 位有符号整数 (int8_t)。

enumerator GXF_PARAMETER_TYPE_INT16#

16 位有符号整数 (int16_t)。

enumerator GXF_PARAMETER_TYPE_UINT8#

8 位无符号整数 (uint8_t)。

enumerator GXF_PARAMETER_TYPE_UINT16#

一个 16 位无符号整数 (uint16_t)。

enumerator GXF_PARAMETER_TYPE_UINT32#

一个 32 位无符号整数 (uint32_t)。

enumerator GXF_PARAMETER_TYPE_FLOAT32#

一个 32 位浮点数 (float)。

enumerator GXF_PARAMETER_TYPE_COMPLEX64#

一个 64 位复数浮点数 (float)。

enumerator GXF_PARAMETER_TYPE_COMPLEX128#

一个 128 位复数浮点数 (double)。

获取描述参数类型的字符串

const char *GxfParameterTypeStr(gxf_parameter_type_t param_type);#
参数:

  • param_type – 要获取信息的参数类型。

返回值:

参数类型的 C 风格字符串描述。

获取标志类型描述#

获取描述标志类型的字符串

const char *GxfParameterFlagTypeStr(gxf_parameter_flags_t_ flag_type);#
参数:

  • flag_type – 要获取信息的标志类型。

返回值:

标志类型的 C 风格字符串描述。

获取参数描述#

type gxf_parameter_info_t#

一个结构体，用于保存关于参数的元数据信息，该参数已注册为组件接口的一部分。

const char *key#

参数在 GXF 文件中显示的名称。

const char *headline#

用于向用户显示参数的简短标题。

const char *description#

描述参数用法的较长文本。

gxf_parameter_flags_t flags#

参数标志，例如使参数成为可选。

gxf_parameter_type_t type#

参数的类型

gxf_tid_t handle_tid#

如果参数是句柄，则为组件的 TID。

const void *default_value#

参数的默认值，句柄和自定义参数不适用。

const void *numeric_min#

数值参数范围的最小值，其他类型不适用。

const void *numeric_max#

数值参数范围的最大值，其他类型不适用。

const void *numeric_step#

数值参数范围的步长值，其他类型不适用。

const char *platform_information#

以逗号分隔的平台。空表示所有平台。

int32_t rank#

参数的秩。0-标量，1-列表等。最大秩为 8。

int32_t shape[8]#

如果多维参数的长度是固定的，则为尺寸大小。标量和可变长度数组的维度形状为 -1。

获取特定参数的描述。如果组件尚未实例化，则会失败。

gxf_result_t GxfGetParameterInfo(
gxf_context_t context,
gxf_tid_t cid,
const char *key,
gxf_parameter_info_t *info,
);#
参数:

  • context – 有效的 GXF 上下文。

  • cid – 组件的唯一标识符。

  • key – 参数的名称。

  • info – 指向 gxf_parameter_info_t 对象的指针，用于获取值。

返回值:

如果操作成功，则返回 GXF_SUCCESS，否则返回 GXF 错误代码之一。

将日志重定向到文件#

将控制台日志重定向到提供的文件。

gxf_result_t GxfRedirectLog(gxf_context_t context, FILE *fp);#
参数:

  • context – 有效的 GXF 上下文。

  • fp – 重定向日志的文件路径。

返回值:

如果操作成功，则返回 GXF_SUCCESS，否则返回 GXF 错误代码之一。

杂项#

获取错误的字符串描述#

const char *GxfResultStr(gxf_result_t result);#

获取描述 GXF 错误代码的字符串。

调用者不拥有返回的 C 字符串的所有权，并且不得删除它。

参数:

  • result – GXF 错误代码

返回值:

指向包含错误代码描述的 C 字符串的指针。

检查结果是否成功#

bool isSuccessful(gxf_result_t result);#

检查结果代码是否为 GXF_SUCCESS。

参数:

  • result – 一个 GXF 结果代码

返回值:

一个布尔值，指示结果代码是否为 GXF_SUCCESS。

设置日志严重性#

type gxf_severity_t#

用于 GXF_LOG_* 日志宏的严重性级别枚举。

type GXF_SEVERITY_NONE#
type GXF_SEVERITY_ERROR#
type GXF_SEVERITY_WARNING#
type GXF_SEVERITY_INFO#
type GXF_SEVERITY_DEBUG#
type GXF_SEVERITY_VERBOSE#
gxf_result_t GxfSetSeverity(
gxf_context_t context,
gxf_severity_t severity,
);#

为整个应用程序设置日志的严重性级别（对应于 GXF_LOG_* 日志宏）。

参数:

  • context – 有效的 GXF 上下文

  • severity – 有效的严重性级别，如 gxf_severity_t 中定义。严重性级别 <= 设置级别的日志将被记录。

返回值:

如果操作成功，则返回 GXF_SUCCESS，否则返回 GXF 错误代码之一。

获取日志严重性#

gxf_result_t GxfGetSeverity(
gxf_context_t context,
gxf_severity_t severity,
);#

返回当前日志的严重性级别。

参数:

  • context – 有效的 GXF 上下文

  • severity – 指向 gxf_severity_t 的指针，结果严重性将在其中返回。

返回值:

如果操作成功，则返回 GXF_SUCCESS，否则返回 GXF 错误代码之一。

在本页中