> 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::MessageAvailableCondition

> Condition class that allows an operator to execute only when one or more messages are available on a given input port.

[Condition](condition) class that allows an operator to execute only when one or more messages are available on a given input port.

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

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

\==Parameters==

* **min\_size** (uint64\_t): The minimum number of messages that must be available on the input port before the operator will be considered READY.
* **front\_stage\_max\_size** (size\_t): If set, the condition will only allow execution if the number of messages in the front stage of the receiver's double-buffer queue does not exceed this count. In most cases, this parameter does not need to be set.
* **receiver** (std::string): The receiver whose message queue will be checked. This should be specified by the name of the [Operator](operator)'s input port the condition will apply to. The Holoscan SDK will then automatically replace the port name with the actual receiver object at application run time.

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

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

***

## Constructors

### MessageAvailableCondition \[#messageavailablecondition]

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::MessageAvailableCondition::MessageAvailableCondition(
    ArgT &&arg,
    ArgsT &&... args
)
```

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

inline

explicit

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

inline

```cpp showLineNumbers={false}
holoscan::MessageAvailableCondition::MessageAvailableCondition(
    size_t min_size,
    size_t front_stage_max_size
)
```

***

## Methods

### gxf\_typename \[#gxftypename]

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

### receiver \[#receiver]

inline

```cpp showLineNumbers={false}
void holoscan::MessageAvailableCondition::receiver(
    std::shared_ptr<Receiver> receiver
)
```

inline

const

```cpp showLineNumbers={false}
std::shared_ptr<Receiver> holoscan::MessageAvailableCondition::receiver() const
```

```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**

The name of the input port.

### min\_size \[#minsize]

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

inline

const

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

### front\_stage\_max\_size \[#frontstagemaxsize]

```cpp showLineNumbers={false}
void holoscan::MessageAvailableCondition::front_stage_max_size(
    size_t front_stage_max_size
)
```

inline

const

```cpp showLineNumbers={false}
size_t holoscan::MessageAvailableCondition::front_stage_max_size() const
```

### setup \[#setup]

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

Define the condition specification.

**Parameters**

The reference to the component specification.

### initialize \[#initialize]

```cpp showLineNumbers={false}
void holoscan::MessageAvailableCondition::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::MessageAvailableSchedulingTerm * holoscan::MessageAvailableCondition::get() const
```

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

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

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

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

```cpp showLineNumbers={false}
YAML::Node holoscan::MessageAvailableCondition::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::MessageAvailableCondition::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**

The current timestamp

The status of the condition

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

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

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]

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

Set the name of the condition.

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

**Parameters**

The name of the condition.

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

Set the name of the condition.

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

**Parameters**

The name of the condition.

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]

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

Set the fragment of the condition.

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

**Parameters**

The pointer to the fragment of the condition.

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

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

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

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]

```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**

The component specification.

```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]

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

Add a resource to the condition.

**Parameters**

The resource to add.

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

Add a resource to the condition.

**Parameters**

The resource to add.

inline

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

Add an argument to the component.

**Parameters**

The argument to add.

inline

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

Add an argument to the component.

**Parameters**

The argument to add.

inline

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

Add a list of arguments to the component.

**Parameters**

The list of arguments to add.

inline

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

Add a list of arguments to the component.

**Parameters**

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.

### transmitter \[#transmitter]

```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**

The name of the output port.

### wrapper\_cid \[#wrappercid]

```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**

Component id corresponding to the underlying framework

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

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

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

The type info of the service/resource to retrieve.

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

### gxf\_context \[#gxfcontext]

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

const

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

### gxf\_eid \[#gxfeid]

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

const

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

### gxf\_tid \[#gxftid]

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

const

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

### gxf\_cid \[#gxfcid]

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

const

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

### gxf\_cname \[#gxfcname]

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

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

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

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

```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**

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

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

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

Update parameters based on the specified arguments.

```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**

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

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                                                       |
| ----------------------- | ---------------------------------------------------------------- | ----------------------------------------------------------------- |
| `receiver_`             | `Parameter< std::shared_ptr< Receiver > >`                       |                                                                   |
| `min_size_`             | `Parameter< uint64_t >`                                          |                                                                   |
| `front_stage_max_size_` | `Parameter< size_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 *`                                                         |                                                                   |