queue.hpp

 
#ifndef OPENEV_CONTAINERS_QUEUE_HPP
#define OPENEV_CONTAINERS_QUEUE_HPP
 
#include "openev/containers/array.hpp"
#include "openev/containers/vector.hpp"
#include "openev/core/types.hpp"
#include <cstddef>
#include <queue>
#include <utility>
 
namespace ev {
#ifndef OPENEV_ARRAY_HPP
template <typename T, std::size_t N>
class Array_;
#endif
 
#ifndef OPENEV_VECTOR_HPP
template <typename T>
class Vector_;
#endif
template <typename T>
class Queue_ : public std::queue<T> {
  using std::queue<T>::queue;
 
public:
  inline void push(const T &e) {
    std::queue<T>::push(e);
  }
  template <std::size_t N>
  inline void push(const Array_<T, N> &array) {
    for(const T &e : array) {
      std::queue<T>::emplace(std::move(e));
    }
  }
 
  inline void push(const Vector_<T> &vector) {
    for(const T &e : vector) {
      std::queue<T>::emplace(std::move(e));
    }
  }
 
  [[nodiscard]] inline double duration() const {
    return (std::queue<T>::back()).t - (std::queue<T>::front()).t;
  }
 
  [[nodiscard]] inline double rate() const {
    return std::queue<T>::size() / duration();
  }
 
  [[nodiscard]] inline double midTime() const {
    return 0.5 * (std::queue<T>::front().t + std::queue<T>::back().t);
  }
};
using Queuei = Queue_<Eventi>;                   
using Queuel = Queue_<Eventl>;                   
using Queuef = Queue_<Eventf>;                   
using Queued = Queue_<Eventd>;                   
using Queue = Queue_<Event>;                     
using AugmentedQueuei = Queue_<AugmentedEventi>; 
using AugmentedQueuel = Queue_<AugmentedEventl>; 
using AugmentedQueuef = Queue_<AugmentedEventf>; 
using AugmentedQueued = Queue_<AugmentedEventd>; 
using AugmentedQueue = Queue_<AugmentedEvent>;   
} // namespace ev
 
#endif // OPENEV_CONTAINERS_QUEUE_HPP