device.h

Go to the documentation of this file.

/******************************************************************************
 * Copyright 2020 ETC Inc.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *    http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 ******************************************************************************
 * This file is a part of RDMnet. For more information, go to:
 * https://github.com/ETCLabs/RDMnet
 *****************************************************************************/
 
 
#ifndef RDMNET_CPP_DEVICE_H_
#define RDMNET_CPP_DEVICE_H_
 
#include <algorithm>
#include <iterator>
#include <string>
#include <utility>
#include <vector>
#include "etcpal/cpp/common.h"
#include "etcpal/cpp/inet.h"
#include "etcpal/cpp/log.h"
#include "rdm/cpp/uid.h"
#include "rdmnet/device.h"
#include "rdmnet/cpp/common.h"
#include "rdmnet/cpp/client.h"
#include "rdmnet/cpp/message.h"
 
namespace rdmnet
{
 
class VirtualEndpointConfig
{
public:
  VirtualEndpointConfig(uint16_t            id,
                        const etcpal::Uuid* dynamic_responders = nullptr,
                        size_t              num_dynamic_responders = 0);
  VirtualEndpointConfig(uint16_t id, const std::vector<etcpal::Uuid>& dynamic_responders);
  VirtualEndpointConfig(uint16_t            id,
                        const rdm::Uid*     static_responders,
                        size_t              num_static_responders,
                        const etcpal::Uuid* dynamic_responders = nullptr,
                        size_t              num_dynamic_responders = 0);
  VirtualEndpointConfig(uint16_t                         id,
                        const std::vector<rdm::Uid>&     static_responders,
                        const std::vector<etcpal::Uuid>& dynamic_responders = std::vector<etcpal::Uuid>{});
 
  const RdmnetVirtualEndpointConfig& get() const noexcept;
 
private:
  void UpdateConfig();
 
  std::vector<EtcPalUuid>     dynamic_responders_;
  std::vector<RdmUid>         static_responders_;
  RdmnetVirtualEndpointConfig config_;
};
 
inline VirtualEndpointConfig::VirtualEndpointConfig(uint16_t            id,
                                                    const etcpal::Uuid* dynamic_responders,
                                                    size_t              num_dynamic_responders)
    : config_{id, nullptr, 0, nullptr, 0}
{
  if (dynamic_responders && num_dynamic_responders)
  {
    std::transform(dynamic_responders, dynamic_responders + num_dynamic_responders,
                   std::back_inserter(dynamic_responders_), [](const etcpal::Uuid& rid) { return rid.get(); });
  }
  UpdateConfig();
}
 
inline VirtualEndpointConfig::VirtualEndpointConfig(uint16_t id, const std::vector<etcpal::Uuid>& dynamic_responders)
    : config_{id, nullptr, 0, nullptr, 0}
{
  if (!dynamic_responders.empty())
  {
    std::transform(dynamic_responders.begin(), dynamic_responders.end(), std::back_inserter(dynamic_responders_),
                   [](const etcpal::Uuid& rid) { return rid.get(); });
  }
  UpdateConfig();
}
 
inline VirtualEndpointConfig::VirtualEndpointConfig(uint16_t            id,
                                                    const rdm::Uid*     static_responders,
                                                    size_t              num_static_responders,
                                                    const etcpal::Uuid* dynamic_responders,
                                                    size_t              num_dynamic_responders)
    : config_{id, nullptr, 0, nullptr, 0}
{
  if (static_responders && num_static_responders)
  {
    std::transform(static_responders, static_responders + num_static_responders, std::back_inserter(static_responders_),
                   [](const rdm::Uid& uid) { return uid.get(); });
  }
  if (dynamic_responders && num_dynamic_responders)
  {
    std::transform(dynamic_responders, dynamic_responders + num_dynamic_responders,
                   std::back_inserter(dynamic_responders_), [](const etcpal::Uuid& rid) { return rid.get(); });
  }
  UpdateConfig();
}
 
inline VirtualEndpointConfig::VirtualEndpointConfig(uint16_t                         id,
                                                    const std::vector<rdm::Uid>&     static_responders,
                                                    const std::vector<etcpal::Uuid>& dynamic_responders)
    : config_{id, nullptr, 0, nullptr, 0}
{
  if (!static_responders.empty())
  {
    std::transform(static_responders.begin(), static_responders.end(), std::back_inserter(static_responders_),
                   [](const rdm::Uid& uid) { return uid.get(); });
  }
  if (!dynamic_responders.empty())
  {
    std::transform(dynamic_responders.begin(), dynamic_responders.end(), std::back_inserter(dynamic_responders_),
                   [](const etcpal::Uuid& rid) { return rid.get(); });
  }
  UpdateConfig();
}
 
inline const RdmnetVirtualEndpointConfig& VirtualEndpointConfig::get() const noexcept
{
  return config_;
}
 
// Sets the values of the encapsulated config correctly.
inline void VirtualEndpointConfig::UpdateConfig()
{
  if (!static_responders_.empty())
  {
    config_.static_responders = static_responders_.data();
    config_.num_static_responders = static_responders_.size();
  }
  if (!dynamic_responders_.empty())
  {
    config_.dynamic_responders = dynamic_responders_.data();
    config_.num_dynamic_responders = dynamic_responders_.size();
  }
}
 
class PhysicalEndpointResponder
{
public:
  ETCPAL_CONSTEXPR_14 PhysicalEndpointResponder(rdm::Uid uid,
                                                uint16_t control_field,
                                                rdm::Uid binding_uid = rdm::Uid{});
 
