rdm_response.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_MESSAGE_TYPES_RDM_RESPONSE_H_
#define RDMNET_CPP_MESSAGE_TYPES_RDM_RESPONSE_H_
 
#include <cstddef>
#include <cstdint>
#include <vector>
#include "etcpal/common.h"
#include "etcpal/cpp/error.h"
#include "etcpal/pack.h"
#include "rdm/cpp/message.h"
#include "rdm/cpp/uid.h"
#include "rdmnet/defs.h"
#include "rdmnet/message.h"
 
namespace rdmnet
{
class SavedRdmResponse;
 
class RdmResponse
{
public:
  RdmResponse() = delete;
  RdmResponse(const RdmResponse& other) = delete;
  RdmResponse& operator=(const RdmResponse& other) = delete;
 
  constexpr RdmResponse(const RdmnetRdmResponse& c_resp) noexcept;
 
  constexpr rdm::Uid rdmnet_source_uid() const noexcept;
  constexpr uint16_t source_endpoint() const noexcept;
  constexpr uint32_t seq_num() const noexcept;
 
  constexpr rdm::Uid           original_cmd_source_uid() const noexcept;
  constexpr rdm::Uid           original_cmd_dest_uid() const noexcept;
  constexpr rdm::CommandHeader original_cmd_header() const noexcept;
  constexpr const uint8_t*     original_cmd_data() const noexcept;
  constexpr uint8_t            original_cmd_data_len() const noexcept;
 
  constexpr rdm::Uid            rdm_source_uid() const noexcept;
  constexpr rdm::Uid            rdm_dest_uid() const noexcept;
  constexpr rdm_response_type_t response_type() const noexcept;
  constexpr uint16_t            subdevice() const noexcept;
  constexpr rdm_command_class_t command_class() const noexcept;
  constexpr uint16_t            param_id() const noexcept;
  constexpr rdm::ResponseHeader rdm_header() const noexcept;
  constexpr const uint8_t*      data() const noexcept;
  constexpr size_t              data_len() const noexcept;
  constexpr bool                more_coming() const noexcept;
 
  constexpr bool OriginalCommandIncluded() const noexcept;
  constexpr bool HasData() const noexcept;
  constexpr bool IsFromDefaultResponder() const noexcept;
  constexpr bool IsResponseToMe() const noexcept;
 
  constexpr bool IsAck() const noexcept;
  constexpr bool IsNack() const noexcept;
 
  constexpr bool IsGetResponse() const noexcept;
  constexpr bool IsSetResponse() const noexcept;
 
  etcpal::Expected<rdm::NackReason> GetNackReason() const noexcept;
  std::vector<uint8_t>              GetData() const;
  std::vector<uint8_t>              GetOriginalCmdData() const;
 
  constexpr const RdmnetRdmResponse& get() const noexcept;
 
  rdm::Command     OriginalCommandToRdm() const;
  rdm::Response    ToRdm() const;
  SavedRdmResponse Save() const;
 
private:
  const RdmnetRdmResponse& resp_;
};
 
class SavedRdmResponse
{
public:
  SavedRdmResponse() = default;
  SavedRdmResponse(const RdmnetSavedRdmResponse& c_resp);
  SavedRdmResponse& operator=(const RdmnetSavedRdmResponse& c_resp);
  SavedRdmResponse(const RdmResponse& resp);
  SavedRdmResponse& operator=(const RdmResponse& resp);
 
  const rdm::Uid& rdmnet_source_uid() const noexcept;
  uint16_t        source_endpoint() const noexcept;
  uint32_t        seq_num() const noexcept;
 
  rdm::Uid                  original_cmd_source_uid() const noexcept;
  rdm::Uid                  original_cmd_dest_uid() const noexcept;
  const rdm::CommandHeader& original_cmd_header() const noexcept;
  const uint8_t*            original_cmd_data() const noexcept;
  uint8_t                   original_cmd_data_len() const noexcept;
  const rdm::Command&       original_cmd() const noexcept;
 
  rdm::Uid                   rdm_source_uid() const noexcept;
  rdm::Uid                   rdm_dest_uid() const noexcept;
  rdm_response_type_t        response_type() const noexcept;
  uint16_t                   subdevice() const noexcept;
  rdm_command_class_t        command_class() const noexcept;
  uint16_t                   param_id() const noexcept;
  const rdm::ResponseHeader& rdm_header() const noexcept;
  const uint8_t*             data() const noexcept;
  size_t                     data_len() const noexcept;
  const rdm::Response&       rdm() const noexcept;
 
