GXF Core C++ API#

预期#

template<typename T>
using nvidia::gxf::Expected = nvidia::Expected<T, gxf_result_t>#

Expected 类型是一个模板，表示一个值，该值要么包含 T 类型的结果，要么包含 gxf_result_t 类型的错误代码。它在整个 GXF 框架中用于表示函数的结果，这些函数可能成功并返回值，或者失败并返回错误代码。

template<typename T>
nvidia::gxf::Expected<T> nvidia::gxf::Expected(
T value,
)#

构造一个具有 T 类型值的 expected 对象。

参数:

value – 要存储在 Expected 对象中的值。

template<typename T>
nvidia::gxf::Expected<T> nvidia::gxf::Expected(
T &&value,
)#

使用移动构造构造一个具有 T 类型值的 expected 对象。

参数:

value – 要存储在 Expected 对象中的值。

template<typename T>
bool nvidia::gxf::Expected::has_value()#

如果 Expected 对象包含值，则返回 true，否则返回 false。

返回:

如果 Expected 对象包含值，则返回 True，否则返回 false。

template<typename T>
T nvidia::gxf::Expected::value()#

如果 expected 对象具有有效值，则返回该值，否则如果使用 Unexpected 构造，则会引发断言。

返回:

存储在 Expected 对象中的值。

template<typename T>
gxf_result_t nvidia::gxf::Expected::error()#

如果 expected 对象是使用 Unexpected 构造的，则返回其错误代码，否则会引发断言。

返回:

存储在 Expected 对象中的错误代码。

template<typename T>
nvidia::gxf::Unexpected<gxf_result_t> nvidia::gxf::ForwardError(
const nvidia::gxf::Expected<T> &expected,
)#

将错误代码提取为 unexpected。

参数:

expected – 要从中提取错误代码的 Expected 对象。

返回:

存储在 Expected 对象中的错误代码，作为 unexpected。

template<typename T>
nvidia::gxf::Unexpected<gxf_result_t> nvidia::gxf::ForwardError(
nvidia::gxf::Expected<T> &&expected,
)#

将错误代码提取为 unexpected。

参数:

expected – 要从中提取错误代码的 Expected 对象。

返回:

存储在 Expected 对象中的错误代码，作为 unexpected。

template<typename T>
gxf_result_t nvidia::gxf::ToResultCode(
const nvidia::gxf::Expected<T> &result,
)#

将 expected 解释为结果代码。如果结果具有值，则返回 GXF_SUCCESS，否则返回结果的错误代码。

参数:

result – 要解释为结果代码的 Expected 对象。

返回:

如果 Expected 对象包含值，则返回 GXF_SUCCESS，否则返回结果的错误代码。

nvidia::gxf::Expected<void> nvidia::gxf::ExpectedOrCode(
gxf_result_t code,
)#

如果结果代码为 GXF_SUCCESS，则该函数返回 nvidia::gxf::Success，否则返回带有给定错误代码的 unexpected。

参数:

code – 要解释的结果代码。

返回:

一个 Expected 对象

template<typename T>
nvidia::gxf::Expected<std::remove_cv_t<std::remove_reference_t<T>>> nvidia::gxf::ExpectedOrCode(
gxf_result_t code,
T &&value,
)#

如果结果代码为 GXF_SUCCESS，则该函数返回值，否则返回带有给定错误代码的 unexpected。

参数:

  • code – 要解释的结果代码。

  • value – 当代码为 GXF_SUCCESS 时要返回的值

返回:

一个 Expected 对象

template<typename S, typename T>
nvidia::gxf::Expected<std::remove_cv_t<std::remove_reference_t<T>>> nvidia::gxf::ExpectedOrError(
const nvidia::gxf::Expected<S> &code,
T &&value,
)#

如果 expected 代码是有效的 expected 对象，则该函数返回给定值，否则返回错误作为 Unexpected。

参数:

  • code – 要解释的 expected 对象。

  • value – 当代码具有有效对象时要返回的值

返回:

一个 Expected 对象

template<typename S, typename T>
gxf_result_t nvidia::gxf::AccumulateError(
gxf_result_t previous,
gxf_result_t current,
)#

累积两个 nvidia::gxf::gxf_result_t 对象的错误代码。如果第一个代码不是 GXF_SUCCESS，则返回第一个代码，否则返回上一个代码

nvidia::gxf::Expected<void> nvidia::gxf::AccumulateError(
Expected<void> previous,
Expected<void> current,
)#