  ETCPAL_CONSTEXPR_14 const RdmnetPhysicalEndpointResponder& get() const noexcept;
 
private:
  RdmnetPhysicalEndpointResponder responder_{};
};
 
ETCPAL_CONSTEXPR_14_OR_INLINE PhysicalEndpointResponder::PhysicalEndpointResponder(rdm::Uid uid,
                                                                                   uint16_t control_field,
                                                                                   rdm::Uid binding_uid)
    : responder_{uid.get(), control_field, binding_uid.get()}
{
}
 
ETCPAL_CONSTEXPR_14_OR_INLINE const RdmnetPhysicalEndpointResponder& PhysicalEndpointResponder::get() const noexcept
{
  return responder_;
}
 
class PhysicalEndpointConfig
{
public:
  PhysicalEndpointConfig(uint16_t id, const PhysicalEndpointResponder* responders = nullptr, size_t num_responders = 0);
  PhysicalEndpointConfig(uint16_t id, const std::vector<PhysicalEndpointResponder>& responders);
 
  const RdmnetPhysicalEndpointConfig& get() const noexcept;
 
private:
  void UpdateConfig();
 
  std::vector<RdmnetPhysicalEndpointResponder> responders_;
  RdmnetPhysicalEndpointConfig                 config_;
};
 
inline PhysicalEndpointConfig::PhysicalEndpointConfig(uint16_t                         id,
                                                      const PhysicalEndpointResponder* responders,
                                                      size_t                           num_responders)
    : config_{id, nullptr, 0}
{
  if (responders && num_responders)
  {
    std::transform(responders, responders + num_responders, std::back_inserter(responders_),
                   [](const PhysicalEndpointResponder& resp) { return resp.get(); });
    UpdateConfig();
  }
}
 
inline PhysicalEndpointConfig::PhysicalEndpointConfig(uint16_t                                      id,
                                                      const std::vector<PhysicalEndpointResponder>& responders)
    : config_{id, nullptr, 0}
{
  if (!responders.empty())
  {
    std::transform(responders.begin(), responders.end(), std::back_inserter(responders_),
                   [](const PhysicalEndpointResponder& resp) { return resp.get(); });
    UpdateConfig();
  }
}
 
inline const RdmnetPhysicalEndpointConfig& PhysicalEndpointConfig::get() const noexcept
{
  return config_;
}
 
// Sets the values of the encapsulated config correctly.
inline void PhysicalEndpointConfig::UpdateConfig()
{
  config_.responders = responders_.data();
  config_.num_responders = responders_.size();
}
 
class Device
{
public:
  using Handle = rdmnet_device_t;
  static constexpr Handle kInvalidHandle = RDMNET_DEVICE_INVALID;
 
  class NotifyHandler
  {
  public:
    virtual ~NotifyHandler() = default;
 
    virtual void HandleConnectedToBroker(Handle handle, const ClientConnectedInfo& info) = 0;
 
    virtual void HandleBrokerConnectFailed(Handle handle, const ClientConnectFailedInfo& info) = 0;
 
    virtual void HandleDisconnectedFromBroker(Handle handle, const ClientDisconnectedInfo& info) = 0;
 
    virtual RdmResponseAction HandleRdmCommand(Handle handle, const RdmCommand& cmd) = 0;
 
