TsDeque.hpp

Go to the documentation of this file.

// This file is part of INSTINCT, the INS Toolkit for Integrated
// Navigation Concepts and Training by the Institute of Navigation of
// the University of Stuttgart, Germany.
//
// This Source Code Form is subject to the terms of the Mozilla Public
// License, v. 2.0. If a copy of the MPL was not distributed with this
// file, You can obtain one at https://mozilla.org/MPL/2.0/.
 
 
#pragma once
 
#include <deque>
#include <mutex>
 
namespace NAV
{
 
template<class T, class Alloc = std::allocator<T>>
class TsDeque
{
  public:
    // #######################################################################################################
    //                                           Member functions
    // #######################################################################################################
 
    TsDeque() = default;
 
    ~TsDeque() = default;
 
    explicit TsDeque(const Alloc& alloc)
        : _queue(alloc) {}
 
    TsDeque(typename std::deque<T, Alloc>::size_type count, const T& value, const Alloc& alloc = Alloc())
        : _queue(count, value, alloc) {}
 
    explicit TsDeque(typename std::deque<T, Alloc>::size_type count, const Alloc& alloc = Alloc())
        : _queue(count, alloc) {}
 
    template<class InputIt>
    TsDeque(InputIt first, InputIt last, const Alloc& alloc = Alloc())
        : _queue(first, last, alloc)
    {}
 
    TsDeque(const TsDeque& other)
    {
        std::scoped_lock lk(other._mutex);
        _queue = std::deque<T, Alloc>(other._queue); // NOLINT(cppcoreguidelines-prefer-member-initializer)
    }
    TsDeque(const TsDeque& other, const Alloc& alloc)
    {
        std::scoped_lock lk(other._mutex);
        _queue = std::deque<T, Alloc>(other._queue, alloc); // NOLINT(cppcoreguidelines-prefer-member-initializer)
    }
    TsDeque(TsDeque&& other) noexcept
    {
        std::scoped_lock lk(other._mutex);
        _queue = std::deque<T, Alloc>(std::move(other._queue)); // NOLINT(cppcoreguidelines-prefer-member-initializer)
    }
    TsDeque(TsDeque&& other, const Alloc& alloc) noexcept
    {
        std::scoped_lock lk(other._mutex);
        _queue = std::deque<T, Alloc>(std::move(other._queue), alloc); // NOLINT(cppcoreguidelines-prefer-member-initializer)
    }
    TsDeque(std::initializer_list<T> init, const Alloc& alloc = Alloc())
        : _queue(init, alloc) {}
 
    TsDeque& operator=(const TsDeque& other)
    {
        if (this != &other)
        {
            std::scoped_lock lk(_mutex);
            std::scoped_lock lko(other._mutex);
            _queue = other._queue;
        }
        return *this;
    }
    TsDeque& operator=(TsDeque&& other) noexcept
    {
        if (this != &other)
        {
            std::scoped_lock lk(_mutex);
            std::scoped_lock lko(other._mutex);
            _queue = std::move(other._queue);
        }
        return *this;
    }
    TsDeque& operator=(std::initializer_list<T> ilist)
    {
        _queue = ilist;
    }
 
    void assign(typename std::deque<T, Alloc>::size_type count, const T& value)
    {
        std::scoped_lock lk(_mutex);
        _queue.assign(count, value);
    }
 
    template<class InputIt>
    void assign(InputIt first, InputIt last)
    {
        std::scoped_lock lk(_mutex);
        _queue.assign(first, last);
    }
    void assign(std::initializer_list<T> ilist)
    {
        std::scoped_lock lk(_mutex);
        _queue.assign(ilist);
    }
 
    typename std::deque<T, Alloc>::allocator_type get_allocator() const noexcept
    {
        return _queue.get_allocator();
    }
 
    // #######################################################################################################
    //                                            Element access
    // #######################################################################################################
 
    auto& at(typename std::deque<T, Alloc>::size_type pos) { return _queue.at(pos); }
    const auto& at(typename std::deque<T, Alloc>::size_type pos) const { return _queue.at(pos); }
 
    auto& operator[](typename std::deque<T, Alloc>::size_type pos) { return _queue[pos]; }
    const auto& operator[](typename std::deque<T, Alloc>::size_type pos) const { return _queue[pos]; }
 
    auto& front() { return _queue.front(); }
    const auto& front() const { return _queue.front(); }
 
    auto& back() { return _queue.back(); }
    const auto& back() const { return _queue.back(); }
 
    // #######################################################################################################
    //                                               Iterators
    // #######################################################################################################
 
    typename std::deque<T>::iterator begin() noexcept { return _queue.begin(); }
    typename std::deque<T>::const_iterator begin() const noexcept { return _queue.begin(); }
    typename std::deque<T>::const_iterator cbegin() const noexcept { return _queue.cbegin(); }
 
    typename std::deque<T>::iterator end() noexcept { return _queue.end(); }
    typename std::deque<T>::const_iterator end() const noexcept { return _queue.end(); }
    typename std::deque<T>::const_iterator cend() const noexcept { return _queue.cend(); }
 