累积两个 expected 对象的错误代码。如果当前对象有错误，则返回当前对象，否则返回上一个对象。

创建 Expected

可以通过两种方式创建 Expected

通过使用 T 类型的值构造它

Expected<int> result{42};

通过使用 gxf_result_t 类型的错误代码构造它

Expected<int> result = Unexpected{GXF_OUT_OF_MEMORY};

访问值或错误代码

可以使用 value() 和 error() 成员函数分别访问 Expected 的值或错误代码。如果 Expected 包含一个值，则 value() 返回该值，error() 返回 gxf_result_t 类型的错误代码，其值为 GXF_SUCCESS。如果 Expected 包含一个错误代码，则 value() 返回 gxf_result_t 类型的错误代码，其值为 GXF_FAILURE，error() 返回错误代码。

Expected<int> result {42};
int value = result.value(); // value == 42
gxf_result_t error = result.error(); // GXF_ASSERT raised

Expected<int> result = Unexpected{GXF_OUT_OF_MEMORY};
error = result.error(); // error == GXF_OUT_OF_MEMORY
value = result.value(); // GXF_ASSERT raised

检查 Expected 是否包含值

可以使用 has_value() 成员函数检查 Expected 中是否存在值。

Expected<int> result {42};
if (result.has_value()) {
   // The expected contains a value
} else {
   // The expected contains an error code
}

将 Expected 转换为结果代码

可以使用 ToResultCode() 函数将 Expected 转换为结果代码。如果 Expected 包含一个值，则该函数返回 GXF_SUCCESS。如果 Expected 包含一个错误代码，则该函数返回该错误代码。

Expected<int> result {42};
gxf_result_t code = ToResultCode(result); // code == GXF_SUCCESS

Expected<int> result = Unexpected{GXF_OUT_OF_MEMORY};
code = ToResultCode(result); // code == GXF_OUT_OF_MEMORY

从结果代码创建 Expected

可以使用 ExpectedOrCode() 函数从结果代码创建 Expected。如果结果代码是 GXF_SUCCESS，则该函数返回一个 Expected，其值的类型为 T。如果结果代码不是 GXF_SUCCESS，则该函数返回一个 Expected，其中包含类型为 gxf_result_t 的相应错误代码。

gxf_result_t code = GXF_SUCCESS;
int value = 42;
Expected<int> result = ExpectedOrCode(code, 42); // result contains a value of type int with the value 42

将 Expected 与返回值的函数一起使用

Expected 类型可以与返回值函数一起使用，以简化错误处理。例如，考虑以下将两个整数相除的函数

Expected<int> Divide(int dividend, int divisor) {
   if (divisor == 0) {
      return Unexpected{GXF_INVALID_ARGUMENT};
   }
   return dividend / divisor;
}

如果除法成功，此函数返回一个类型为 int 的 Expected，如果除法不可能（即，如果除数为零），则返回类型为 gxf_result_t 的错误代码。 nvidia::gxf::Unexpected 类型是一个模板特化，与 nvidia::gxf::Expected 模板结合使用，以表示结果类型中的错误状态。

要使用此函数，调用者可以检查 Expected 是否包含值或错误代码

Expected<int> result = Divide(42, 0);
if (result.has_value()) {
   // The division was successful
   int value = result.value();
} else {
   // The division was not successful
   gxf_result_t error = result.error();
}

组件#

class nvidia::gxf::Component#

组件是实体的一部分，并提供其功能。 Component 类是所有 GXF 组件的基类。它为在 GXF 实体中创建和管理组件提供了通用接口。

virtual gxf_result_t initialize() = 0;#

用于启动组件的生命周期，应代替构造函数使用。在创建实体的所有组件后调用。同一实体内组件的初始化顺序未定义。

virtual gxf_result_t deinitialize() = 0;#

用于结束组件的生命周期，应代替析构函数使用。同一实体内组件的反初始化顺序未定义。

virtual gxf_result_t registerInterface(Registrar *registrar) = 0;#

用于注册组件的所有参数。请勿将此函数用于其他目的，因为它可能在运行时随时被调用。

示例:
class Foo : public Component {
 public:
  gxf_result_t registerInterface(Registrar* registrar) override {
      registrar->parameter(count_, "count", 1);
  }
  Parameter<int> count_;
};