    virtual RdmResponseAction HandleLlrpRdmCommand(Handle handle, const llrp::RdmCommand& cmd) = 0;
 
    virtual void HandleDynamicUidStatus(Handle handle, const DynamicUidAssignmentList& list)
    {
      ETCPAL_UNUSED_ARG(handle);
      ETCPAL_UNUSED_ARG(list);
    }
  };
 
  struct Settings
  {
    etcpal::Uuid cid;            
    rdm::Uid     uid;            
    std::string  search_domain;  
 
    uint8_t* response_buf{nullptr};
 
    std::vector<VirtualEndpointConfig> virtual_endpoints;
    std::vector<PhysicalEndpointConfig> physical_endpoints;
    std::vector<RdmnetMcastNetintId> llrp_netints;
 
    Settings() = default;
    Settings(const etcpal::Uuid& new_cid, const rdm::Uid& new_uid);
    Settings(const etcpal::Uuid& new_cid, uint16_t manufacturer_id);
 
    bool IsValid() const;
  };
 
  Device() = default;
  Device(const Device& other) = delete;
  Device& operator=(const Device& other) = delete;
  Device(Device&& other) = default;             
  Device& operator=(Device&& other) = default;  
 
  etcpal::Error StartupWithDefaultScope(NotifyHandler&          notify_handler,
                                        const Settings&         settings,
                                        const etcpal::SockAddr& static_broker_addr = etcpal::SockAddr{});
  etcpal::Error Startup(NotifyHandler&          notify_handler,
                        const Settings&         settings,
                        const char*             scope_id_str,
                        const etcpal::SockAddr& static_broker_addr = etcpal::SockAddr{});
  etcpal::Error Startup(NotifyHandler& notify_handler, const Settings& settings, const Scope& scope_config);
  void          Shutdown(rdmnet_disconnect_reason_t disconnect_reason = kRdmnetDisconnectShutdown);
 
  etcpal::Error ChangeScope(const char*                new_scope_id_str,
                            rdmnet_disconnect_reason_t disconnect_reason,
                            const etcpal::SockAddr&    static_broker_addr = etcpal::SockAddr{});
  etcpal::Error ChangeScope(const Scope& new_scope_config, rdmnet_disconnect_reason_t disconnect_reason);
  etcpal::Error ChangeSearchDomain(const char* new_search_domain, rdmnet_disconnect_reason_t disconnect_reason);
 
  etcpal::Error SendRdmAck(const SavedRdmCommand& received_cmd,
                           const uint8_t*         response_data = nullptr,
                           size_t                 response_data_len = 0);
  etcpal::Error SendRdmNack(const SavedRdmCommand& received_cmd, rdm_nack_reason_t nack_reason);
  etcpal::Error SendRdmNack(const SavedRdmCommand& received_cmd, uint16_t raw_nack_reason);
  etcpal::Error SendRdmUpdate(uint16_t param_id, const uint8_t* data = nullptr, size_t data_len = 0);
  etcpal::Error SendRdmUpdate(uint16_t       subdevice,
                              uint16_t       param_id,
                              const uint8_t* data = nullptr,
                              size_t         data_len = 0);
  etcpal::Error SendRdmUpdate(const SourceAddr& source_addr,
                              uint16_t          param_id,
                              const uint8_t*    data = nullptr,
                              size_t            data_len = 0);
  etcpal::Error SendRptStatus(const SavedRdmCommand& received_cmd,
                              rpt_status_code_t      status_code,
                              const char*            status_string = nullptr);
 
  etcpal::Error SendLlrpAck(const llrp::SavedRdmCommand& received_cmd,
                            const uint8_t*               response_data = nullptr,
                            uint8_t                      response_data_len = 0);
  etcpal::Error SendLlrpNack(const llrp::SavedRdmCommand& received_cmd, rdm_nack_reason_t nack_reason);
  etcpal::Error SendLlrpNack(const llrp::SavedRdmCommand& received_cmd, uint16_t raw_nack_reason);
 
  etcpal::Error AddVirtualEndpoint(const VirtualEndpointConfig& endpoint_config);
  etcpal::Error AddVirtualEndpoints(const std::vector<VirtualEndpointConfig>& endpoint_configs);
  etcpal::Error AddPhysicalEndpoint(const PhysicalEndpointConfig& physical_config);
  etcpal::Error AddPhysicalEndpoints(const std::vector<PhysicalEndpointConfig>& endpoint_configs);
  etcpal::Error RemoveEndpoint(uint16_t endpoint_id);
  etcpal::Error RemoveEndpoints(const std::vector<uint16_t>& endpoint_ids);
 