    typename std::deque<T>::reverse_iterator rbegin() noexcept { return _queue.rbegin(); }
    typename std::deque<T>::const_reverse_iterator rbegin() const noexcept { return _queue.rbegin(); }
    typename std::deque<T>::const_reverse_iterator crbegin() const noexcept { return _queue.crbegin(); }
 
    typename std::deque<T>::reverse_iterator rend() noexcept { return _queue.rend(); }
    typename std::deque<T>::const_reverse_iterator rend() const noexcept { return _queue.rend(); }
    typename std::deque<T>::const_reverse_iterator crend() const noexcept { return _queue.crend(); }
 
    // #######################################################################################################
    //                                               Capacity
    // #######################################################################################################
 
    [[nodiscard]] bool empty() const noexcept
    {
        std::scoped_lock lk(_mutex);
        return _queue.empty();
    }
 
    typename std::deque<T, Alloc>::size_type size() const noexcept
    {
        std::scoped_lock lk(_mutex);
        return _queue.size();
    }
 
    typename std::deque<T, Alloc>::size_type max_size() const noexcept
    {
        std::scoped_lock lk(_mutex);
        return _queue.max_size();
    }
 
    void shrink_to_fit()
    {
        std::scoped_lock lk(_mutex);
        _queue.shrink_to_fit();
    }
 
    // #######################################################################################################
    //                                               Modifiers
    // #######################################################################################################
 
    void clear() noexcept
    {
        std::scoped_lock lk(_mutex);
        _queue.clear();
    }
 
    typename std::deque<T>::iterator insert(typename std::deque<T>::const_iterator pos, const T& value)
    {
        std::scoped_lock lk(_mutex);
        return _queue.insert(pos, value);
    }
 
    typename std::deque<T>::iterator insert(typename std::deque<T>::const_iterator pos, T&& value)
    {
        std::scoped_lock lk(_mutex);
        return _queue.insert(pos, value);
    }
 
    typename std::deque<T>::iterator insert(typename std::deque<T>::const_iterator pos, typename std::deque<T, Alloc>::size_type count, const T& value)
    {
        std::scoped_lock lk(_mutex);
        return _queue.insert(pos, count, value);
    }
 
    template<class InputIt>
    typename std::deque<T>::iterator insert(typename std::deque<T>::const_iterator pos, InputIt first, InputIt last)
    {
        std::scoped_lock lk(_mutex);
        return _queue.insert(pos, first, last);
    }
 
    typename std::deque<T>::iterator insert(typename std::deque<T>::const_iterator pos, std::initializer_list<T> ilist)
    {
        std::scoped_lock lk(_mutex);
        return _queue.insert(pos, ilist);
    }
 
    template<class... Args>
    typename std::deque<T>::iterator emplace(typename std::deque<T>::const_iterator pos, Args&&... args)
    {
        std::scoped_lock lk(_mutex);
        return _queue.emplace(pos, std::forward<Args>(args)...);
    }
 
    typename std::deque<T>::iterator erase(typename std::deque<T>::const_iterator pos)
    {
        std::scoped_lock lk(_mutex);
        return _queue.erase(pos);
    }
    typename std::deque<T>::iterator erase(typename std::deque<T>::const_iterator first, typename std::deque<T>::const_iterator last)
    {
        std::scoped_lock lk(_mutex);
        return _queue.erase(first, last);
    }
 
    void push_back(const T& value)
    {
        std::scoped_lock lk(_mutex);
        _queue.push_back(value);
    }
    void push_back(T&& value)
    {
        std::scoped_lock lk(_mutex);
        _queue.push_back(value);
    }
 
    template<class... Args>
    auto& emplace_back(Args&&... args)
    {
        std::scoped_lock lk(_mutex);
        return _queue.emplace_back(std::forward<Args>(args)...);
    }
 
    void pop_back()
    {
        std::scoped_lock lk(_mutex);
        _queue.pop_back();
    }
 
    void push_front(const T& value)
    {
        std::scoped_lock lk(_mutex);
        _queue.push_front(value);
    }
    void push_front(T&& value)
    {
        std::scoped_lock lk(_mutex);
        _queue.push_front(value);
    }
 
    template<class... Args>
    auto& emplace_front(Args&&... args)
    {
        std::scoped_lock lk(_mutex);
        return _queue.emplace_front(std::forward<Args>(args)...);
    }
 
    void pop_front()
    {
        std::scoped_lock lk(_mutex);
        _queue.pop_front();
    }
 
    void resize(typename std::deque<T, Alloc>::size_type count)
    {
        std::scoped_lock lk(_mutex);
        _queue.resize(count);
    }
    void resize(typename std::deque<T, Alloc>::size_type count, const T& value)
    {
        std::scoped_lock lk(_mutex);
        _queue.resize(count, value);
    }
 
    void swap(std::deque<T>& other) noexcept
    {
        std::scoped_lock lk(_mutex);
        _queue.swap(other);
    }
 
    auto extract_front()
    {
        T front;
        {
            std::scoped_lock lk(_mutex);
            front = _queue.front();
        }
        pop_front();
        return front;
    }
 
  private:
    std::deque<T, Alloc> _queue;
 
    mutable std::mutex _mutex;
};
 
} // namespace NAV