registerInterface() 函数用于注册组件的参数。它接受指向 Registrar 对象的指针作为参数，并使用重载的 parameter api 之一注册组件的所有参数。该 api 支持多个参数，其中包括参数名称、唯一键标识符、参数标题和描述字符串以及其默认值。

gxf_context_t context() const noexcept;#

获取组件的上下文。

gxf_uid_t eid() const noexcept;#

获取组件的实体 ID。

gxf_uid_t cid() const noexcept;#

获取组件的组件 ID。

gxf_tid_t tid() const noexcept;#

获取组件的类型 ID。

const char *type_name() const noexcept;#

获取组件的类型名称。

Entity entity() const noexcept;#

获取拥有此组件的实体。

const char *name() const noexcept;#

获取组件的名称。

void internalSetup(
gxf_context_t context,
gxf_uid_t eid,
gxf_uid_t cid,
Registrar *registrar,
);#

此函数应仅由 GXF 调用，用于设置组件。

template<typename T>
Expected<T> getParameter(const char *key);#

使用给定的 “key” 查询组件参数的值，其中 T 是有效的参数类型。

参数:

key – 组件注册期间使用的唯一字符串值

返回:

有效键的 T 类型值或失败时的错误代码

Expected<YAML::Node> wrapParameter(const char *key);#

将参数 “key” 的当前值包装在 yaml 节点中。

参数:

key – 组件注册期间使用的唯一字符串值

返回:

带有参数值的 yaml 节点

template<typename T>
Expected<void> setParameter(
const char *key,
T value,
);#

使用 “value” 设置参数 “key”，其中 T 是有效的参数类型。

参数:

  • key – 组件注册期间使用的唯一字符串值

  • value – T 类型的对象

返回:

Expected<void> 成功或失败时的错误代码

template<typename T>
Expected<void> setParameter(
const char *key,
Handle<T> &value,
);#

使用 “value” 设置句柄类型的参数 “key”，其中 T 是有效的参数类型。

参数:

  • key – 组件注册期间使用的唯一字符串值

  • value – 指向 T 类型组件对象的句柄

返回:

成功或失败时的错误代码

Expected<void> parseParameter(
const char *key,
const YAML::Node &node,
std::string prefix = "",
);#

使用 yaml 节点中的值设置参数 “key”。

参数:

  • key – 组件注册期间使用的唯一字符串值

  • node – 带有参数值的 yaml 节点

  • prefix – 实体前缀字符串

返回:

成功或失败时的错误代码

template<typename T>
Expected<std::vector<ParameterRegistrar::ComponentParameterInfo>> getParametersOfType(
);#

查询组件中类型为 T 的所有参数，并返回其 ComponentParameterInfo 结构。

返回:

给定类型的参数的 ComponentParameterInfo 向量

Expected<ParameterRegistrar::ComponentParameterInfo> getParameterInfo(
const char *key,
);#

查询参数 “key” 的 ComponentParameterInfo。

virtual ~Component() = default;#

析构函数。

Component(const Component &component) = delete;#

删除复制构造函数。删除此构造函数是为了防止复制组件。

Component(Component &&component) = delete;#

删除移动构造函数。删除此构造函数是为了防止移动组件。

Component &operator=(const Component &component) = delete;#

删除复制赋值运算符。删除此运算符是为了防止复制组件。

Component &operator=(Component &&component) = delete;#

删除移动赋值运算符。删除此运算符是为了防止移动组件。

实体#

class nvidia::gxf::Entity#

一个实体拥有多个组件，这些组件定义了实体的功能。实体本身只不过是一个唯一的标识符。使用 C++ 类型创建的实体是引用计数的。当实体对象被销毁或超出作用域时，引用计数会自动减少。

static Expected<Entity> New(
gxf_context_t context,
const char *name = nullptr,
)#

使用给定的上下文创建新实体，并可选择设置给定的名称。此 api 的调用者拥有该对象。引用计数设置为 1，并且在此对象被销毁或超出作用域时自动减少。

参数:

  • context – GXF 上下文。

  • name – 实体的名称。

返回:

新实体或错误。

static Expected<Entity> Own(
gxf_context_t context,
gxf_uid_t eid,
void *item_ptr = nullptr,
)#

基于现有 ID 创建实体句柄并取得所有权。引用计数不会增加。

参数:

  • context – GXF 上下文。

  • eid – 实体 ID。

  • item_ptr – 可选的实体项指针

返回:

新的实体句柄或错误。

