> For clean Markdown of any page, append .md to the page URL.
> For a complete documentation index, see https://docs.nvidia.com/holoscan/sdk-user-guide/llms.txt.
> For AI client integration (Claude Code, Cursor, etc.), connect to the MCP server at https://docs.nvidia.com/holoscan/sdk-user-guide/_mcp/server.

# holoscan::DownstreamMessageAffordableCondition

> Condition class that allows an operator to execute only when there is space in any downstream operator's receiver queues for a specified number of messages produced by a given output port.

[Condition](condition) class that allows an operator to execute only when there is space in any downstream operator's receiver queues for a specified number of messages produced by a given output port.

This condition applies to a specific output port of the operator as determined by setting the "transmitter" argument.

This condition can also be set via the [`Operator::setup`](gpuresidentoperator#setup) method using [`IOSpec::condition`](iospec#condition) with `ConditionType::kDownstreamMessageAffordable`. In that case, the transmitter is already known from the port corresponding to the [`IOSpec`](iospec) object, so the "transmitter" argument is unnecessary.

\==Parameters==

* **min\_size** (uint64\_t): The minimum number of messages that there must be space available for in the front stage of the double-buffer receiver queues of all receivers connected to the specified transmitter.
* **transmitter** (std::string): The transmitter that should check for space in the queue of all of its connected receivers. This should be specified by the name of the operator's output port the condition will apply to. The Holoscan SDK will then automatically replace the port name with the actual transmitter object at application run time.

```cpp showLineNumbers={false}
#include <holoscan/downstream_affordable.hpp>
```

**Inherits from:** `holoscan::gxf::GXFCondition` (public)

---

## Constructors

### DownstreamMessageAffordableCondition \[#downstreammessageaffordablecondition]

#### Move

inline

explicit

```cpp showLineNumbers={false}
template <typename ArgT,
          typename... ArgsT,
          typename = std::enable_if_t<!std::is_base_of_v<::holoscan::Condition, std::decay_t<ArgT>> &&   (std::is_same_v<::holoscan::Arg, std::decay_t<ArgT>> ||   std::is_same_v<::holoscan::ArgList, std::decay_t<ArgT>>)>>
holoscan::DownstreamMessageAffordableCondition::DownstreamMessageAffordableCondition(
    ArgT &&arg,
    ArgsT &&... args
)
```

#### Default

```cpp showLineNumbers={false}
holoscan::DownstreamMessageAffordableCondition::DownstreamMessageAffordableCondition() = default
```

#### Overload 3

inline

explicit

```cpp showLineNumbers={false}
holoscan::DownstreamMessageAffordableCondition::DownstreamMessageAffordableCondition(
    size_t min_size
)
```

---

## Methods

### gxf\_typename \[#gxftypename]

```cpp showLineNumbers={false}
const char * holoscan::DownstreamMessageAffordableCondition::gxf_typename() const override
```

### setup \[#setup]

```cpp showLineNumbers={false}
void holoscan::DownstreamMessageAffordableCondition::setup(
    ComponentSpec &spec
) override
```

Define the condition specification.

**Parameters**

**`spec`** `ComponentSpec &`

The reference to the component specification.

---

### transmitter \[#transmitter]

#### Overload 1

inline

```cpp showLineNumbers={false}
void holoscan::DownstreamMessageAffordableCondition::transmitter(
    std::shared_ptr<Transmitter> transmitter
)
```

#### Const

inline

const

```cpp showLineNumbers={false}
std::shared_ptr<Transmitter> holoscan::DownstreamMessageAffordableCondition::transmitter() const
```

#### Overload 3

```cpp showLineNumbers={false}
std::optional<std::shared_ptr<Transmitter>> holoscan::Condition::transmitter(
    const std::string &port_name
)
```

Return the [Transmitter](transmitter) corresponding to a specific output port of the [Operator](operator) associated with this condition.

**Returns:** The [Transmitter](transmitter) corresponding to the output port, if it exists. Otherwise, return nullopt.

**Parameters**

**`port_name`** `const std::string &`

The name of the output port.

---

### min\_size \[#minsize]

#### Mutable

```cpp showLineNumbers={false}
void holoscan::DownstreamMessageAffordableCondition::min_size(
    uint64_t min_size
)
```

#### Const

inline

const

```cpp showLineNumbers={false}
uint64_t holoscan::DownstreamMessageAffordableCondition::min_size() const
```

### initialize \[#initialize]

```cpp showLineNumbers={false}
void holoscan::DownstreamMessageAffordableCondition::initialize() override
```

Initialize the component.

This method is called only once when the component is created for the first time, and use of light-weight initialization.

### get \[#get]

```cpp showLineNumbers={false}
nvidia::gxf::DownstreamReceptiveSchedulingTerm * holoscan::DownstreamMessageAffordableCondition::get() const
```

### add\_to\_graph\_entity \[#addtographentity]

#### Overload 1

```cpp showLineNumbers={false}
void holoscan::DownstreamMessageAffordableCondition::add_to_graph_entity(
    Operator *op
)
```

#### Overload 2

```cpp showLineNumbers={false}
void holoscan::DownstreamMessageAffordableCondition::add_to_graph_entity(
    Fragment *fragment,
    std::shared_ptr<nvidia::gxf::GraphEntity> graph_entity
)
```

### to\_yaml\_node \[#toyamlnode]

```cpp showLineNumbers={false}
YAML::Node holoscan::DownstreamMessageAffordableCondition::to_yaml_node() const override
```

Get a `YAML` representation of the condition.

**Returns:** `YAML` node including type and spec of the condition in addition to the base component properties.

### reset\_backend\_objects \[#resetbackendobjects]

```cpp showLineNumbers={false}
void holoscan::DownstreamMessageAffordableCondition::reset_backend_objects() override
```

Reset any backend-specific state.

### check \[#check]

```cpp showLineNumbers={false}
virtual void holoscan::Condition::check(
    int64_t timestamp,
    SchedulingStatusType *status_type,
    int64_t *target_timestamp
) const
```

Check the condition status before allowing execution.

If the condition is waiting for a time event 'target\_timestamp' will contain the target timestamp.

**Parameters**

**`timestamp`** `int64_t`

The current timestamp

---

**`status_type`** `SchedulingStatusType *`

The status of the condition

---

**`target_timestamp`** `int64_t *`

The target timestamp (used if the term is waiting for a time event).

---

### on\_execute \[#onexecute]

```cpp showLineNumbers={false}
virtual void holoscan::Condition::on_execute(
    int64_t timestamp
)
```

Called each time after the entity of this term was executed.

**Parameters**

**`timestamp`** `int64_t`

The current timestamp

---

### update\_state \[#updatestate]

```cpp showLineNumbers={false}
virtual void holoscan::Condition::update_state(
    int64_t timestamp
)
```

Checks if the state of the condition can be updated and updates it.

**Parameters**

**`timestamp`** `int64_t`

The current timestamp

---

### condition\_type \[#conditiontype]

```cpp showLineNumbers={false}
ConditionComponentType holoscan::Condition::condition_type() const
```

Get the condition type.

**Returns:** The condition type.

### name \[#name]

#### Set the name of the condition (1)

```cpp showLineNumbers={false}
Condition & holoscan::Condition::name(
    const std::string &name
) &
```

Set the name of the condition.

**Returns:** The reference to the condition.

**Parameters**

**`name`** `const std::string &`

The name of the condition.

---

#### Set the name of the condition (2)

```cpp showLineNumbers={false}
Condition && holoscan::Condition::name(
    const std::string &name
) &&
```

Set the name of the condition.

**Returns:** The reference to the condition.

**Parameters**

**`name`** `const std::string &`

The name of the condition.

---

#### Const

const

```cpp showLineNumbers={false}
const std::string & holoscan::ComponentBase::name() const
```

Get the name of the component.

**Returns:** The name of the component.

### fragment \[#fragment]

#### Set the fragment of the condition

```cpp showLineNumbers={false}
Condition & holoscan::Condition::fragment(
    Fragment *fragment
)
```

Set the fragment of the condition.

**Returns:** The reference to the condition.

**Parameters**

**`fragment`** `Fragment *`

The pointer to the fragment of the condition.

---

#### Get a pointer to \[Fragment]\(fragment) object

```cpp showLineNumbers={false}
Fragment * holoscan::ComponentBase::fragment()
```

Get a pointer to [Fragment](fragment) object.

**Returns:** The Pointer to [Fragment](fragment) object.

#### Const

const

```cpp showLineNumbers={false}
const Fragment * holoscan::ComponentBase::fragment() const
```

Get a const pointer to [Fragment](fragment) object.

**Returns:** The const pointer to [Fragment](fragment) object.

### spec \[#spec]

#### Set the component specification to the condition

```cpp showLineNumbers={false}
Condition & holoscan::Condition::spec(
    const std::shared_ptr<ComponentSpec> &spec
)
```

Set the component specification to the condition.

**Returns:** The reference to the condition.

**Parameters**

**`spec`** `const std::shared_ptr<ComponentSpec> &`

The component specification.

---

#### Get the component specification of the condition

```cpp showLineNumbers={false}
ComponentSpec * holoscan::Condition::spec()
```

Get the component specification of the condition.

**Returns:** The pointer to the component specification.

### spec\_shared \[#specshared]

```cpp showLineNumbers={false}
std::shared_ptr<ComponentSpec> holoscan::Condition::spec_shared()
```

Get the shared pointer to the component spec.

**Returns:** The shared pointer to the component spec.

### add\_arg \[#addarg]

#### Add a resource to the condition (1)

```cpp showLineNumbers={false}
void holoscan::Condition::add_arg(
    const std::shared_ptr<Resource> &arg
)
```

Add a resource to the condition.

**Parameters**

**`arg`** `const std::shared_ptr<Resource> &`

The resource to add.

---

#### Add a resource to the condition (2)

```cpp showLineNumbers={false}
void holoscan::Condition::add_arg(
    std::shared_ptr<Resource> &&arg
)
```

Add a resource to the condition.

**Parameters**

**`arg`** `std::shared_ptr<Resource> &&`

The resource to add.

---

#### Add an argument to the component (1)

inline

```cpp showLineNumbers={false}
void holoscan::ComponentBase::add_arg(
    const Arg &arg
)
```

Add an argument to the component.

**Parameters**

**`arg`** `const Arg &`

The argument to add.

---

#### Add an argument to the component (2)

inline

```cpp showLineNumbers={false}
void holoscan::ComponentBase::add_arg(
    Arg &&arg
)
```

Add an argument to the component.

**Parameters**

**`arg`** `Arg &&`

The argument to add.

---

#### Add a list of arguments to the component (1)

inline

```cpp showLineNumbers={false}
void holoscan::ComponentBase::add_arg(
    const ArgList &arg
)
```

Add a list of arguments to the component.

**Parameters**

**`arg`** `const ArgList &`

The list of arguments to add.

---

#### Add a list of arguments to the component (2)

inline

```cpp showLineNumbers={false}
void holoscan::ComponentBase::add_arg(
    ArgList &&arg
)
```

Add a list of arguments to the component.

**Parameters**

**`arg`** `ArgList &&`

The list of arguments to add.

---

### resources \[#resources]

```cpp showLineNumbers={false}
std::unordered_map<std::string, std::shared_ptr<Resource>> & holoscan::Condition::resources()
```

Get the resources of the condition.

**Returns:** The resources of the condition.

### receiver \[#receiver]

```cpp showLineNumbers={false}
std::optional<std::shared_ptr<Receiver>> holoscan::Condition::receiver(
    const std::string &port_name
)
```

Return the [Receiver](receiver) corresponding to a specific input port of the [Operator](operator) associated with this condition.

**Returns:** The [Receiver](receiver) corresponding to the input port, if it exists. Otherwise, return nullopt.

**Parameters**

**`port_name`** `const std::string &`

The name of the input port.

---

### wrapper\_cid \[#wrappercid]

#### Mutable

```cpp showLineNumbers={false}
void holoscan::Condition::wrapper_cid(
    int64_t cid
)
```

Store the component ID for this condition in the underlying backend implementation.

This method may not be needed for all backends.

**Parameters**

**`cid`** `int64_t`

Component id corresponding to the underlying framework

---

#### Const

const

```cpp showLineNumbers={false}
int64_t holoscan::Condition::wrapper_cid() const
```

Get the component ID of a native [Condition](condition) in the underlying backend.

This may not be used by all backends.

In the case of GXF, this is the gxf\_uid\_t (alias for int64\_t) of the GXFSchedulingTermWrapper component that is used to wrap the native condition as a GXF SchedulingTerm.

This method is only relevant for native conditions. For conditions inheriting from GXFCondition, please just use GXFCondition::gxf\_cid() instead.

**Returns:** The unique GXF component id for this condition.

### notify\_scheduler \[#notifyscheduler]

```cpp showLineNumbers={false}
bool holoscan::Condition::notify_scheduler()
```

Notify the scheduler that an asynchronous event has completed.

This method is used by event-based conditions (those returning `kWaitEvent` from `check()`) to signal to the scheduler that the condition is now ready to be re-evaluated.

This method can be called from any thread (e.g., a CUDA host callback or a worker thread). It is thread-safe.

Example usage:

**Returns:** true if the notification was successful, false otherwise.

**Example**

```cpp showLineNumbers={false}
// In a CUDA host callback or worker thread
void my_callback(void* user_data) {
    auto* condition = static_cast<MyCondition*>(user_data);
    condition->state_.store(State::EVENT_COMPLETE);
    condition->notify_scheduler();
}
```

**See also:**
SchedulingStatusType::kWaitEvent

### set\_parameters \[#setparameters]

```cpp showLineNumbers={false}
void holoscan::Condition::set_parameters() override
```

Set the parameters based on defaults (sets GXF parameters for GXF components).

### id \[#id]

```cpp showLineNumbers={false}
int64_t holoscan::ComponentBase::id() const
```

Get the identifier of the component.

By default, the identifier is set to -1. It is set to a valid value when the component is initialized.

With the default executor (GXFExecutor), the identifier is set to the GXF component ID.

**Returns:** The identifier of the component.

### args \[#args]

```cpp showLineNumbers={false}
std::vector<Arg> & holoscan::ComponentBase::args()
```

Get the list of arguments.

**Returns:** The vector of arguments.

### description \[#description]

```cpp showLineNumbers={false}
std::string holoscan::ComponentBase::description() const
```

Get a description of the component.

**Returns:** `YAML` string.

**See also:**
to\_yaml\_node()

### service \[#service]

```cpp showLineNumbers={false}
template <typename ServiceT = DefaultFragmentService>
std::shared_ptr<ServiceT> holoscan::ComponentBase::service(
    std::string_view id = ""
) const
```

Retrieve a registered fragment service or resource.

Retrieves a previously registered fragment service or resource by its type and optional identifier. Returns nullptr if no service/resource is found with the specified type and identifier.

Note that any changes to the service retrieval logic in this method should be synchronized with the implementation in `Fragment::service()` method to maintain consistency.

**Returns:** The shared pointer to the service/resource, or nullptr if not found or if type casting fails.

**Template parameters**

**`ServiceT`** `typename`

The type of the service/resource to retrieve. Must inherit from either [Resource](resource) or [FragmentService](fragmentservice). Defaults to [DefaultFragmentService](defaultfragmentservice) if not specified.

---

**Parameters**

**`id`** `std::string_view` — default: ""

The identifier of the service/resource. If empty, retrieves by type only.

---

### get\_service\_by\_type\_info \[#getservicebytypeinfo]

```cpp showLineNumbers={false}
std::shared_ptr<FragmentService> holoscan::ComponentBase::get_service_by_type_info(
    const std::type_info &service_type,
    std::string_view id = ""
) const
```

Retrieve a registered fragment service or resource for Python bindings.

This is a helper method for Python bindings to retrieve a service by its C++ type info.

**Returns:** The shared pointer to the base service, or nullptr if not found.

**Parameters**

**`service_type`** `const std::type_info &`

The type info of the service/resource to retrieve.

---

**`id`** `std::string_view` — default: ""

The identifier of the service/resource. If empty, retrieves by type only.

---

### gxf\_context \[#gxfcontext]

#### Mutable

```cpp showLineNumbers={false}
void holoscan::gxf::GXFComponent::gxf_context(
    gxf_context_t gxf_context
)
```

#### Const

const

```cpp showLineNumbers={false}
gxf_context_t holoscan::gxf::GXFComponent::gxf_context() const
```

### gxf\_eid \[#gxfeid]

#### Mutable

```cpp showLineNumbers={false}
void holoscan::gxf::GXFComponent::gxf_eid(
    gxf_uid_t gxf_eid
)
```

#### Const

const

```cpp showLineNumbers={false}
gxf_uid_t holoscan::gxf::GXFComponent::gxf_eid() const
```

### gxf\_tid \[#gxftid]

#### Mutable

```cpp showLineNumbers={false}
void holoscan::gxf::GXFComponent::gxf_tid(
    gxf_tid_t gxf_tid
)
```

#### Const

const

```cpp showLineNumbers={false}
gxf_tid_t holoscan::gxf::GXFComponent::gxf_tid() const
```

### gxf\_cid \[#gxfcid]

#### Mutable

```cpp showLineNumbers={false}
void holoscan::gxf::GXFComponent::gxf_cid(
    gxf_uid_t gxf_cid
)
```

#### Const

const

```cpp showLineNumbers={false}
gxf_uid_t holoscan::gxf::GXFComponent::gxf_cid() const
```

### gxf\_cname \[#gxfcname]

#### Overload 1

```cpp showLineNumbers={false}
std::string & holoscan::gxf::GXFComponent::gxf_cname()
```

#### Overload 2

```cpp showLineNumbers={false}
void holoscan::gxf::GXFComponent::gxf_cname(
    const std::string &name
)
```

### gxf\_graph\_entity \[#gxfgraphentity]

#### Overload 1

```cpp showLineNumbers={false}
std::shared_ptr<nvidia::gxf::GraphEntity> holoscan::gxf::GXFComponent::gxf_graph_entity()
```

#### Overload 2

```cpp showLineNumbers={false}
void holoscan::gxf::GXFComponent::gxf_graph_entity(
    std::shared_ptr<nvidia::gxf::GraphEntity> graph_entity
)
```

### gxf\_entity\_group\_name \[#gxfentitygroupname]

```cpp showLineNumbers={false}
std::string holoscan::gxf::GXFComponent::gxf_entity_group_name()
```

The name of the entity group this component belongs to.

### gxf\_entity\_group\_id \[#gxfentitygroupid]

```cpp showLineNumbers={false}
gxf_uid_t holoscan::gxf::GXFComponent::gxf_entity_group_id()
```

The group id of the entity group this component belongs to.

### gxf\_cptr \[#gxfcptr]

```cpp showLineNumbers={false}
void * holoscan::gxf::GXFComponent::gxf_cptr()
```

### gxf\_component \[#gxfcomponent]

```cpp showLineNumbers={false}
nvidia::gxf::Handle<nvidia::gxf::Component> holoscan::gxf::GXFComponent::gxf_component()
```

### gxf\_initialize \[#gxfinitialize]

```cpp showLineNumbers={false}
void holoscan::gxf::GXFComponent::gxf_initialize()
```

### set\_gxf\_parameter \[#setgxfparameter]

```cpp showLineNumbers={false}
void holoscan::gxf::GXFComponent::set_gxf_parameter(
    const std::string &component_name,
    const std::string &key,
    ParameterWrapper &param_wrap
)
```

Set a given parameter on the underlying GXF component.

### reset\_gxf\_graph\_entity \[#resetgxfgraphentity]

```cpp showLineNumbers={false}
void holoscan::gxf::GXFComponent::reset_gxf_graph_entity()
```

### set\_operator \[#setoperator]

```cpp showLineNumbers={false}
void holoscan::Condition::set_operator(
    Operator *op
)
```

Set the [Operator](operator) this condition is associated with.

**Parameters**

**`op`** `Operator *`

The pointer to the [Operator](operator) object.

---

### update\_params\_from\_args \[#updateparamsfromargs]

#### Update parameters based on the specified arguments

```cpp showLineNumbers={false}
void holoscan::Condition::update_params_from_args()
```

Update parameters based on the specified arguments.

#### Update parameters based on the specified arguments (with params)

```cpp showLineNumbers={false}
void holoscan::ComponentBase::update_params_from_args(
    std::unordered_map<std::string, ParameterWrapper> &params
)
```

Update parameters based on the specified arguments.

### service\_provider \[#serviceprovider]

```cpp showLineNumbers={false}
void holoscan::ComponentBase::service_provider(
    FragmentServiceProvider *provider
)
```

Set the service provider that owns this component.

---

## Static methods

### register\_converter \[#registerconverter]

```cpp showLineNumbers={false}
template <typename typeT>
static void holoscan::ComponentBase::register_converter()
```

Register the argument setter for the given type.

If an operator or resource has an argument with a custom type, the argument setter must be registered using this method.

The argument setter is used to set the value of the argument from the `YAML` configuration.

This method can be called in the initialization phase of the operator/resource (e.g., `initialize()`). The example below shows how to register the argument setter for the custom type (`Vec3`):

It is assumed that `YAML::convert<T>::encode` and `YAML::convert<T>::decode` are implemented for the given type. You need to specialize the `YAML::convert<>` template class.

For example, suppose that you had a `Vec3` class with the following members:

You can define the `YAML::convert<Vec3>` as follows in a '.cpp' file:

Please refer to the [yaml-cpp documentation](https://github.com/jbeder/yaml-cpp/wiki/Tutorial#converting-tofrom-native-data-types) for more details.

**Template parameters**

**`typeT`** `typename`

The type of the argument to register.

---

**Example**

```cpp showLineNumbers={false}
void MyOp::initialize() {
  register_converter<Vec3>();
}
```

**Example**

```cpp showLineNumbers={false}
struct Vec3 {
  // make sure you have overloaded operator==() for the comparison
  double x, y, z;
};
```

**Example**

```cpp showLineNumbers={false}
namespace YAML {
template<>
struct convert<Vec3> {
  static Node encode(const Vec3& rhs) {
    Node node;
    node.push_back(rhs.x);
    node.push_back(rhs.y);
    node.push_back(rhs.z);
    return node;
  }

  static bool decode(const Node& node, Vec3& rhs) {
    if(!node.IsSequence() || node.size() != 3) {
      return false;
    }

    rhs.x = node[0].as<double>();
    rhs.y = node[1].as<double>();
    rhs.z = node[2].as<double>();
    return true;
  }
};
}
```

### register\_argument\_setter \[#registerargumentsetter]

```cpp showLineNumbers={false}
template <typename typeT>
void holoscan::ComponentBase::register_argument_setter()
```

Register the argument setter for the given type.

Please refer to the documentation of `register_converter()` for more details.

**Template parameters**

**`typeT`** `typename`

The type of the argument to register.

---

---

## Types

### ConditionComponentType

[Resource](resource) type used for the initialization of the resource.

| Name      | Value | Description                      |
| --------- | ----- | -------------------------------- |
| `kNative` |       | Native condition.                |
| `kGXF`    |       | GXF condition (scheduling term). |

---

## Member variables

| Name                | Type                                                             | Description                                                       |
| ------------------- | ---------------------------------------------------------------- | ----------------------------------------------------------------- |
| `transmitter_`      | `Parameter< std::shared_ptr< Transmitter > >`                    |                                                                   |
| `min_size_`         | `Parameter< uint64_t >`                                          |                                                                   |
| `is_initialized_`   | `bool`                                                           | Whether the condition is initialized.                             |
| `resources_`        | `std::unordered_map< std::string, std::shared_ptr< Resource > >` | The resources used by the condition.                              |
| `condition_type_`   | `ConditionComponentType`                                         | The type of the component.                                        |
| `op_`               | `Operator *`                                                     | The operator this condition is associated with.                   |
| `wrapper_cid_`      | `int64_t`                                                        | [Component](component) ID of underlying GXFSchedulingTermWrapper. |
| `spec_`             | `std::shared_ptr< ComponentSpec >`                               | The component specification.                                      |
| `id_`               | `int64_t`                                                        | The ID of the component.                                          |
| `name_`             | `std::string`                                                    | Name of the component.                                            |
| `fragment_`         | `Fragment *`                                                     | Pointer to the fragment that owns this component.                 |
| `args_`             | `std::vector< Arg >`                                             | List of arguments.                                                |
| `service_provider_` | `FragmentServiceProvider *`                                      | Pointer to the service provider.                                  |
| `gxf_context_`      | `gxf_context_t`                                                  |                                                                   |
| `gxf_eid_`          | `gxf_uid_t`                                                      |                                                                   |
| `gxf_tid_`          | `gxf_tid_t`                                                      |                                                                   |
| `gxf_cid_`          | `gxf_uid_t`                                                      |                                                                   |
| `gxf_graph_entity_` | `std::shared_ptr< nvidia::gxf::GraphEntity >`                    |                                                                   |
| `gxf_cname_`        | `std::string`                                                    |                                                                   |
| `gxf_component_`    | `nvidia::gxf::Handle< nvidia::gxf::Component >`                  |                                                                   |
| `gxf_cptr_`         | `void *`                                                         |                                                                   |