client.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_CLIENT_H_
#define RDMNET_CPP_CLIENT_H_
 
#include <cstdint>
#include "etcpal/cpp/error.h"
#include "etcpal/cpp/inet.h"
#include "etcpal/cpp/opaque_id.h"
#include "etcpal/cpp/uuid.h"
#include "rdm/cpp/uid.h"
#include "rdmnet/client.h"
 
namespace rdmnet
{
 
namespace detail
{
class ScopeHandleType
{
};
};  // namespace detail
 
class SourceAddr
{
public:
  SourceAddr() = default;
  constexpr SourceAddr(uint16_t source_endpoint, const rdm::Uid& rdm_source_uid, uint16_t subdevice = 0) noexcept;
 
  constexpr const RdmnetSourceAddr& get() const noexcept;
 
private:
  RdmnetSourceAddr addr_{};
};
 
constexpr const RdmnetSourceAddr& SourceAddr::get() const noexcept
{
  return addr_;
}
 
constexpr SourceAddr::SourceAddr(uint16_t source_endpoint, const rdm::Uid& rdm_source_uid, uint16_t subdevice) noexcept
    : addr_{source_endpoint, rdm_source_uid.get(), subdevice}
{
}
 
class DestinationAddr
{
public:
  DestinationAddr() = default;
 
  static constexpr DestinationAddr ToDefaultResponder(const rdm::Uid& rdmnet_uid, uint16_t subdevice = 0);
  static constexpr DestinationAddr ToDefaultResponder(uint16_t manufacturer_id,
                                                      uint32_t device_id,
                                                      uint16_t subdevice = 0);
  static constexpr DestinationAddr ToSubResponder(const rdm::Uid& rdmnet_uid,
                                                  uint16_t        endpoint,
                                                  const rdm::Uid& rdm_uid,
                                                  uint16_t        subdevice = 0);
 
  constexpr const RdmnetDestinationAddr& get() const noexcept;
 
private:
  constexpr DestinationAddr(const RdmUid& rdmnet_uid, uint16_t endpoint, const RdmUid& rdm_uid, uint16_t subdevice);
 
  RdmnetDestinationAddr addr_{};
};
 
constexpr DestinationAddr DestinationAddr::ToDefaultResponder(const rdm::Uid& rdmnet_uid, uint16_t subdevice)
{
  return DestinationAddr(rdmnet_uid.get(), E133_NULL_ENDPOINT, rdmnet_uid.get(), subdevice);
}
 
constexpr DestinationAddr DestinationAddr::ToDefaultResponder(uint16_t manufacturer_id,
                                                              uint32_t device_id,
                                                              uint16_t subdevice)
{
  return DestinationAddr({manufacturer_id, device_id}, E133_NULL_ENDPOINT, {manufacturer_id, device_id}, subdevice);
}
 
constexpr DestinationAddr DestinationAddr::ToSubResponder(const rdm::Uid& rdmnet_uid,
                                                          uint16_t        endpoint,
                                                          const rdm::Uid& rdm_uid,
                                                          uint16_t        subdevice)
{
  return DestinationAddr(rdmnet_uid.get(), endpoint, rdm_uid.get(), subdevice);
}
 
constexpr const RdmnetDestinationAddr& DestinationAddr::get() const noexcept
{
  return addr_;
}
 
constexpr DestinationAddr::DestinationAddr(const RdmUid& rdmnet_uid,
                                           uint16_t      endpoint,
                                           const RdmUid& rdm_uid,
                                           uint16_t      subdevice)
    : addr_{rdmnet_uid, endpoint, rdm_uid, subdevice}
{
}
 
class ClientConnectedInfo
{
public:
  ClientConnectedInfo() = delete;
  ClientConnectedInfo(const ClientConnectedInfo& other) = delete;
  ClientConnectedInfo& operator=(const ClientConnectedInfo& other) = delete;
 
  constexpr ClientConnectedInfo(const RdmnetClientConnectedInfo& c_info) noexcept;
 
  constexpr etcpal::SockAddr broker_addr() const noexcept;
  std::string                broker_name() const;
  constexpr const char*      broker_name_c_str() const noexcept;
  constexpr etcpal::Uuid     broker_cid() const noexcept;
  constexpr rdm::Uid         broker_uid() const noexcept;
 
