llrp_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_LLRP_RDM_RESPONSE_H_
#define RDMNET_CPP_MESSAGE_TYPES_LLRP_RDM_RESPONSE_H_
 
#include <cstdint>
#include "etcpal/cpp/error.h"
#include "etcpal/cpp/uuid.h"
#include "rdm/cpp/message.h"
#include "rdm/cpp/uid.h"
#include "rdmnet/message.h"
 
namespace rdmnet
{
namespace llrp
{
class SavedRdmResponse;
 
class RdmResponse
{
public:
  RdmResponse() = delete;
  RdmResponse(const RdmResponse& other) = delete;
  RdmResponse& operator=(const RdmResponse& other) = delete;
 
  constexpr RdmResponse(const LlrpRdmResponse& c_resp) noexcept;
 
  constexpr etcpal::Uuid source_cid() const noexcept;
  constexpr uint32_t     seq_num() const noexcept;
 
  constexpr rdm::Uid            source_uid() const noexcept;
  constexpr rdm::Uid            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 uint8_t             data_len() const noexcept;
 
  constexpr bool HasData() const noexcept;
 
  constexpr bool IsAck() const noexcept;
  constexpr bool IsNack() const noexcept;
 
  constexpr bool IsGetResponse() const noexcept;
  constexpr bool IsSetResponse() const noexcept;
 
  constexpr const LlrpRdmResponse& get() const noexcept;
 
  etcpal::Expected<rdm::NackReason> GetNackReason() const noexcept;
 
  rdm::Response    ToRdm() const;
  SavedRdmResponse Save() const;
 
private:
  const LlrpRdmResponse& resp_;
};
 
class SavedRdmResponse
{
public:
  SavedRdmResponse() = default;
  SavedRdmResponse(const LlrpSavedRdmResponse& c_resp);
  SavedRdmResponse& operator=(const LlrpSavedRdmResponse& c_resp);
  SavedRdmResponse(const RdmResponse& resp);
  SavedRdmResponse& operator=(const RdmResponse& resp);
 
  const etcpal::Uuid& source_cid() const noexcept;
  uint32_t            seq_num() const noexcept;
 
  rdm::Uid                   source_uid() const noexcept;
  rdm::Uid                   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;
  uint8_t                    data_len() const noexcept;
  const rdm::Response&       rdm() const noexcept;
 
  bool IsValid() const noexcept;
  bool HasData() 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;
 
private:
  etcpal::Uuid  source_cid_;
  uint32_t      seq_num_;
  rdm::Response rdm_;
};
 
// llrp::RdmResponse function definitions
 
constexpr RdmResponse::RdmResponse(const LlrpRdmResponse& c_resp) noexcept : resp_(c_resp)
{
}
 
constexpr etcpal::Uuid RdmResponse::source_cid() const noexcept
{
  return resp_.source_cid;
}
 
constexpr uint32_t RdmResponse::seq_num() const noexcept
{
  return resp_.seq_num;
}
 
constexpr rdm::Uid RdmResponse::source_uid() const noexcept
{
  return resp_.rdm_header.source_uid;
}
 
constexpr rdm::Uid RdmResponse::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 uint8_t RdmResponse::data_len() const noexcept
{
  return resp_.rdm_data_len;
}
 
constexpr bool RdmResponse::HasData() const noexcept
{
  return (data_len() != 0);
}
 
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;
}
 
constexpr const LlrpRdmResponse& RdmResponse::get() const noexcept
{
  return resp_;
}
 
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);
}
 
// llrp::SavedRdmResponse function definitions
 
inline SavedRdmResponse::SavedRdmResponse(const LlrpSavedRdmResponse& c_resp)
    : source_cid_(c_resp.source_cid)
    , seq_num_(c_resp.seq_num)
    , rdm_(c_resp.rdm_header, c_resp.rdm_data, c_resp.rdm_data_len)
{
}
 
inline SavedRdmResponse& SavedRdmResponse::operator=(const LlrpSavedRdmResponse& c_resp)
{
  source_cid_ = c_resp.source_cid;
  seq_num_ = c_resp.seq_num;
  rdm_ = rdm::Response(c_resp.rdm_header, c_resp.rdm_data, c_resp.rdm_data_len);
  return *this;
}
 
inline SavedRdmResponse::SavedRdmResponse(const RdmResponse& resp)
    : source_cid_(resp.source_cid()), seq_num_(resp.seq_num()), rdm_(resp.ToRdm())
{
}
 
inline SavedRdmResponse& SavedRdmResponse::operator=(const RdmResponse& resp)
{
  source_cid_ = resp.source_cid();
  seq_num_ = resp.seq_num();
  rdm_ = resp.ToRdm();
  return *this;
}
 
inline const etcpal::Uuid& SavedRdmResponse::source_cid() const noexcept
{
  return source_cid_;
}
 
inline uint32_t SavedRdmResponse::seq_num() const noexcept
{
  return seq_num_;
}
 
inline rdm::Uid SavedRdmResponse::source_uid() const noexcept
{
  return rdm_.source_uid();
}
 
inline rdm::Uid SavedRdmResponse::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 uint8_t SavedRdmResponse::data_len() const noexcept
{
  return static_cast<uint8_t>(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::HasData() const noexcept
{
  return rdm_.HasData();
}
 
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();
}
 
};  // namespace llrp
};  // namespace rdmnet
 
#endif  // RDMNET_CPP_MESSAGE_TYPES_LLRP_RDM_RESPONSE_H_