  etcpal::Error AddVirtualResponder(uint16_t endpoint_id, const etcpal::Uuid& responder_id);
  etcpal::Error AddVirtualResponder(uint16_t endpoint_id, const rdm::Uid& responder_static_uid);
  etcpal::Error AddVirtualResponders(uint16_t endpoint_id, const std::vector<etcpal::Uuid>& responder_ids);
  etcpal::Error AddVirtualResponders(uint16_t endpoint_id, const std::vector<rdm::Uid>& responder_static_uids);
  etcpal::Error AddPhysicalResponder(uint16_t        endpoint_id,
                                     const rdm::Uid& responder_uid,
                                     uint16_t        control_field,
                                     const rdm::Uid& binding_uid = rdm::Uid{});
  etcpal::Error AddPhysicalResponder(uint16_t endpoint_id, const PhysicalEndpointResponder& responder);
  etcpal::Error AddPhysicalResponders(uint16_t endpoint_id, const std::vector<PhysicalEndpointResponder>& responders);
  etcpal::Error RemoveVirtualResponder(uint16_t endpoint_id, const etcpal::Uuid& responder_id);
  etcpal::Error RemoveVirtualResponder(uint16_t endpoint_id, const rdm::Uid& responder_static_uid);
  etcpal::Error RemoveVirtualResponders(uint16_t endpoint_id, const std::vector<etcpal::Uuid>& responder_ids);
  etcpal::Error RemoveVirtualResponders(uint16_t endpoint_id, const std::vector<rdm::Uid>& responder_static_uids);
  etcpal::Error RemovePhysicalResponder(uint16_t endpoint_id, const rdm::Uid& responder_uid);
  etcpal::Error RemovePhysicalResponders(uint16_t endpoint_id, const std::vector<rdm::Uid>& responder_uids);
 
  constexpr Handle         handle() const;
  constexpr NotifyHandler* notify_handler() const;
  etcpal::Expected<Scope>  scope() const;
 
private:
  class TranslatedConfig
  {
  public:
    TranslatedConfig(const Settings&         settings,
                     NotifyHandler&          notify_handler,
                     const char*             scope,
                     const etcpal::SockAddr& static_broker_addr);
    const RdmnetDeviceConfig& get() noexcept;
 
  private:
    std::vector<RdmnetPhysicalEndpointConfig> physical_endpoints_;
    std::vector<RdmnetVirtualEndpointConfig>  virtual_endpoints_;
    RdmnetDeviceConfig                        config_;
  };
 
