static_queue.h

/******************************************************************************
 * Copyright 2022 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 EtcPal. For more information, go to:
 * https://github.com/ETCLabs/EtcPal
 ******************************************************************************/
 
 
#ifndef ETCPAL_CPP_STATIC_QUEUE_H
#define ETCPAL_CPP_STATIC_QUEUE_H
 
#include "etcpal/common.h"
#include "etcpal/cpp/common.h"
#include "etcpal/queue.h"
 
#include <algorithm>
#include <chrono>
#include <cstddef>
#include <limits>
#include <assert.h>
 
namespace etcpal
{
 
template <class T, unsigned N>
class StaticQueue
{
  static_assert(std::is_trivially_copyable<T>::value, "Type T in etcpal::StaticQueue<T> must be trivially copyable.");
  static_assert(N > 0, "The number of elements in a static queue must be greater than 0");
 
public:
  explicit StaticQueue();
  ~StaticQueue();
 
  StaticQueue(const StaticQueue& other) = delete;
 
  StaticQueue& operator=(const StaticQueue& other) = delete;
  StaticQueue(StaticQueue&& other)                 = delete;
 
  StaticQueue& operator=(StaticQueue&& other) = delete;
 
  bool Send(const T& data, int timeout_ms = ETCPAL_WAIT_FOREVER);
  bool SendFromIsr(const T& data);
 
  bool Receive(T& data, int timeout_ms = ETCPAL_WAIT_FOREVER);
  template <class Rep, class Period>
  bool   Receive(T& data, const std::chrono::duration<Rep, Period>& timeout);
  bool   ReceiveFromIsr(T& data);
  bool   Reset();
  bool   IsEmpty() const;
  bool   IsEmptyFromIsr() const;
  bool   IsFull() const;
  bool   IsFullFromIsr() const;
  size_t SlotsUsed() const;
  size_t SlotsUsedFromIsr() const;
  size_t SlotsAvailable() const;
 
private:
  etcpal_queue_t queue_{};
  uint8_t        buffer[N * sizeof(T)];
};
 
template <class T, unsigned N>
inline StaticQueue<T, N>::StaticQueue()
{
  bool true_if_success = false;
  true_if_success      = etcpal_queue_create_static(&queue_, N, sizeof(T), buffer);
  assert(true_if_success);
}
 
template <class T, unsigned N>
inline StaticQueue<T, N>::~StaticQueue()
{
  etcpal_queue_destroy(&queue_);
}
 
template <class T, unsigned N>
inline bool StaticQueue<T, N>::Send(const T& data, int timeout_ms)
{
  return etcpal_queue_timed_send(&queue_, &data, timeout_ms);
}
 
template <class T, unsigned N>
inline bool StaticQueue<T, N>::SendFromIsr(const T& data)
{
  return etcpal_queue_send_from_isr(&queue_, &data);
}
 
template <class T, unsigned N>
inline bool StaticQueue<T, N>::Receive(T& data, int timeout_ms)
{
  return etcpal_queue_timed_receive(&queue_, &data, timeout_ms);
}
 
template <class T, unsigned N>
template <class Rep, class Period>
inline bool StaticQueue<T, N>::Receive(T& data, const std::chrono::duration<Rep, Period>& timeout)
{
  int timeout_ms_clamped =
      static_cast<int>(std::min(std::chrono::milliseconds(timeout).count(),
                                static_cast<std::chrono::milliseconds::rep>(std::numeric_limits<int>::max())));
  return etcpal_queue_timed_receive(&queue_, &data, timeout_ms_clamped);
}
 
template <class T, unsigned N>
inline bool StaticQueue<T, N>::ReceiveFromIsr(T& data)
{
  return etcpal_queue_receive_from_isr(&queue_, &data);
}
 
template <class T, unsigned N>
inline bool StaticQueue<T, N>::Reset()
{
  return etcpal_queue_reset(&queue_);
}
 
template <class T, unsigned N>
inline bool StaticQueue<T, N>::IsEmpty() const
{
  return etcpal_queue_is_empty(&queue_);
};
 
template <class T, unsigned N>
inline bool StaticQueue<T, N>::IsEmptyFromIsr() const
{
  return etcpal_queue_is_empty_from_isr(&queue_);
};
 
template <class T, unsigned N>
inline bool StaticQueue<T, N>::IsFull() const
{
  return etcpal_queue_is_full(&queue_);
};
 
template <class T, unsigned N>
inline bool StaticQueue<T, N>::IsFullFromIsr() const
{
  return etcpal_queue_is_full_from_isr(&queue_);
};
 
template <class T, unsigned N>
inline size_t StaticQueue<T, N>::SlotsUsed() const
{
  return etcpal_queue_slots_used(&queue_);
};
 
template <class T, unsigned N>
inline size_t StaticQueue<T, N>::SlotsUsedFromIsr() const
{
  return etcpal_queue_slots_used_from_isr(&queue_);
};
 
template <class T, unsigned N>
inline size_t StaticQueue<T, N>::SlotsAvailable() const
{
  return etcpal_queue_slots_available(&queue_);
};
 
};  // namespace etcpal
 
#endif  // ETCPAL_CPP_STATIC_QUEUE_H