  constexpr const RdmnetClientConnectedInfo& get() const noexcept;
 
private:
  const RdmnetClientConnectedInfo& info_;
};
 
constexpr ClientConnectedInfo::ClientConnectedInfo(const RdmnetClientConnectedInfo& c_info) noexcept : info_(c_info)
{
}
 
constexpr etcpal::SockAddr ClientConnectedInfo::broker_addr() const noexcept
{
  return info_.broker_addr;
}
 
inline std::string ClientConnectedInfo::broker_name() const
{
  return info_.broker_name;
}
 
constexpr const char* ClientConnectedInfo::broker_name_c_str() const noexcept
{
  return info_.broker_name;
}
 
constexpr etcpal::Uuid ClientConnectedInfo::broker_cid() const noexcept
{
  return info_.broker_cid;
}
 
constexpr rdm::Uid ClientConnectedInfo::broker_uid() const noexcept
{
  return info_.broker_uid;
}
 
constexpr const RdmnetClientConnectedInfo& ClientConnectedInfo::get() const noexcept
{
  return info_;
}
 
class ClientConnectFailedInfo
{
public:
  ClientConnectFailedInfo() = delete;
  ClientConnectFailedInfo(const ClientConnectFailedInfo& other) = delete;
  ClientConnectFailedInfo& operator=(const ClientConnectFailedInfo& other) = delete;
 
  constexpr ClientConnectFailedInfo(const RdmnetClientConnectFailedInfo& c_info) noexcept;
 
  constexpr rdmnet_connect_fail_event_t event() const noexcept;
  constexpr etcpal::Error               socket_err() const noexcept;
  constexpr rdmnet_connect_status_t     rdmnet_reason() const noexcept;
  constexpr bool                        will_retry() const noexcept;
 
  constexpr bool HasSocketErr() const noexcept;
  constexpr bool HasRdmnetReason() const noexcept;
 
  const char* EventToCString() const noexcept;
  std::string EventToString() const;
  const char* RdmnetReasonToCString() const noexcept;
  std::string RdmnetReasonToString() const;
 
  constexpr const RdmnetClientConnectFailedInfo& get() const noexcept;
 
private:
  const RdmnetClientConnectFailedInfo& info_;
};
 
constexpr ClientConnectFailedInfo::ClientConnectFailedInfo(const RdmnetClientConnectFailedInfo& c_info) noexcept
    : info_(c_info)
{
}
 
constexpr rdmnet_connect_fail_event_t ClientConnectFailedInfo::event() const noexcept
{
  return info_.event;
}
 
constexpr etcpal::Error ClientConnectFailedInfo::socket_err() const noexcept
{
  return info_.socket_err;
}
 
constexpr rdmnet_connect_status_t ClientConnectFailedInfo::rdmnet_reason() const noexcept
{
  return info_.rdmnet_reason;
}
 
constexpr bool ClientConnectFailedInfo::will_retry() const noexcept
{
  return info_.will_retry;
}
 
constexpr bool ClientConnectFailedInfo::HasSocketErr() const noexcept
{
  return (info_.event == kRdmnetConnectFailSocketFailure || info_.event == kRdmnetConnectFailTcpLevel);
}
 
constexpr bool ClientConnectFailedInfo::HasRdmnetReason() const noexcept
{
  return (info_.event == kRdmnetConnectFailRejected);
}
 
inline const char* ClientConnectFailedInfo::EventToCString() const noexcept
{
  return rdmnet_connect_fail_event_to_string(info_.event);
}
 
inline std::string ClientConnectFailedInfo::EventToString() const
{
  return rdmnet_connect_fail_event_to_string(info_.event);
}
 
inline const char* ClientConnectFailedInfo::RdmnetReasonToCString() const noexcept
{
  return rdmnet_connect_status_to_string(info_.rdmnet_reason);
}
 
inline std::string ClientConnectFailedInfo::RdmnetReasonToString() const
{
  return rdmnet_connect_status_to_string(info_.rdmnet_reason);
}
 
constexpr const RdmnetClientConnectFailedInfo& ClientConnectFailedInfo::get() const noexcept
{
  return info_;
}
 
class ClientDisconnectedInfo
{
public:
  ClientDisconnectedInfo() = delete;
  ClientDisconnectedInfo(const ClientDisconnectedInfo& other) = delete;
  ClientDisconnectedInfo& operator=(const ClientDisconnectedInfo& other) = delete;
 
  constexpr ClientDisconnectedInfo(const RdmnetClientDisconnectedInfo& c_info) noexcept;
 
  constexpr rdmnet_disconnect_event_t  event() const noexcept;
  constexpr etcpal::Error              socket_err() const noexcept;
  constexpr rdmnet_disconnect_reason_t rdmnet_reason() const noexcept;
  constexpr bool                       will_retry() const noexcept;
 
  constexpr bool HasSocketErr() const noexcept;
  constexpr bool HasRdmnetReason() const noexcept;
 
