common.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_COMMON_H_
#define RDMNET_CPP_COMMON_H_
 
 
#include "etcpal/cpp/error.h"
#include "etcpal/cpp/log.h"
#include "rdmnet/common.h"
 
 
 
namespace rdmnet
{
enum class McastMode
{
  kEnabledOnAllInterfaces,
  kDisabledOnAllInterfaces
};
 
inline etcpal::Error Init(const EtcPalLogParams*                  log_params = nullptr,
                          const std::vector<EtcPalMcastNetintId>& mcast_netints = std::vector<EtcPalMcastNetintId>{})
{
  if (mcast_netints.empty())
  {
    return rdmnet_init(log_params, nullptr);
  }
  else
  {
    RdmnetNetintConfig config = {mcast_netints.data(), mcast_netints.size(), false};
    return rdmnet_init(log_params, &config);
  }
}
 
inline etcpal::Error Init(const etcpal::Logger&                   logger,
                          const std::vector<EtcPalMcastNetintId>& mcast_netints = std::vector<EtcPalMcastNetintId>{})
{
  if (mcast_netints.empty())
  {
    return rdmnet_init(&logger.log_params(), nullptr);
  }
  else
  {
    RdmnetNetintConfig config = {mcast_netints.data(), mcast_netints.size(), false};
    return rdmnet_init(&logger.log_params(), &config);
  }
}
 
inline etcpal::Error Init(const EtcPalLogParams* log_params, McastMode mcast_mode)
{
  RdmnetNetintConfig config = {nullptr, 0u, (mcast_mode == McastMode::kDisabledOnAllInterfaces)};
  return rdmnet_init(log_params, &config);
}
 
inline etcpal::Error Init(const etcpal::Logger& logger, McastMode mcast_mode)
{
  RdmnetNetintConfig config = {nullptr, 0u, (mcast_mode == McastMode::kDisabledOnAllInterfaces)};
  return rdmnet_init(&logger.log_params(), &config);
}
 
inline void Deinit()
{
  return rdmnet_deinit();
}
 
class RdmResponseAction
{
public:
  static RdmResponseAction SendAck(size_t response_data_len = 0);
  static RdmResponseAction SendNack(rdm_nack_reason_t nack_reason);
  static RdmResponseAction SendNack(uint16_t raw_nack_reason);
  static RdmResponseAction DeferResponse();
  static RdmResponseAction RetryLater();
 
  constexpr const RdmnetSyncRdmResponse& get() const;
 
private:
  RdmnetSyncRdmResponse response_;
};
 
inline RdmResponseAction RdmResponseAction::SendAck(size_t response_data_len)
{
  RdmResponseAction to_return;
  RDMNET_SYNC_SEND_RDM_ACK(&to_return.response_, response_data_len);
  return to_return;
}
 
inline RdmResponseAction RdmResponseAction::SendNack(rdm_nack_reason_t nack_reason)
{
  RdmResponseAction to_return;
  RDMNET_SYNC_SEND_RDM_NACK(&to_return.response_, nack_reason);
  return to_return;
}
 
inline RdmResponseAction RdmResponseAction::SendNack(uint16_t raw_nack_reason)
{
  RdmResponseAction to_return;
  RDMNET_SYNC_SEND_RDM_NACK(&to_return.response_, static_cast<rdm_nack_reason_t>(raw_nack_reason));
  return to_return;
}
 
inline RdmResponseAction RdmResponseAction::DeferResponse()
{
  RdmResponseAction to_return;
  RDMNET_SYNC_DEFER_RDM_RESPONSE(&to_return.response_);
  return to_return;
}
 
inline RdmResponseAction RdmResponseAction::RetryLater()
{
  RdmResponseAction to_return;
  RDMNET_SYNC_RETRY_LATER(&to_return.response_);
  return to_return;
}
 
constexpr const RdmnetSyncRdmResponse& RdmResponseAction::get() const
{
  return response_;
}
 
class EptResponseAction
{
public:
  static EptResponseAction SendData(size_t response_data_len);
  static EptResponseAction SendStatus(ept_status_code_t status_code);
  static EptResponseAction DeferResponse();
 
  constexpr const RdmnetSyncEptResponse& get() const;
 
private:
  RdmnetSyncEptResponse response_;
};
 
inline EptResponseAction EptResponseAction::SendData(size_t response_data_len)
{
  EptResponseAction to_return;
  RDMNET_SYNC_SEND_EPT_DATA(&to_return.response_, response_data_len);
  return to_return;
}
 
inline EptResponseAction EptResponseAction::SendStatus(ept_status_code_t status_code)
{
  EptResponseAction to_return;
  RDMNET_SYNC_SEND_EPT_STATUS(&to_return.response_, status_code);
  return to_return;
}
 
inline EptResponseAction EptResponseAction::DeferResponse()
{
  EptResponseAction to_return;
  RDMNET_SYNC_DEFER_EPT_RESPONSE(&to_return.response_);
  return to_return;
}
 
constexpr const RdmnetSyncEptResponse& EptResponseAction::get() const
{
  return response_;
}
 
};  // namespace rdmnet
 
#endif  // RDMNET_CPP_COMMON_H_