DeviceGroup.hpp

Go to the documentation of this file.

// Copyright (c) 2026 EduArt Robotik GmbH

 
#pragma once
 
#include <chrono>
#include <functional>
#include <future>
#include <vector>
 
#include "sensorring/platform/SensorringExport.hpp"
 
#include "IDevice.hpp"
 
namespace eduart {
 
namespace device {

class SENSORRING_EXPORT DeviceGroup {
 
public:
  DeviceGroup(std::vector<device::IDevice*> devices);

  ~DeviceGroup() = default;

  std::vector<device::IDevice*> getDevices() const;

  unsigned int getDeviceCount() const;

  template <typename Response, typename Predicate> static bool waitForAll(std::vector<std::future<Response> >& futures, std::chrono::steady_clock::duration timeout, Predicate&& success_predicate) noexcept;

  void invokeForEachDevice(std::function<void(device::IDevice*)> callback) const;

  template <typename T> std::vector<T*> getDevicesOfType() const;

  template <typename T> void invokeForEachDeviceOfType(std::function<void(T*)> callback) const;

  template <typename T> static DeviceGroup createFromDevicesOfType(std::vector<device::IDevice*> devices);
 
private:
  std::vector<device::IDevice*> _devices;
};
 
// Template implementations
template <typename T> std::vector<T*> DeviceGroup::getDevicesOfType() const {
  std::vector<T*> devices;
  for (auto& device : _devices) {
    if (auto* cast = dynamic_cast<T*>(device)) {
      devices.push_back(cast);
    }
  }
  return devices;
}
 
template <typename T> void DeviceGroup::invokeForEachDeviceOfType(std::function<void(T*)> callback) const {
  for (auto& device : _devices) {
    if (auto* cast = dynamic_cast<T*>(device)) {
      callback(cast);
    }
  }
}
 
template <typename T> DeviceGroup DeviceGroup::createFromDevicesOfType(std::vector<device::IDevice*> devices) {
  std::vector<device::IDevice*> filtered;
  for (auto& device : devices) {
    if (dynamic_cast<T*>(device)) {
      filtered.push_back(device);
    }
  }
  return DeviceGroup(std::move(filtered));
}
 
template <typename Response, typename Predicate> bool DeviceGroup::waitForAll(std::vector<std::future<Response> >& futures, std::chrono::steady_clock::duration timeout, Predicate&& success_predicate) noexcept {
  if (futures.empty())
    return true;
  const auto deadline = std::chrono::steady_clock::now() + timeout;
 
  // First, wait for all futures to become ready (or until timeout).
  for (auto& fut : futures) {
    if (fut.wait_until(deadline) != std::future_status::ready) {
      return false; // At least one future did not complete in time.
    }
  }
 
  // Then, consume results and apply the predicate.
  bool all_ok = true;
  for (auto& fut : futures) {
    if (!success_predicate(fut.get())) {
      all_ok = false;
    }
  }
  return all_ok;
}
 
} // namespace device
 
} // namespace eduart