> This page is for version 3.0 (Latest) (default).
> For other versions, use one of these documentation indexes:
> - 3.0 (Latest) (default): https://docs.nvidia.com/holoscan/sensor-bridge/3-0/llms.txt
> - 2.7: https://docs.nvidia.com/holoscan/sensor-bridge/2-7/llms.txt
> - Archives: https://docs.nvidia.com/holoscan/sensor-bridge/archives/llms.txt

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

# hololink::module::DataChannelInterfaceV1

> Handle to a single data path on an HSB device.

Handle to a single data path on an HSB device.

DataChannel represents the path that sensor or actuator data travels between the host system (usually via RDMA) and the device itself.

* A single HSB device can support any number of DataChannel instances.
* Data producers or consumers use this object to find enumeration metadata provided by the application at construction time. This data is configured by the application per application requirements (e.g. using a specific sensor number or configuration)– enumeration metadata found just by listening to BOOTP messages may not have this application-specific setup.
* Channel specific objects are invalidated when [`device_lost`](#devicelost) is called here, so later calls to get_service will reinitialize these– supporting device reconnection.

```cpp showLineNumbers={false}
#include <hololink/module/data_channel.hpp>
```

## Example

```cpp showLineNumbers={false}
auto& adapter = hololink::module::Adapter::get_adapter();
auto metadata = adapter.wait_for_channel(hololink_ip, discovery_timeout);
auto channel = hololink::module::DataChannelInterfaceV1::get_service(metadata);
// Reach the device this channel runs on.
channel->hololink()->start();
```

**Inherits from:** `hololink::module::ConfigurableService< DataChannelInterfaceV1 >` (public)

---

## Methods

### enumeration_metadata \[#enumerationmetadata]

```cpp showLineNumbers={false}
virtual const EnumerationMetadata & hololink::module::DataChannelInterfaceV1::enumeration_metadata() const
```

The enumeration metadata this channel was configured with.

Every service on this channel is configured from this snapshot.

**Returns:** The metadata describing this channel.

### hololink \[#hololink]

```cpp showLineNumbers={false}
virtual std::shared_ptr<HololinkInterfaceV1> hololink::module::DataChannelInterfaceV1::hololink() const
```

The device this channel runs on.

The same device an application gets by fetching [HololinkInterfaceV1](hololinkinterfacev1) with this channel's enumeration metadata.

**Returns:** The device.

### device_lost \[#devicelost]

```cpp showLineNumbers={false}
virtual hololink_module_status_t hololink::module::DataChannelInterfaceV1::device_lost()
```

Invalidate the services cached for the device this channel runs on, following loss of contact with it.

Does what HololinkInterfaceV1::device_lost() does, for applications that hold a channel and not the device it runs on.

**Returns:** HOLOLINK_MODULE_OK or an error status.

### configure \[#configure]

```cpp showLineNumbers={false}
virtual void hololink::module::ConfigurableService<DataChannelInterfaceV1>::configure(
    const EnumerationMetadata &
)
```

Use `metadata` contents to initialize this instance.

This routine is guaranteed to be called the first time a call to get_service(metadata) is called on a specific service instance.

### module \[#module]

```cpp showLineNumbers={false}
std::shared_ptr<Module> hololink::module::ServiceBase::module() const
```

The [Module](module) that this service was published from.

The service holds no strong reference to its [Module](module), so this does not extend the [Module](module)'s lifetime.

**Returns:** The owning [Module](module), or an empty pointer if the service has not been published or its [Module](module) no longer exists.

---

## Static methods

### get_service \[#getservice]

#### Fetch a service

```cpp showLineNumbers={false}
static std::shared_ptr<DataChannelInterfaceV1> hololink::module::ConfigurableService<DataChannelInterfaceV1>::get_service(
    const EnumerationMetadata &metadata,
    bool allow_null = false
)
```

Fetch a service, configured by [EnumerationMetadata](enumerationmetadata).

[Module](module) usually caches service objects; so when a specific service instance isn't found, it will be constructed with the current values in [EnumerationMetadata](enumerationmetadata). Later calls to get_service are likely to return that cached instance, ignoring changes to any enumeration metadata that aren't specifically related to service addressing.

**Returns:** A shared pointer to the requested service (\<Derived>).

**Throws:** `std::runtime_error` when allow_null==false and the service lookup (or construction) fails.

**Parameters**

**`metadata`** `const EnumerationMetadata &`

Addressing and configuration for the service.

---

**`allow_null`** `bool` — default: false

Use `true` to return nullptr when the service cannot be resolved; the default `false` value raises a std::runtime_error.

---

#### Overload 2

inline

```cpp showLineNumbers={false}
static std::shared_ptr<DataChannelInterfaceV1> hololink::module::Service<DataChannelInterfaceV1>::get_service(
    std::shared_ptr<Module> module,
    const char *instance_id,
    bool allow_null = false
)
```

Type-safe way to fetch a std::shared_ptr to an instance of \<Derived> from a [Module](module).

Note that [Module](module) usually caches instances, it's likely that calls to get_service with the same locator_id will return pointers to the same implementation object.

**Returns:** A shared pointer to the service instance.

**Parameters**

**`module`** `std::shared_ptr<Module>`

Is the shared object that owns the instance we wish to fetch

---

**`instance_id`** `const char *`

Names the specific object, usually expressed as a set of "name=value;..." pairs, as defined by the implementations themselves. This name is normally fetched by calling `Derived::locator_id(enumeration_metadata)`.

---

**`allow_null`** `bool` — default: false

The default value of `false` causes this routine to throw a std::runtime_error if the service cannot be found within the module; this would be expected to terminate the calling program. If the application wants to handle the error, pass in `true` here and get_service will return `nullptr` when this module doesn't provide the requested service.

---

### for_each_type_id \[#foreachtypeid]

```cpp showLineNumbers={false}
static bool hololink::module::Service<DataChannelInterfaceV1>::for_each_type_id(
    Callback &&cb
)
```

Iterate over every type_id supported by this instance.

The callback signature is `bool(const char*)` — returning false halts the walk; true continues. Iteration is depth-first, so you'll see the most specific implementation types first.