  Handle         handle_{kInvalidHandle};
  NotifyHandler* notify_{nullptr};
};
 
 
namespace internal
{
extern "C" inline void DeviceLibCbConnected(rdmnet_device_t                  handle,
                                            const RdmnetClientConnectedInfo* info,
                                            void*                            context)
{
  if (info && context)
  {
    static_cast<Device::NotifyHandler*>(context)->HandleConnectedToBroker(handle, *info);
  }
}
 
extern "C" inline void DeviceLibCbConnectFailed(rdmnet_device_t                      handle,
                                                const RdmnetClientConnectFailedInfo* info,
                                                void*                                context)
{
  if (info && context)
  {
    static_cast<Device::NotifyHandler*>(context)->HandleBrokerConnectFailed(handle, *info);
  }
}
 
extern "C" inline void DeviceLibCbDisconnected(rdmnet_device_t                     handle,
                                               const RdmnetClientDisconnectedInfo* info,
                                               void*                               context)
{
  if (info && context)
  {
    static_cast<Device::NotifyHandler*>(context)->HandleDisconnectedFromBroker(handle, *info);
  }
}
 
extern "C" inline void DeviceLibCbRdmCommandReceived(rdmnet_device_t         handle,
                                                     const RdmnetRdmCommand* cmd,
                                                     RdmnetSyncRdmResponse*  response,
                                                     void*                   context)
{
  if (cmd && context)
  {
    *response = static_cast<Device::NotifyHandler*>(context)->HandleRdmCommand(handle, *cmd).get();
  }
}
 
extern "C" inline void DeviceLibCbLlrpRdmCommandReceived(rdmnet_device_t        handle,
                                                         const LlrpRdmCommand*  cmd,
                                                         RdmnetSyncRdmResponse* response,
                                                         void*                  context)
{
  if (cmd && context)
  {
    *response = static_cast<Device::NotifyHandler*>(context)->HandleLlrpRdmCommand(handle, *cmd).get();
  }
}
 
extern "C" inline void DeviceLibCbDynamicUidStatus(rdmnet_device_t                       handle,
                                                   const RdmnetDynamicUidAssignmentList* list,
                                                   void*                                 context)
{
  if (list && context)
  {
    static_cast<Device::NotifyHandler*>(context)->HandleDynamicUidStatus(handle, *list);
  }
}
 
};  // namespace internal
 
 
inline Device::Settings::Settings(const etcpal::Uuid& new_cid, const rdm::Uid& new_uid) : cid(new_cid), uid(new_uid)
{
}
 
inline Device::Settings::Settings(const etcpal::Uuid& cid_in, uint16_t manufacturer_id)
    : cid(cid_in), uid(rdm::Uid::DynamicUidRequest(manufacturer_id))
{
}
 
inline bool Device::Settings::IsValid() const
{
  return (!cid.IsNull() && (uid.IsStatic() || uid.IsDynamicUidRequest()));
}
 
inline etcpal::Error Device::StartupWithDefaultScope(NotifyHandler&          notify_handler,
                                                     const Settings&         settings,
                                                     const etcpal::SockAddr& static_broker_addr)
{
  TranslatedConfig config(settings, notify_handler, E133_DEFAULT_SCOPE, static_broker_addr);
  return rdmnet_device_create(&config.get(), &handle_);
}
 
inline etcpal::Error Device::Startup(NotifyHandler&          notify_handler,
                                     const Settings&         settings,
                                     const char*             scope_id_str,
                                     const etcpal::SockAddr& static_broker_addr)
{
  TranslatedConfig config(settings, notify_handler, scope_id_str, static_broker_addr);
  return rdmnet_device_create(&config.get(), &handle_);
}
 
inline etcpal::Error Device::Startup(NotifyHandler& notify_handler, const Settings& settings, const Scope& scope_config)
{
  TranslatedConfig config(settings, notify_handler, scope_config.id_string().c_str(),
                          scope_config.static_broker_addr());
  return rdmnet_device_create(&config.get(), &handle_);
}
 
inline void Device::Shutdown(rdmnet_disconnect_reason_t disconnect_reason)
{
  rdmnet_device_destroy(handle_, disconnect_reason);
  handle_ = kInvalidHandle;
}
 
inline etcpal::Error Device::ChangeScope(const char*                new_scope_id_str,
                                         rdmnet_disconnect_reason_t disconnect_reason,
                                         const etcpal::SockAddr&    static_broker_addr)
{
  RdmnetScopeConfig new_scope_config = {new_scope_id_str, static_broker_addr.get()};
  return rdmnet_device_change_scope(handle_, &new_scope_config, disconnect_reason);
}
 
inline etcpal::Error Device::ChangeScope(const Scope& new_scope_config, rdmnet_disconnect_reason_t disconnect_reason)
{
  RdmnetScopeConfig translated_config = {new_scope_config.id_string().c_str(),
                                         new_scope_config.static_broker_addr().get()};
  return rdmnet_device_change_scope(handle_, &translated_config, disconnect_reason);
}
 
inline etcpal::Error Device::ChangeSearchDomain(const char*                new_search_domain,
                                                rdmnet_disconnect_reason_t disconnect_reason)
{
  return rdmnet_device_change_search_domain(handle_, new_search_domain, disconnect_reason);
}
 
inline etcpal::Error Device::SendRdmAck(const SavedRdmCommand& received_cmd,
                                        const uint8_t*         response_data,
                                        size_t                 response_data_len)
{
  return rdmnet_device_send_rdm_ack(handle_, &received_cmd.get(), response_data, response_data_len);
}
 
inline etcpal::Error Device::SendRdmNack(const SavedRdmCommand& received_cmd, rdm_nack_reason_t nack_reason)
{
  return rdmnet_device_send_rdm_nack(handle_, &received_cmd.get(), nack_reason);
}
 
inline etcpal::Error Device::SendRdmNack(const SavedRdmCommand& received_cmd, uint16_t raw_nack_reason)
{
  return rdmnet_device_send_rdm_nack(handle_, &received_cmd.get(), static_cast<rdm_nack_reason_t>(raw_nack_reason));
}
 
inline etcpal::Error Device::SendRdmUpdate(uint16_t param_id, const uint8_t* data, size_t data_len)
{
  return rdmnet_device_send_rdm_update(handle_, 0, param_id, data, data_len);
}
 
inline etcpal::Error Device::SendRdmUpdate(uint16_t subdevice, uint16_t param_id, const uint8_t* data, size_t data_len)
{
  return rdmnet_device_send_rdm_update(handle_, subdevice, param_id, data, data_len);
}
 
inline etcpal::Error Device::SendRdmUpdate(const SourceAddr& source_addr,
                                           uint16_t          param_id,
                                           const uint8_t*    data,
                                           size_t            data_len)
{
  return rdmnet_device_send_rdm_update_from_responder(handle_, &source_addr.get(), param_id, data, data_len);
}
 
inline etcpal::Error Device::SendRptStatus(const SavedRdmCommand& received_cmd,
                                           rpt_status_code_t      status_code,
                                           const char*            status_string)
{
  return rdmnet_device_send_status(handle_, &received_cmd.get(), status_code, status_string);
}
 
inline etcpal::Error Device::SendLlrpAck(const llrp::SavedRdmCommand& received_cmd,
                                         const uint8_t*               response_data,
                                         uint8_t                      response_data_len)
{
  return rdmnet_device_send_llrp_ack(handle_, &received_cmd.get(), response_data, response_data_len);
}
 
inline etcpal::Error Device::SendLlrpNack(const llrp::SavedRdmCommand& received_cmd, rdm_nack_reason_t nack_reason)
{
  return rdmnet_device_send_llrp_nack(handle_, &received_cmd.get(), nack_reason);
}
 
inline etcpal::Error Device::SendLlrpNack(const llrp::SavedRdmCommand& received_cmd, uint16_t raw_nack_reason)
{
  return rdmnet_device_send_llrp_nack(handle_, &received_cmd.get(), static_cast<rdm_nack_reason_t>(raw_nack_reason));
}
 
inline etcpal::Error Device::AddVirtualEndpoint(const VirtualEndpointConfig& endpoint_config)
{
  return rdmnet_device_add_virtual_endpoint(handle_, &endpoint_config.get());
}
 
inline etcpal::Error Device::AddVirtualEndpoints(const std::vector<VirtualEndpointConfig>& endpoint_configs)
{
  if (endpoint_configs.empty())
    return kEtcPalErrInvalid;
 
  std::vector<RdmnetVirtualEndpointConfig> virtual_endpts;
  virtual_endpts.reserve(endpoint_configs.size());
  std::transform(endpoint_configs.begin(), endpoint_configs.end(), std::back_inserter(virtual_endpts),
                 [](const VirtualEndpointConfig& config) { return config.get(); });
 
  return rdmnet_device_add_virtual_endpoints(handle_, virtual_endpts.data(), virtual_endpts.size());
}
 
inline etcpal::Error Device::AddPhysicalEndpoint(const PhysicalEndpointConfig& endpoint_config)
{
  return rdmnet_device_add_physical_endpoint(handle_, &endpoint_config.get());
}
 
inline etcpal::Error Device::AddPhysicalEndpoints(const std::vector<PhysicalEndpointConfig>& endpoint_configs)
{
  if (endpoint_configs.empty())
    return kEtcPalErrInvalid;
 
  std::vector<RdmnetPhysicalEndpointConfig> physical_endpts;
  physical_endpts.reserve(endpoint_configs.size());
  std::transform(endpoint_configs.begin(), endpoint_configs.end(), std::back_inserter(physical_endpts),
                 [](const PhysicalEndpointConfig& config) { return config.get(); });
 
  return rdmnet_device_add_physical_endpoints(handle_, physical_endpts.data(), physical_endpts.size());
}
 
inline etcpal::Error Device::RemoveEndpoint(uint16_t endpoint_id)
{
  return rdmnet_device_remove_endpoint(handle_, endpoint_id);
}
 
inline etcpal::Error Device::RemoveEndpoints(const std::vector<uint16_t>& endpoint_ids)
{
  if (endpoint_ids.empty())
    return kEtcPalErrInvalid;
 
  return rdmnet_device_remove_endpoints(handle_, endpoint_ids.data(), endpoint_ids.size());
}
 
inline etcpal::Error Device::AddVirtualResponder(uint16_t endpoint_id, const etcpal::Uuid& responder_id)
{
  return rdmnet_device_add_dynamic_responders(handle_, endpoint_id, &responder_id.get(), 1);
}
 
inline etcpal::Error Device::AddVirtualResponder(uint16_t endpoint_id, const rdm::Uid& responder_static_uid)
{
  return rdmnet_device_add_static_responders(handle_, endpoint_id, &responder_static_uid.get(), 1);
}
 
inline etcpal::Error Device::AddVirtualResponders(uint16_t endpoint_id, const std::vector<etcpal::Uuid>& responder_ids)
{
  if (responder_ids.empty())
    return kEtcPalErrInvalid;
 
  std::vector<EtcPalUuid> ids;
  ids.reserve(responder_ids.size());
  std::transform(responder_ids.begin(), responder_ids.end(), std::back_inserter(ids),
                 [](const etcpal::Uuid& id) { return id.get(); });
 
  return rdmnet_device_add_dynamic_responders(handle_, endpoint_id, ids.data(), ids.size());
}
 
inline etcpal::Error Device::AddVirtualResponders(uint16_t                     endpoint_id,
                                                  const std::vector<rdm::Uid>& responder_static_uids)
{
  if (responder_static_uids.empty())
    return kEtcPalErrInvalid;
 
  std::vector<RdmUid> uids;
  uids.reserve(responder_static_uids.size());
  std::transform(responder_static_uids.begin(), responder_static_uids.end(), std::back_inserter(uids),
                 [](const rdm::Uid& uid) { return uid.get(); });
 
  return rdmnet_device_add_static_responders(handle_, endpoint_id, uids.data(), uids.size());
}
 
inline etcpal::Error Device::AddPhysicalResponder(uint16_t        endpoint_id,
                                                  const rdm::Uid& responder_uid,
                                                  uint16_t        control_field,
                                                  const rdm::Uid& binding_uid)
{
  RdmnetPhysicalEndpointResponder responder = {responder_uid.get(), control_field, binding_uid.get()};
  return rdmnet_device_add_physical_responders(handle_, endpoint_id, &responder, 1);
}
 
inline etcpal::Error Device::AddPhysicalResponder(uint16_t endpoint_id, const PhysicalEndpointResponder& responder)
{
  return rdmnet_device_add_physical_responders(handle_, endpoint_id, &responder.get(), 1);
}
 
inline etcpal::Error Device::AddPhysicalResponders(uint16_t                                      endpoint_id,
                                                   const std::vector<PhysicalEndpointResponder>& responders)
{
  if (responders.empty())
    return kEtcPalErrInvalid;
 
  std::vector<RdmnetPhysicalEndpointResponder> resps;
  resps.reserve(responders.size());
  std::transform(responders.begin(), responders.end(), std::back_inserter(resps),
                 [](const PhysicalEndpointResponder& responder) { return responder.get(); });
 
  return rdmnet_device_add_physical_responders(handle_, endpoint_id, resps.data(), resps.size());
}
 
inline etcpal::Error Device::RemoveVirtualResponder(uint16_t endpoint_id, const etcpal::Uuid& responder_id)
{
  return rdmnet_device_remove_dynamic_responders(handle_, endpoint_id, &responder_id.get(), 1);
}
 
inline etcpal::Error Device::RemoveVirtualResponder(uint16_t endpoint_id, const rdm::Uid& responder_static_uid)
{
  return rdmnet_device_remove_static_responders(handle_, endpoint_id, &responder_static_uid.get(), 1);
}
 
inline etcpal::Error Device::RemoveVirtualResponders(uint16_t                         endpoint_id,
                                                     const std::vector<etcpal::Uuid>& responder_ids)
{
  if (responder_ids.empty())
    return kEtcPalErrInvalid;
 
  std::vector<EtcPalUuid> ids;
  ids.reserve(responder_ids.size());
  std::transform(responder_ids.begin(), responder_ids.end(), std::back_inserter(ids),
                 [](const etcpal::Uuid& id) { return id.get(); });
 
  return rdmnet_device_remove_dynamic_responders(handle_, endpoint_id, ids.data(), ids.size());
}
 
inline etcpal::Error Device::RemoveVirtualResponders(uint16_t                     endpoint_id,
                                                     const std::vector<rdm::Uid>& responder_static_uids)
{
  if (responder_static_uids.empty())
    return kEtcPalErrInvalid;
 
  std::vector<RdmUid> uids;
  uids.reserve(responder_static_uids.size());
  std::transform(responder_static_uids.begin(), responder_static_uids.end(), std::back_inserter(uids),
                 [](const rdm::Uid& uid) { return uid.get(); });
 
  return rdmnet_device_remove_static_responders(handle_, endpoint_id, uids.data(), uids.size());
}
 
inline etcpal::Error Device::RemovePhysicalResponder(uint16_t endpoint_id, const rdm::Uid& responder_uid)
{
  return rdmnet_device_remove_physical_responders(handle_, endpoint_id, &responder_uid.get(), 1);
}
 
inline etcpal::Error Device::RemovePhysicalResponders(uint16_t endpoint_id, const std::vector<rdm::Uid>& responder_uids)
{
  if (responder_uids.empty())
    return kEtcPalErrInvalid;
 
  std::vector<RdmUid> uids;
  uids.reserve(responder_uids.size());
  std::transform(responder_uids.begin(), responder_uids.end(), std::back_inserter(uids),
                 [](const rdm::Uid& uid) { return uid.get(); });
 
  return rdmnet_device_remove_physical_responders(handle_, endpoint_id, uids.data(), uids.size());
}
 
constexpr Device::Handle Device::handle() const
{
  return handle_;
}
 
constexpr Device::NotifyHandler* Device::notify_handler() const
{
  return notify_;
}
 
inline etcpal::Expected<Scope> Device::scope() const
{
  std::string    scope_id(E133_SCOPE_STRING_PADDED_LENGTH, 0);
  EtcPalSockAddr static_broker_addr;
  etcpal_error_t res = rdmnet_device_get_scope(handle_, &scope_id[0], &static_broker_addr);
  if (res == kEtcPalErrOk)
    return Scope(scope_id, static_broker_addr);
  else
    return res;
}
 
inline const RdmnetDeviceConfig& Device::TranslatedConfig::get() noexcept
{
  if (!physical_endpoints_.empty())
  {
    config_.physical_endpoints = physical_endpoints_.data();
    config_.num_physical_endpoints = physical_endpoints_.size();
  }
  if (!virtual_endpoints_.empty())
  {
    config_.virtual_endpoints = virtual_endpoints_.data();
    config_.num_virtual_endpoints = virtual_endpoints_.size();
  }
  return config_;
}
 
// clang-format off
inline Device::TranslatedConfig::TranslatedConfig(const Settings&         settings,
                                                  NotifyHandler&          notify_handler,
                                                  const char*             scope,
                                                  const etcpal::SockAddr& static_broker_addr)
  : config_{
      settings.cid.get(),
      {
        ::rdmnet::internal::DeviceLibCbConnected,
        ::rdmnet::internal::DeviceLibCbConnectFailed,
        ::rdmnet::internal::DeviceLibCbDisconnected,
        ::rdmnet::internal::DeviceLibCbRdmCommandReceived,
        ::rdmnet::internal::DeviceLibCbLlrpRdmCommandReceived,
        ::rdmnet::internal::DeviceLibCbDynamicUidStatus,
        &notify_handler
      },
      settings.response_buf,
      {
        scope,
        static_broker_addr.get()
      },
      settings.uid.get(),
      settings.search_domain.c_str(),
      nullptr,
      0,
      nullptr,
      0,
      nullptr,
      0
    }
{
  // clang-format on
 
  // Physical endpoints
  if (!settings.physical_endpoints.empty())
  {
    physical_endpoints_.reserve(settings.physical_endpoints.size());
    std::transform(settings.physical_endpoints.begin(), settings.physical_endpoints.end(),
                   std::back_inserter(physical_endpoints_),
                   [](const PhysicalEndpointConfig& config) { return config.get(); });
  }
 
  // Virtual endpoints
  if (!settings.virtual_endpoints.empty())
  {
    virtual_endpoints_.reserve(settings.virtual_endpoints.size());
    std::transform(settings.virtual_endpoints.begin(), settings.virtual_endpoints.end(),
                   std::back_inserter(virtual_endpoints_),
                   [](const VirtualEndpointConfig& config) { return config.get(); });
  }
 
  // LLRP network interfaces
  if (!settings.llrp_netints.empty())
  {
    config_.llrp_netints = settings.llrp_netints.data();
    config_.num_llrp_netints = settings.llrp_netints.size();
  }
}
 
};  // namespace rdmnet
 
#endif  // RDMNET_CPP_DEVICE_H_