  const char* EventToCString() const noexcept;
  std::string EventToString() const;
  const char* RdmnetReasonToCString() const noexcept;
  std::string RdmnetReasonToString() const;
 
  constexpr const RdmnetClientDisconnectedInfo& get() const noexcept;
 
private:
  const RdmnetClientDisconnectedInfo& info_;
};
 
constexpr ClientDisconnectedInfo::ClientDisconnectedInfo(const RdmnetClientDisconnectedInfo& c_info) noexcept
    : info_(c_info)
{
}
 
constexpr rdmnet_disconnect_event_t ClientDisconnectedInfo::event() const noexcept
{
  return info_.event;
}
 
constexpr etcpal::Error ClientDisconnectedInfo::socket_err() const noexcept
{
  return info_.socket_err;
}
 
constexpr rdmnet_disconnect_reason_t ClientDisconnectedInfo::rdmnet_reason() const noexcept
{
  return info_.rdmnet_reason;
}
 
constexpr bool ClientDisconnectedInfo::will_retry() const noexcept
{
  return info_.will_retry;
}
 
constexpr bool ClientDisconnectedInfo::HasSocketErr() const noexcept
{
  return (info_.event == kRdmnetDisconnectAbruptClose);
}
 
constexpr bool ClientDisconnectedInfo::HasRdmnetReason() const noexcept
{
  return (info_.event == kRdmnetDisconnectGracefulRemoteInitiated);
}
 
inline const char* ClientDisconnectedInfo::EventToCString() const noexcept
{
  return rdmnet_disconnect_event_to_string(info_.event);
}
 
inline std::string ClientDisconnectedInfo::EventToString() const
{
  return rdmnet_disconnect_event_to_string(info_.event);
}
 
inline const char* ClientDisconnectedInfo::RdmnetReasonToCString() const noexcept
{
  return rdmnet_disconnect_reason_to_string(info_.rdmnet_reason);
}
 
inline std::string ClientDisconnectedInfo::RdmnetReasonToString() const
{
  return rdmnet_disconnect_reason_to_string(info_.rdmnet_reason);
}
 
constexpr const RdmnetClientDisconnectedInfo& ClientDisconnectedInfo::get() const noexcept
{
  return info_;
}
 
using ScopeHandle = etcpal::OpaqueId<detail::ScopeHandleType, rdmnet_client_scope_t, RDMNET_CLIENT_SCOPE_INVALID>;
 
constexpr uint16_t kNullEndpoint = E133_NULL_ENDPOINT;
 
class Scope
{
public:
  Scope() = default;
  Scope(const std::string& scope_str, const etcpal::SockAddr& static_broker_addr = etcpal::SockAddr{});
  Scope(const RdmnetScopeConfig& scope_config);
 
  bool                    IsStatic() const noexcept;
  bool                    IsDefault() const noexcept;
  const std::string&      id_string() const noexcept;
  const etcpal::SockAddr& static_broker_addr() const noexcept;
 
  void SetIdString(const std::string& id);
  void SetIdString(const char* id);
  void SetStaticBrokerAddr(const etcpal::SockAddr& static_broker_addr);
 
private:
  std::string      id_{E133_DEFAULT_SCOPE};
  etcpal::SockAddr static_broker_addr_{};
};
 
inline Scope::Scope(const std::string& scope_str, const etcpal::SockAddr& static_broker_addr)
    : id_(scope_str.substr(0, E133_SCOPE_STRING_PADDED_LENGTH - 1)), static_broker_addr_(static_broker_addr)
{
}
 
inline Scope::Scope(const RdmnetScopeConfig& scope_config) : id_(scope_config.scope)
{
  if (!ETCPAL_IP_IS_INVALID(&scope_config.static_broker_addr.ip))
    static_broker_addr_ = scope_config.static_broker_addr;
}
 
inline bool Scope::IsStatic() const noexcept
{
  return static_broker_addr_.IsValid();
}
 
inline bool Scope::IsDefault() const noexcept
{
  return id_ == E133_DEFAULT_SCOPE;
}
 
inline const std::string& Scope::id_string() const noexcept
{
  return id_;
}
 
inline const etcpal::SockAddr& Scope::static_broker_addr() const noexcept
{
  return static_broker_addr_;
}
 
inline void Scope::SetIdString(const std::string& id)
{
  id_ = id;
}
 
inline void Scope::SetIdString(const char* id)
{
  if (id)
  {
    id_ = id;
  }
}
 
inline void Scope::SetStaticBrokerAddr(const etcpal::SockAddr& static_broker_addr)
{
  static_broker_addr_ = static_broker_addr;
}
 
};  // namespace rdmnet
 
#endif  // RDMNET_CPP_CLIENT_H_