  bool IsValid() const noexcept;
  bool OriginalCommandIncluded() const noexcept;
  bool HasData() const noexcept;
  bool IsFromDefaultResponder() const noexcept;
  bool IsResponseToMe() const noexcept;
 
  bool IsAck() const noexcept;
  bool IsNack() const noexcept;
 
  bool IsGetResponse() const noexcept;
  bool IsSetResponse() const noexcept;
 
  etcpal::Expected<rdm::NackReason> GetNackReason() const noexcept;
  std::vector<uint8_t>              GetData() const;
 
  void AppendData(const RdmResponse& new_resp);
  void AppendData(const uint8_t* data, size_t size);
 
private:
  rdm::Uid      rdmnet_source_uid_;
  uint16_t      source_endpoint_{0};
  uint32_t      seq_num_{0};
  bool          is_response_to_me_{false};
  rdm::Command  original_cmd_;
  rdm::Response rdm_;
};
 
// RdmResponse function definitions
 
constexpr RdmResponse::RdmResponse(const RdmnetRdmResponse& c_resp) noexcept : resp_(c_resp)
{
}
 
constexpr rdm::Uid RdmResponse::rdmnet_source_uid() const noexcept
{
  return resp_.rdmnet_source_uid;
}
 
constexpr uint16_t RdmResponse::source_endpoint() const noexcept
{
  return resp_.source_endpoint;
}
 
constexpr uint32_t RdmResponse::seq_num() const noexcept
{
  return resp_.seq_num;
}
 
constexpr rdm::Uid RdmResponse::original_cmd_source_uid() const noexcept
{
  return (OriginalCommandIncluded() ? resp_.original_cmd_header.source_uid : rdm::Uid{});
}
 
constexpr rdm::Uid RdmResponse::original_cmd_dest_uid() const noexcept
{
  return (OriginalCommandIncluded() ? resp_.original_cmd_header.dest_uid : rdm::Uid{});
}
 
constexpr rdm::CommandHeader RdmResponse::original_cmd_header() const noexcept
{
  return (OriginalCommandIncluded() ? resp_.original_cmd_header : rdm::CommandHeader{});
}
 
constexpr const uint8_t* RdmResponse::original_cmd_data() const noexcept
{
  return (OriginalCommandIncluded() ? resp_.original_cmd_data : nullptr);
}
 
constexpr uint8_t RdmResponse::original_cmd_data_len() const noexcept
{
  return (OriginalCommandIncluded() ? resp_.original_cmd_data_len : 0);
}
 
constexpr rdm::Uid RdmResponse::rdm_source_uid() const noexcept
{
  return resp_.rdm_header.source_uid;
}
 
constexpr rdm::Uid RdmResponse::rdm_dest_uid() const noexcept
{
  return resp_.rdm_header.dest_uid;
}
 
constexpr rdm_response_type_t RdmResponse::response_type() const noexcept
{
  return resp_.rdm_header.resp_type;
}
 
constexpr uint16_t RdmResponse::subdevice() const noexcept
{
  return resp_.rdm_header.subdevice;
}
 
constexpr rdm_command_class_t RdmResponse::command_class() const noexcept
{
  return resp_.rdm_header.command_class;
}
 
constexpr uint16_t RdmResponse::param_id() const noexcept
{
  return resp_.rdm_header.param_id;
}
 
constexpr rdm::ResponseHeader RdmResponse::rdm_header() const noexcept
{
  return resp_.rdm_header;
}
 
constexpr const uint8_t* RdmResponse::data() const noexcept
{
  return resp_.rdm_data;
}
 
constexpr size_t RdmResponse::data_len() const noexcept
{
  return resp_.rdm_data_len;
}
 
constexpr bool RdmResponse::more_coming() const noexcept
{
  return resp_.more_coming;
}
 
constexpr bool RdmResponse::OriginalCommandIncluded() const noexcept
{
  return (resp_.seq_num != 0);
}
 
constexpr bool RdmResponse::HasData() const noexcept
{
  return (data_len() != 0);
}
 
constexpr bool RdmResponse::IsFromDefaultResponder() const noexcept
{
  return (resp_.source_endpoint == E133_NULL_ENDPOINT);
}
 
constexpr bool RdmResponse::IsResponseToMe() const noexcept
{
  return resp_.is_response_to_me;
}
 
constexpr bool RdmResponse::IsAck() const noexcept
{
  return (resp_.rdm_header.resp_type == kRdmResponseTypeAck);
}
 
constexpr bool RdmResponse::IsNack() const noexcept
{
  return (resp_.rdm_header.resp_type == kRdmResponseTypeNackReason);
}
 
constexpr bool RdmResponse::IsGetResponse() const noexcept
{
  return (resp_.rdm_header.command_class == kRdmCCGetCommandResponse);
}
 
constexpr bool RdmResponse::IsSetResponse() const noexcept
{
  return (resp_.rdm_header.command_class == kRdmCCSetCommandResponse);
}
 
inline etcpal::Expected<rdm::NackReason> RdmResponse::GetNackReason() const noexcept
{
  if (IsNack() && data_len() >= 2)
    return etcpal_unpack_u16b(data());
  else
    return kEtcPalErrInvalid;
}
 
inline std::vector<uint8_t> RdmResponse::GetData() const
{
  return std::vector<uint8_t>(resp_.rdm_data, resp_.rdm_data + resp_.rdm_data_len);
}
 
inline std::vector<uint8_t> RdmResponse::GetOriginalCmdData() const
{
  return std::vector<uint8_t>(resp_.original_cmd_data, resp_.original_cmd_data + resp_.original_cmd_data_len);
}
 
constexpr const RdmnetRdmResponse& RdmResponse::get() const noexcept
{
  return resp_;
}
 
inline rdm::Command RdmResponse::OriginalCommandToRdm() const
{
  return (OriginalCommandIncluded()
              ? rdm::Command(resp_.original_cmd_header, resp_.original_cmd_data, resp_.original_cmd_data_len)
              : rdm::Command{});
}
 
inline rdm::Response RdmResponse::ToRdm() const
{
  return rdm::Response(resp_.rdm_header, resp_.rdm_data, resp_.rdm_data_len);
}
 
inline SavedRdmResponse RdmResponse::Save() const
{
  return SavedRdmResponse(*this);
}
 
// SavedRdmResponse function definitions
 
inline SavedRdmResponse::SavedRdmResponse(const RdmnetSavedRdmResponse& c_resp)
    : rdmnet_source_uid_(c_resp.rdmnet_source_uid)
    , source_endpoint_(c_resp.source_endpoint)
    , seq_num_(c_resp.seq_num)
    , original_cmd_(c_resp.original_cmd_header, c_resp.original_cmd_data, c_resp.original_cmd_data_len)
    , rdm_(c_resp.rdm_header, c_resp.rdm_data, c_resp.rdm_data_len)
{
}
 
inline SavedRdmResponse& SavedRdmResponse::operator=(const RdmnetSavedRdmResponse& c_resp)
{
  rdmnet_source_uid_ = c_resp.rdmnet_source_uid;
  source_endpoint_ = c_resp.source_endpoint;
  seq_num_ = c_resp.seq_num;
  original_cmd_ = rdm::Command(c_resp.original_cmd_header, c_resp.original_cmd_data, c_resp.original_cmd_data_len);
  rdm_ = rdm::Response(c_resp.rdm_header, c_resp.rdm_data, c_resp.rdm_data_len);
  return *this;
}
 
inline SavedRdmResponse::SavedRdmResponse(const RdmResponse& resp)
    : rdmnet_source_uid_(resp.rdmnet_source_uid())
    , source_endpoint_(resp.source_endpoint())
    , seq_num_(resp.seq_num())
    , original_cmd_(resp.OriginalCommandToRdm())
    , rdm_(resp.ToRdm())
{
}
 
inline SavedRdmResponse& SavedRdmResponse::operator=(const RdmResponse& resp)
{
  rdmnet_source_uid_ = resp.rdmnet_source_uid();
  source_endpoint_ = resp.source_endpoint();
  seq_num_ = resp.seq_num();
  original_cmd_ = resp.OriginalCommandToRdm();
  rdm_ = resp.ToRdm();
  return *this;
}
 
inline const rdm::Uid& SavedRdmResponse::rdmnet_source_uid() const noexcept
{
  return rdmnet_source_uid_;
}
 
inline uint16_t SavedRdmResponse::source_endpoint() const noexcept
{
  return source_endpoint_;
}
 
inline uint32_t SavedRdmResponse::seq_num() const noexcept
{
  return seq_num_;
}
 
inline rdm::Uid SavedRdmResponse::original_cmd_source_uid() const noexcept
{
  return (OriginalCommandIncluded() ? original_cmd_.source_uid() : rdm::Uid{});
}
 
inline rdm::Uid SavedRdmResponse::original_cmd_dest_uid() const noexcept
{
  return (OriginalCommandIncluded() ? original_cmd_.dest_uid() : rdm::Uid{});
}
 
inline const rdm::CommandHeader& SavedRdmResponse::original_cmd_header() const noexcept
{
  return original_cmd_.header();
}
 
inline const uint8_t* SavedRdmResponse::original_cmd_data() const noexcept
{
  return (OriginalCommandIncluded() ? original_cmd_.data() : nullptr);
}
 
inline uint8_t SavedRdmResponse::original_cmd_data_len() const noexcept
{
  return (OriginalCommandIncluded() ? original_cmd_.data_len() : 0);
}
 
inline const rdm::Command& SavedRdmResponse::original_cmd() const noexcept
{
  return original_cmd_;
}
 
inline rdm::Uid SavedRdmResponse::rdm_source_uid() const noexcept
{
  return rdm_.source_uid();
}
 
inline rdm::Uid SavedRdmResponse::rdm_dest_uid() const noexcept
{
  return rdm_.dest_uid();
}
 
inline rdm_response_type_t SavedRdmResponse::response_type() const noexcept
{
  return rdm_.response_type();
}
 
inline uint16_t SavedRdmResponse::subdevice() const noexcept
{
  return rdm_.subdevice();
}
 
inline rdm_command_class_t SavedRdmResponse::command_class() const noexcept
{
  return rdm_.command_class();
}
 
inline uint16_t SavedRdmResponse::param_id() const noexcept
{
  return rdm_.param_id();
}
 
inline const rdm::ResponseHeader& SavedRdmResponse::rdm_header() const noexcept
{
  return rdm_.header();
}
 
inline const uint8_t* SavedRdmResponse::data() const noexcept
{
  return rdm_.data();
}
 
inline size_t SavedRdmResponse::data_len() const noexcept
{
  return rdm_.data_len();
}
 
inline const rdm::Response& SavedRdmResponse::rdm() const noexcept
{
  return rdm_;
}
 
inline bool SavedRdmResponse::IsValid() const noexcept
{
  return rdm_.IsValid();
}
 
inline bool SavedRdmResponse::OriginalCommandIncluded() const noexcept
{
  return (seq_num_ != 0);
}
 
inline bool SavedRdmResponse::HasData() const noexcept
{
  return rdm_.HasData();
}
 
inline bool SavedRdmResponse::IsFromDefaultResponder() const noexcept
{
  return (source_endpoint_ == E133_NULL_ENDPOINT);
}
 
inline bool SavedRdmResponse::IsResponseToMe() const noexcept
{
  return is_response_to_me_;
}
 
inline bool SavedRdmResponse::IsAck() const noexcept
{
  return rdm_.IsAck();
}
 
inline bool SavedRdmResponse::IsNack() const noexcept
{
  return rdm_.IsNack();
}
 
inline bool SavedRdmResponse::IsGetResponse() const noexcept
{
  return rdm_.IsGetResponse();
}
 
inline bool SavedRdmResponse::IsSetResponse() const noexcept
{
  return rdm_.IsSetResponse();
}
 
inline etcpal::Expected<rdm::NackReason> SavedRdmResponse::GetNackReason() const noexcept
{
  return rdm_.GetNackReason();
}
 
inline std::vector<uint8_t> SavedRdmResponse::GetData() const
{
  return rdm_.GetData();
}
 
inline void SavedRdmResponse::AppendData(const RdmResponse& new_resp)
{
  rdm_.AppendData(new_resp.data(), new_resp.data_len());
}
 
inline void SavedRdmResponse::AppendData(const uint8_t* data, size_t data_len)
{
  rdm_.AppendData(data, data_len);
}
};  // namespace rdmnet
 
#endif  // RDMNET_CPP_MESSAGE_TYPES_RDM_RESPONSE_H_