static Expected<Entity> Shared(
gxf_context_t context,
gxf_uid_t eid,
void *item_ptr = nullptr,
)#

基于现有 ID 创建实体句柄并共享所有权。引用计数增加一。

参数:

  • context – GXF 上下文。

  • eid – 实体 ID。

返回:

新的实体句柄或错误。

Entity()#

使用默认构造函数构造新的实体对象。这是一个空实体，没有有效的上下文或实体 ID。

Entity(const Entity &other)#

通过从另一个实体对象复制来构造新的实体对象。

Entity(Entity &&other)#

通过从现有实体对象移动内容来构造新的实体对象。

~Entity()#

销毁 Entity 对象。将引用计数减少 1。

gxf_context_t context() const#

返回实体的 GXF 上下文。

gxf_uid_t eid() const#

返回实体的唯一对象 ID (UID)

bool is_null() const#

检查实体对象是否为空

const char *name() const#

实体的名称；如果未给实体命名，则为空字符串。

Expected<void> activate()#

激活实体。参见 gxf.h 中的 GxfEntityActivate

Expected<void> deactivate()#

停用实体。参见 gxf.h 中的 GxfEntityDeactivate

Expected<Entity> clone() const#

从现有实体对象克隆实体。返回的实体与被克隆的实体共享所有权。引用计数增加一。

Expected<UntypedHandle> add(gxf_tid_t tid, const char *name = nullptr)#

添加具有给定类型 ID 的组件

参数:

  • tid – 已注册组件的有效类型 ID

  • name – 赋予新创建的组件实例的名称

返回:

组件的无类型句柄或失败时的错误代码

template<typename T>
Expected<Handle<T>> add(
const char *name = nullptr,
)#

添加类型为 T 的组件，其中 T 是已注册的组件类型。

参数:

name – 赋予新创建的组件实例的名称

返回:

新的组件句柄或错误。

Expected<UntypedHandle> get(
gxf_tid_t tid,
const char *name = nullptr,
) const#

通过类型 ID 获取组件。如果不存在此类组件，则会断言。

参数:

  • tid – 已注册组件的有效类型 ID

  • name – 要查找的组件的名称

返回:

组件的无类型句柄或失败时的错误代码

template<typename T>
Expected<Handle<T>> get(
const char *name = nullptr,
) const#

获取具有给定名称的 T 类型组件。如果不存在此类组件，则会断言。

参数:

name – 要查找的组件的名称

返回:

组件实例的类型化句柄或失败时的错误

template<size_t N = kMaxComponents>
Expected<FixedVector<UntypedHandle, N>> findAll(
) const#

查找实体中的所有组件。返回所有组件的无类型句柄列表。 N 是 FixedVector 的容量。

返回:

在堆栈上分配的无类型组件句柄的固定大小向量或错误。

template<typename T, size_t N = kMaxComponents>
Expected<FixedVector<Handle<T>, N>> findAll(
) const#

查找给定类型的所有组件，其中 T 是已注册组件的有效类型，N 是 FixedVector 的容量。

返回:

在堆栈上分配的 T 类型句柄的固定大小向量或错误。

template<size_t N = kMaxComponents>
Expected<FixedVector<UntypedHandle>> findAllHeap(
) const#

查找实体中的所有组件。返回所有组件的无类型句柄的固定大小向量。

返回:

Expected<FixedVector<UntypedHandle, N>> 在堆上分配的所有组件的无类型句柄的固定大小向量

template<typename T, size_t N = kMaxComponents>
Expected<FixedVector<Handle<T>>> findAllHeap(
)#

查找实体中类型为 T 的所有组件。返回所有组件的类型化句柄的固定大小向量。

返回:

Expected<FixedVector<Handle<T>>> 在堆上分配的给定组件类型的类型化句柄的固定大小向量

Expected<void> remove(gxf_tid_t tid, const char *name = nullptr)#

删除具有给定类型 ID 和名称的组件

参数:

  • tid – 已注册组件的有效类型 ID

  • name – 赋予新创建的组件实例的名称

返回:

Expected<void> 成功或失败时的错误代码

template<typename T>
Expected<void> remove(
const char *name = nullptr,
)#

删除具有给定模板组件类型和名称的组件

参数:

name – 组件的名称

返回:

Expected<void> 成功或失败时的错误代码

Expected<void> remove(gxf_uid_t &cid)#

删除具有给定 uid 的组件

参数:

