holoscan::Clock

Clock resource class using Bridge pattern.

Clock classes are used by a Scheduler to control the flow of time in an application. This class acts as a Resource wrapper around a ClockInterface implementation.

#include <holoscan/clock.hpp>

Inherits from: holoscan::Resource (public)

Constructors

Clock

template <typename ArgT,
          typename... ArgsT,
          typename = std::enable_if_t<!std::is_base_of_v<::holoscan::Resource, 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::Clock::Clock(holoscan::Clock::Clock(
    ArgT &&arg,
    ArgsT &&... args
)

Destructor

~Clock

holoscan::Clock::~Clock() override = defaultholoscan::Clock::~Clock() override = default

Methods

set_clock_impl

void holoscan::Clock::set_clock_impl(
    std::shared_ptr<ClockInterface> clock_impl
)

Set the clock implementation.

clock_impl

std::shared_ptr<ClockInterface> holoscan::Clock::clock_impl() conststd::shared_ptr<ClockInterface> holoscan::Clock::clock_impl() const

Get the clock implementation.

cast_to

template <typename T>
std::shared_ptr<T> holoscan::Clock::cast_to() const

Template method for safe casting to specific clock implementation types.

time

virtual double holoscan::Clock::time() const

The current time of the clock. Time is measured in seconds.

timestamp

virtual int64_t holoscan::Clock::timestamp() const

The current timestamp of the clock. Timestamps are measured in nanoseconds.

sleep_for

virtual void holoscan::Clock::sleep_for(
    int64_t duration_ns
)

sleep_until

virtual void holoscan::Clock::sleep_until(
    int64_t target_time_ns
)

Waits until the given target time.

resource_type

ResourceType holoscan::Clock::resource_type() constResourceType holoscan::Clock::resource_type() const

Get the resource type.

Returns: The resource type.

name

Resource & holoscan::Clock::name(Resource & holoscan::Clock::name(
    const std::string &name
) &

fragment

Resource & holoscan::Clock::fragment(Resource & holoscan::Clock::fragment(
    Fragment *fragment
)

spec

Resource & holoscan::Clock::spec(Resource & holoscan::Clock::spec(
    const std::shared_ptr<ComponentSpec> &spec
)

spec_shared

std::shared_ptr<ComponentSpec> holoscan::Clock::spec_shared()std::shared_ptr<ComponentSpec> holoscan::Clock::spec_shared()

Get the shared pointer to the component spec.

Returns: The shared pointer to the component spec.

setup

virtual void holoscan::Clock::setup(
    ComponentSpec &spec
)

Define the resource specification.

Parameters

initialize

void holoscan::Clock::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.

to_yaml_node

YAML::Node holoscan::Clock::to_yaml_node() const override

Get a YAML representation of the resource.

Returns: YAML node including spec of the resource in addition to the base component properties.

set_parameters

void holoscan::Clock::set_parameters() override

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

id

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.

add_arg

void holoscan::ComponentBase::add_arg(
    const Arg &arg
)

args

std::vector<Arg> & holoscan::ComponentBase::args()

Get the list of arguments.

Returns: The vector of arguments.

description

std::string holoscan::ComponentBase::description() const

Get a description of the component.

Returns: YAML string.

See also: to_yaml_node()

service

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

Parameters

get_service_by_type_info

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

reset_backend_objects

virtual void holoscan::ComponentBase::reset_backend_objects()

Reset any backend-specific objects (e.g. GXF GraphEntity).

update_params_from_args

void holoscan::Clock::update_params_from_args()

service_provider

void holoscan::ComponentBase::service_provider(
    FragmentServiceProvider *provider
)

Set the service provider that owns this component.

Static methods

register_converter

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 for more details.

Template parameters

Example

void MyOp::initialize() {
  register_converter<Vec3>();
}

Example

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

Example

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

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

Types

ResourceType

Resource type used for the initialization of the resource.

Member variables