queue.h

Go to the documentation of this file.

/******************************************************************************
 * 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_QUEUE_H
#define ETCPAL_CPP_QUEUE_H
 
#include <algorithm>
#include <chrono>
#include <cstddef>
#include <limits>
#include "etcpal/common.h"
#include "etcpal/queue.h"
#include "etcpal/cpp/common.h"
 
namespace etcpal
{
 
template <class T>
class Queue
{
  static_assert(std::is_trivially_copyable<T>::value, "Type T in etcpal::Queue<T> must be trivially copyable.");
 
public:
  explicit Queue(size_t size);
  ~Queue();
 
  Queue(const Queue& other) = delete;
  Queue& operator=(const Queue& other) = delete;
  Queue(Queue&& other)                 = delete;
  Queue& operator=(Queue&& 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_{};
};
 
template <class T>
inline Queue<T>::Queue(size_t size)
{
  etcpal_queue_create(&queue_, size, sizeof(T));
}
 
template <class T>
inline Queue<T>::~Queue()
{
  etcpal_queue_destroy(&queue_);
}
 
template <class T>
inline bool Queue<T>::Send(const T& data, int timeout_ms)
{
  return etcpal_queue_timed_send(&queue_, &data, timeout_ms);
}
 
template <class T>
inline bool Queue<T>::SendFromIsr(const T& data)
{
  return etcpal_queue_send_from_isr(&queue_, &data);
}
 
template <class T>
inline bool Queue<T>::Receive(T& data, int timeout_ms)
{
  return etcpal_queue_timed_receive(&queue_, &data, timeout_ms);
}
 
template <class T>
template <class Rep, class Period>
inline bool Queue<T>::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>
inline bool Queue<T>::ReceiveFromIsr(T& data)
{
  return etcpal_queue_receive_from_isr(&queue_, &data);
}
 
template <class T>
inline bool Queue<T>::Reset()
{
  return etcpal_queue_reset(&queue_);
}
 
template <class T>
inline bool Queue<T>::IsEmpty() const
{
  return etcpal_queue_is_empty(&queue_);
};
 
template <class T>
inline bool Queue<T>::IsEmptyFromIsr() const
{
  return etcpal_queue_is_empty_from_isr(&queue_);
};
 
template <class T>
inline bool Queue<T>::IsFull() const
{
  return etcpal_queue_is_full(&queue_);
};
 
template <class T>
inline bool Queue<T>::IsFullFromIsr() const
{
  return etcpal_queue_is_full_from_isr(&queue_);
};
 
template <class T>
inline size_t Queue<T>::SlotsUsed() const
{
  return etcpal_queue_slots_used(&queue_);
};
 
template <class T>
inline size_t Queue<T>::SlotsUsedFromIsr() const
{
  return etcpal_queue_slots_used_from_isr(&queue_);
};
 
template <class T>
inline size_t Queue<T>::SlotsAvailable() const
{
  return etcpal_queue_slots_available(&queue_);
};
 
};  // namespace etcpal
 
#endif  // ETCPAL_CPP_RTOS_ERROR_H