cid – 组件的有效 uid

返回:

Expected<void> 成功或失败时的错误代码

void *entity_item_ptr() const#

返回实体的 Entity Item 的指针

返回:

void * 实体项指针

Handle#

UntypedHandle 类#

class nvidia::gxf::UntypedHandle#

UntypedHandle 类是 Handle 的基类，并为访问组件提供通用功能，而无需指定其类型。

static UntypedHandle Null()#
返回:

一个空的 UntypedHandle 对象。

static Expected<UntypedHandle> Create(
gxf_context_t context,
gxf_uid_t cid,
)#

创建一个新的无类型句柄

参数:

  • context – 组件所属的上下文。

  • cid – 组件的 ID。

返回:

给定上下文和组件 ID 的新的 UntypedHandle 对象。

gxf_context_t context() const#
返回:

组件所属的上下文。

gxf_uid_t cid() const#
返回:

组件的 ID。

gxf_tid_t tid() const#
返回:

描述组件类型的类型 ID。

bool is_null() const#
返回:

如果句柄等效于 nullptr，则为 True。

explicit operator bool() const#
返回:

如果句柄不为空，则为 True。

const char *name() const#
返回:

组件的名称。

UntypedHandle(const UntypedHandle &component) = default#
参数:

component – 要复制的 UntypedHandle 对象。

UntypedHandle(UntypedHandle &&component) = default#
参数:

component – 要移动的 UntypedHandle 对象。

UntypedHandle &operator=(const UntypedHandle &component) = default#
参数:

component – 要复制的 UntypedHandle 对象。

UntypedHandle &operator=(UntypedHandle &&component) = default#
参数:

component – 要移动的 UntypedHandle 对象。

Handle 类#

class nvidia::gxf::Handle#

Handle 类是一个模板类，它派生自 UntypedHandle，并提供对具有特定类型的组件的访问。

static Handle Null()#
返回:

一个空的 Handle 对象。

static Handle Unspecified()#

未指定的句柄是一个唯一的句柄，用于表示将来将创建的组件。 类型为 Handle 的参数不将 “Unspecified” 视为有效参数值，因此，仅当跨不同文件定义图形应用程序且参数以延迟方式设置时（例如，子图和参数 yaml 文件）才必须使用此句柄。 如果任何必需参数为 “Unspecified”，实体激活将失败

返回:

一个未指定的 Handle 对象。

static Expected<Handle> Create(gxf_context_t context, gxf_uid_t cid)#

使用组件 ID 创建新句柄

参数:

  • context – 组件所属的上下文。

  • cid – 组件的 ID。

返回:

给定上下文和组件 ID 的新的 Handle 对象。

static Expected<Handle> Create(const UntypedHandle &untyped_handle)#

从无类型句柄创建新句柄

参数:

untyped_handle – 用于创建 Handle 对象的 UntypedHandle 对象。

返回:

给定 UntypedHandle 对象的新的 Handle 对象。

bool operator==(const Handle &lhs, const Handle &rhs);#

比较两个句柄对象是否相等

返回:

如果句柄对象指向同一组件，则为 True

bool operator!=(const Handle &lhs, const Handle &rhs);#

比较两个句柄对象是否不相等

返回:

如果句柄对象未指向同一组件，则为 True

bool operator<(const Handle &lhs, const Handle &rhs);#

比较一个句柄对象是否小于另一个

参数:

  • lhs – 类型化句柄组件

  • rhs – 类型化句柄组件

返回:

如果 lhs 的组件 ID 小于 rhs，则为 True

template<typename Derived>
Handle(
gxf_context_t context = kNullContext,
gxf_uid_t uid = kNullUid,
)#

构造函数，等效于 :cpp:func::Handle::Create 函数

operator T*() const#
返回:

指向特定类型组件的指针。

T *operator->() const#
返回:

指向特定类型组件的指针。

T *get() const#
返回:

指向特定类型组件的指针。

Expected<T*> try_get() const#
返回:

指向特定类型组件的指针；如果句柄无效，则返回错误。

Handle(const Handle &component) = default#
参数:

component – 要复制的 Handle 对象。

Handle(Handle &&component) = default#
参数:

component – 要移动的 Handle 对象。

Handle &operator=(const Handle &component) = default#
参数:

component – 要复制的 Handle 对象。

Handle &operator=(Handle &&component) = default#
参数:

component – 要移动的 Handle 对象。

参数#

template<typename T>
class Parameter#

Parameter 是组件可以配置和访问的值。它提供了一种类型安全且便捷的方式来管理组件属性。

Parameter()#

默认构造函数。创建一个未初始化的 parameter。

返回:

一个未初始化的 parameter。

Parameter(const Parameter &other)#

复制构造函数。

参数:

other – 要复制的 parameter。

返回:

其他 parameter 的副本。

const T &get() const#

获取当前的 parameter 值。仅当 parameter 在 parameter 接口中标记为“mandatory”时才有效。否则会引发断言。

返回:

对 parameter 当前值的常量引用。

operator const T&() const#

用于将 mandatory parameter 作为常量引用访问的便捷函数。

返回:

对 parameter 当前值的常量引用。

Expected<T> try_get() const#

尝试获取 parameter 的当前值。如果 parameter 未设置或具有错误值，则返回带有错误代码的 Unexpected。

返回:

parameter 的当前值，或带有错误代码的 Unexpected。

Expected<void> set(T value)#
设置 parameter 的当前值。如果值无效，则返回 Unexpected

并带有错误代码。

参数:

value – parameter 的新值。

返回:

Expected<void> 成功或失败时的错误代码

void connect(ParameterBackend<T> *backend)#

将 parameter 连接到后端。后端负责管理 parameter 值并提供对其的访问。

参数:

backend – 要连接的后端。

const char *key() const#

返回 parameter 的键。该键是一个字符串，用于标识 parameter，并用于在 parameter 存储中查找它。

返回:

parameter 的键。

Expected<void> set_without_propagate(T value)#

设置 parameter 的当前值，但不将更改传播到后端。此函数应仅由 ParameterBackend 类使用。

参数:

value – parameter 的新值。

返回:

Expected<void> 成功或失败时的错误代码

Parameter 类型#

GXF 本地支持多种 parameter 类型，如 :c:enum::gxf_parameter_type_t 中所述。支持所有标准 C++ 数据类型，包括 POD 类型、字符串、布尔值、组件句柄和复数。ParameterWrapper 和 ParameterParser 接口可用于支持任何自定义 Parameter 类型。

struct ParameterParser#
template<typename T, typename V = void>
static Expected<T> Parse(
gxf_context_t context,
gxf_uid_t component_uid,
const char *key,
const YAML::Node &node,
const std::string &prefix,
)#

从 YAML 节点解析 T 类型的 parameter。

参数:

  • context – GXF 上下文。

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

  • key – parameter 的键。

  • node – 要解析的 YAML 节点。

  • prefix – 查找实体时使用的前缀。

返回:

一个 Expected，其中包含已解析的 parameter 或错误代码。

struct ParameterWrapper#
template<typename T, typename V = void>
static ExpectedYAML::Node Wrap(
gxf_context_t context,
const T &value,
)#

将 T 类型的值包装在 YAML 节点中。

参数:

  • context – GXF 上下文。

  • value – 要包装的值。

返回:

一个 Expected，其中包含 YAML 节点或错误代码。

这是一个适配 ParameterParser 和 ParameterWrapper 以创建枚举 parameter 的示例

示例:
// Mode switch
enum struct MyEnum {
  kValue0 = 0,
  kValue1 = 1,
};

// Custom parameter parser for MyEnum
template <>
struct ParameterParser<MyEnum> {
  static Expected<MyEnum> Parse(gxf_context_t context, gxf_uid_t component_uid,
                                const char* key, const YAML::Node& node,
                                const std::string& prefix) {
    const std::string value = node.as<std::string>();
    if (strcmp(value.c_str(), "Value0") == 0) {
      return MyEnum::kValue0;
    }
    if (strcmp(value.c_str(), "Value1") == 0) {
      return MyEnum::kValue1;
    }
    return Unexpected{GXF_ARGUMENT_OUT_OF_RANGE};
  }
};

// Custom parameter wrapper for MyEnum
template<>
struct ParameterWrapper<MyEnum> {
  static Expected<YAML::Node> Wrap(gxf_context_t context, const MyEnum& value) {
    YAML::Node node(YAML::NodeType::Scalar);
    switch (value) {
      case MyEnum::kValue0: {
        node = std::string("Value0");
        break;
      }
      case MyEnum::kValue1: {
        node = std::string("Value1");
        break;
      }
      default:
        return Unexpected{GXF_PARAMETER_OUT_OF_RANGE};
    }
    return node;
  }
};

Parameter 注册#

class nvidia::gxf::Registrar#

Registrar 类用于注册组件的 parameter 和资源。以下 API 必须仅在 registerInterface() 函数中使用。

template<typename T>
Expected<void> parameter(
Parameter<T> &parameter,
const char *key,
)#

使用给定的键注册 parameter，其中 T 是有效的 parameter 类型。

参数:

  • parameter – 要注册的 parameter

  • key – 组件注册期间使用的唯一字符串值

返回:

Expected<void> 成功或失败时的错误代码

template<typename T>
Expected<void> parameter(
Parameter<T> &parameter,
const char *key,
const char *headline,
)#

使用给定的键和标题注册 parameter，其中 T 是有效的 parameter 类型。

参数:

  • parameter – 要注册的 parameter

  • key – 组件注册期间使用的唯一字符串值

  • headline – parameter 的简要描述

返回:

Expected<void> 成功或失败时的错误代码

template<typename T>
Expected<void> parameter(
Parameter<T> &parameter,
const char *key,
const char *headline,
const char *description,
)#

使用给定的键、标题和描述注册 parameter，其中 T 是有效的 parameter 类型。

参数:

  • parameter – 要注册的 parameter

  • key – 组件注册期间使用的唯一字符串值

  • headline – parameter 的简要描述

  • description – parameter 的详细描述

返回:

Expected<void> 成功或失败时的错误代码

template<typename T>
Expected<void> parameter(
Parameter<T> &parameter,
const char *key,
const char *headline,
const char *description,
const T &default_value,
)#

使用给定的键、标题、描述和默认值注册 parameter，其中 T 是有效的 parameter 类型。

参数:

  • parameter – 要注册的 parameter

  • key – 组件注册期间使用的唯一字符串值

  • headline – parameter 的简要描述

  • description – parameter 的详细描述

  • default_value – parameter 的默认值

返回:

Expected<void> 成功或失败时的错误代码

template<typename T>
Expected<void> parameter(
Parameter<T> &parameter,
const char *key,
const char *headline,
const char *description,
const T &default_value,
gxf_parameter_flags_t flags,
)#

使用给定的键、标题、描述、默认值和标志注册 parameter，其中 T 是有效的 parameter 类型。

参数:

  • parameter – 要注册的 parameter

  • key – 组件注册期间使用的唯一字符串值

  • headline – parameter 的简要描述

  • description – parameter 的详细描述

  • default_value – parameter 的默认值

  • flags – 用于指定 parameter 属性的标志

返回:

Expected<void> 成功或失败时的错误代码

template<typename T>
Expected<void> parameter(
Parameter<T> &parameter,
const char *key,
const char *headline,
const char *description,
Unexpected,
gxf_parameter_flags_t flags,
)#

使用给定的键、标题、描述和标志注册 parameter，其中 T 是有效的 parameter 类型。默认值设置为 nvidia::gxf::Unexpected。

参数:

  • parameter – 要注册的 parameter

  • key – 组件注册期间使用的唯一字符串值

  • headline – parameter 的简要描述

  • description – parameter 的详细描述

  • flags – 用于指定 parameter 属性的标志

返回:

Expected<void> 成功或失败时的错误代码

template<typename T>
Expected<void> parameter(
nvidia::gxf::Parameter<T> &parameter,
const ParameterInfo<T> &parameter_info,
)#

使用包含所有 parameter 元数据的 ParameterInfo 注册 parameter，其中 T 是有效的 parameter 类型。

参数:

  • parameter – 要注册的 parameter

  • parameter_info – 包含所有 parameter 元数据的结构体

返回:

Expected<void> 成功或失败时的错误代码

template<typename T>
Expected<void> registerParameterlessComponent()#

注册一个没有 parameter 的组件。如果未重写 registerInterface()，则由 GXF 内部调用。

返回:

Expected<void> 成功或失败时的错误代码

static constexpr Unexpected NoDefaultParameter()#

返回一个常量，用于注册没有默认值的可选 parameter。

返回:

带有代码 GXF_PARAMETER_NOT_INITIALIZED 的 Unexpected

template<typename T>
Expected<void> resource(
Resource<Handle<T>> &resource,
const char *description,
)#

注册一个带有描述的资源

参数:

  • resource – 要注册的资源

  • description – 资源的详细描述

返回:

Expected<void> 成功或失败时的错误代码

在本页中