StaticQueue.h

Go to the documentation of this file.

//
// Copyright 2012 - 2025 (C). Alex Robenko. All rights reserved.
//
// 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 http://mozilla.org/MPL/2.0/.
 
 
#pragma once
 
#include "comms/Assert.h"
#include "comms/CompileControl.h"
#include "comms/util/AlignedStorage.h"
#include "comms/util/SizeToType.h"
#include "comms/util/type_traits.h"
 
#include <algorithm>
#include <array>
#include <cstddef>
#include <cstdint>
#include <iterator>
#include <stdexcept>
#include <string>
#include <type_traits>
#include <utility>
 
COMMS_MSVC_WARNING_PUSH
COMMS_MSVC_WARNING_DISABLE(4324) // Disable warning about alignment padding
 
namespace comms
{
 
namespace util
{
 
namespace details
{
 
template <typename T>
class StaticQueueBase
{
public:
    template <typename TDerived, typename TQueueType>
    class IteratorBase;
 
    class ConstIterator;
    class Iterator;
 
protected:
    using ValueType = T;
    using StorageType = comms::util::AlignedStorage<sizeof(ValueType), std::alignment_of<ValueType>::value>;
    using StorageTypePtr = StorageType*;
    using ConstStorageTypePtr = const StorageType*;
    using SizeType = std::size_t;
    using Reference = ValueType&;
    using ConstReference = const ValueType&;
    using Pointer = ValueType*;
    using ConstPointer = const ValueType*;
    using LinearisedIterator = Pointer;
    using ConstLinearisedIterator = ConstPointer;
    using ReverseLinearisedIterator = std::reverse_iterator<LinearisedIterator>;
    using ConstReverseLinearisedIterator = std::reverse_iterator<ConstLinearisedIterator>;
    using LinearisedIteratorRange = std::pair<LinearisedIterator, LinearisedIterator>;
    using ConstLinearisedIteratorRange = std::pair<ConstLinearisedIterator, ConstLinearisedIterator>;
 
    StaticQueueBase(StorageTypePtr data, std::size_t capacity)
        : m_data(data),
          m_capacity(capacity),
          m_startIdx(0),
          m_count(0)
    {
    }
 
    StaticQueueBase(const StaticQueueBase&) = delete;
    StaticQueueBase(StaticQueueBase&&) = delete;
 
    ~StaticQueueBase() noexcept
    {
        clear();
    }
 
    StaticQueueBase& operator=(const StaticQueueBase& other)
    {
        if (this == &other) {
            return *this;
        }
 
        clear();
        assignElements(other);
        return *this;
    }
 
    StaticQueueBase& operator=(StaticQueueBase&& other)
    {
        if (this == &other) {
            return *this;
        }
 
        clear();
        assignElements(std::move(other));
        return *this;
    }
 
    constexpr std::size_t capacity() const
    {
        return m_capacity;
    }
 
    std::size_t size() const
    {
        return m_count;
    }
 
    void clear()
    {
        while (!empty()) {
            popFront();
        }
    }
 
    bool empty() const
    {
        return (size() == 0);
    }
 
    bool full() const
    {
        return (size() == capacity());
    }
 
    Reference front()
    {
        COMMS_ASSERT(!empty());
        return (*this)[0];
    }
 
    ConstReference front() const
    {
        COMMS_ASSERT(!empty());
        return (*this)[0];
    }
 
    Reference back()
    {
        auto constThis = static_cast<const StaticQueueBase*>(this);
        return const_cast<Reference>(constThis->back());
    }
 
    ConstReference back() const
    {
        COMMS_ASSERT(!empty());
        if (empty()) {
            return (*this)[0]; // Back() on empty queue
        }
 
        return (*this)[m_count - 1];
    }
 
    void popFront()
    {
        COMMS_ASSERT(!empty()); // Queue musn't be empty
        if (empty())
        {
            // Do nothing
            return;
        }
 
        Reference element = front();
        element.~T();
 
        --m_count;
        ++m_startIdx;
        if ((capacity() <= m_startIdx) ||
            (empty())) {
            m_startIdx = 0;
        }
    }
 
    void popFront(std::size_t count)
    {
        COMMS_ASSERT(count <= size());
        while ((!empty()) && (count > 0)) {
            popFront();
            --count;
        }
    }
 
    void popBack()
    {
        COMMS_ASSERT(!empty());
        if (empty())
        {
            // Do nothing
            return;
        }
 
        Reference element = back();
        element.~T();
 
        --m_count;
    }
 
    void popBack(std::size_t count)
    {
        COMMS_ASSERT(count <= size());
        while ((!empty()) && (count > 0)) {
            popBack();
            --count;
        }
    }
 
    Reference operator[](std::size_t index)
    {
        auto constThis = static_cast<const StaticQueueBase*>(this);
        return const_cast<Reference>((*constThis)[index]);
    }
 
    ConstReference operator[](std::size_t index) const
    {
        COMMS_ASSERT(index < size());
        return elementAtIndex(index);
    }
 
    Reference at(std::size_t index)
    {
        auto constThis = static_cast<const StaticQueueBase*>(this);
        return const_cast<Reference>(constThis->at(index));
    }
 
    ConstReference at(std::size_t index) const
    {
        if (index >= size()) {
            throw std::out_of_range(std::string("Index is out of range"));
        }
        return (*this)[index];
    }
 
    int indexOf(ConstReference element) const
    {
        ConstPointer elementPtr = &element;
        auto cellPtr = reinterpret_cast<ConstStorageTypePtr>(elementPtr);
        if ((cellPtr < &m_data[0]) ||
            (&m_data[capacity()] <= cellPtr)) {
            // invalid, element is not within array boundaries
            return -1;
        }
 
        auto rawIdx = cellPtr - &m_data[0];
        std::size_t actualIdx = capacity(); // invalid value
        if (rawIdx < m_startIdx) {
            actualIdx = (capacity() - m_startIdx) + rawIdx;
        }
        else {
            actualIdx = rawIdx - m_startIdx;
        }
 
        if (size() <= actualIdx)
        {
            // Element is out of range
            return -1;
        }
 
        return actualIdx;
    }
 
    LinearisedIterator invalidIter()
    {
        return reinterpret_cast<LinearisedIterator>(&m_data[capacity()]);
    }
 
    ConstLinearisedIterator invalidIter() const
    {
        return reinterpret_cast<LinearisedIterator>(&m_data[capacity()]);
    }
 
    ReverseLinearisedIterator invalidReverseIter()
    {
        return ReverseLinearisedIterator(
            reinterpret_cast<LinearisedIterator>(&m_data[0]));
    }
 
    ConstReverseLinearisedIterator invalidReverseIter() const
    {
        return ReverseLinearisedIterator(
            reinterpret_cast<LinearisedIterator>(&m_data[0]));
    }
 
    LinearisedIterator lbegin()
    {
        if (!linearised()) {
            return invalidIter();
        }
 
        return reinterpret_cast<LinearisedIterator>(&m_data[0] + m_startIdx);
    }
 
    ConstLinearisedIterator lbegin() const
    {
        return clbegin();
    }
 
    ConstLinearisedIterator clbegin() const
    {
        if (!linearised()) {
            return invalidIter();
        }
 
        return reinterpret_cast<LinearisedIterator>(&m_data[0] + m_startIdx);
    }
 
    ReverseLinearisedIterator rlbegin()
    {
        if (!linearised()) {
            return invalidReverseIter();
        }
 
        return ReverseLinearisedIterator(lend());
    }
 
    ConstReverseLinearisedIterator rlbegin() const
    {
        return crlbegin();
    }
 
    ConstReverseLinearisedIterator crlbegin() const
    {
        if (!linearised()) {
            return invalidReverseIter();
        }
        return ConstReverseLinearisedIterator(lend());
    }
 
    LinearisedIterator lend()
    {
        if (!linearised()) {
            return invalidIter();
        }
 
        return lbegin() + size();
    }
 
    ConstLinearisedIterator lend() const
    {
        return clend();
    }
 
    ConstLinearisedIterator clend() const
    {
        if (!linearised()) {
            return invalidIter();
        }
 
        return clbegin() + size();
    }
 
    ReverseLinearisedIterator rlend()
    {
        if (!linearised()) {
            return invalidReverseIter();
        }
 
        return rlbegin() + size();
    }
 
    ConstReverseLinearisedIterator rlend() const
    {
        return crlend();
    }
 
    ConstReverseLinearisedIterator crlend() const
    {
        if (!linearised()) {
            return invalidReverseIter();
        }
 
        return rlbegin() + size();
    }
 
    void linearise()
    {
        if (linearised()) {
            // Nothing to do
            return;
        }
 
        auto rangeOne = arrayOne();
        auto rangeOneSize = std::distance(rangeOne.first, rangeOne.second);
        COMMS_ASSERT(0 < rangeOneSize);
        auto rangeTwo = arrayTwo();
        auto rangeTwoSize = std::distance(rangeTwo.first, rangeTwo.second);
        COMMS_ASSERT(0 < rangeTwoSize);
        COMMS_ASSERT((rangeOneSize + rangeTwoSize) == size());
        auto remSpaceSize = capacity() - size();
 
        if (rangeTwoSize <= remSpaceSize) {
            lineariseByMoveOneTwo(rangeOne, rangeTwo);
            return;
        }
 
        if (rangeOneSize <= remSpaceSize) {
            lineariseByMoveTwoOne(rangeOne, rangeTwo);
            return;
        }
 
        if (rangeOneSize < rangeTwoSize) {
            lineariseByPopOne();
        }
 
        lineariseByPopTwo();
    }
 
    bool linearised() const
    {
        return (empty() || ((m_startIdx + size()) <= capacity()));
    }
 
    LinearisedIteratorRange arrayOne()
    {
        auto constThis = static_cast<const StaticQueueBase*>(this);
        auto constRange = constThis->arrayOne();
        return
            LinearisedIteratorRange(
                const_cast<LinearisedIterator>(constRange.first),
                const_cast<LinearisedIterator>(constRange.second));
    }
 
    ConstLinearisedIteratorRange arrayOne() const
    {
        auto begCell = &m_data[m_startIdx];
        auto endCell = std::min(&m_data[m_startIdx + size()], &m_data[capacity()]);
        return
            ConstLinearisedIteratorRange(
                reinterpret_cast<ConstLinearisedIterator>(begCell),
                reinterpret_cast<ConstLinearisedIterator>(endCell));
    }
 
    LinearisedIteratorRange arrayTwo()
    {
        auto constThis = static_cast<const StaticQueueBase*>(this);
        auto constRange = constThis->arrayTwo();
        return
            LinearisedIteratorRange(
                const_cast<LinearisedIterator>(constRange.first),
                const_cast<LinearisedIterator>(constRange.second));
    }
 
    ConstLinearisedIteratorRange arrayTwo() const
    {
        if (linearised()) {
            auto iter = arrayOne().second;
            return ConstLinearisedIteratorRange(iter, iter);
        }
 
        auto begCell = &m_data[0];
        auto endCell = &m_data[(m_startIdx + size()) - capacity()];
 
        return
            ConstLinearisedIteratorRange(
                reinterpret_cast<ConstLinearisedIterator>(begCell),
                reinterpret_cast<ConstLinearisedIterator>(endCell));
    }
 
    void resize(std::size_t newSize)
    {
        COMMS_ASSERT(newSize <= capacity());
        if (capacity() < newSize) {
            return;
        }
 
        if (size() <= newSize) {
            while (size() < newSize) {
                pushBackNotFull(ValueType());
            }
 
            return;
        }
 
        // New requested size is less than existing now
        popBack(size() - newSize);
    }
 
    LinearisedIterator erase(LinearisedIterator pos)
    {
        COMMS_ASSERT(pos != invalidIter());
        COMMS_ASSERT(!empty());
        auto rangeOne = arrayOne();
        auto rangeTwo = arrayTwo();
 
        auto isInRangeFunc =
            [](LinearisedIterator pos, const LinearisedIteratorRange range) -> bool
            {
                return ((range.first <= pos) && (pos < range.second));
            };
 
        COMMS_ASSERT(isInRangeFunc(pos, rangeOne) ||
               isInRangeFunc(pos, rangeTwo));
 
        if (isInRangeFunc(pos, rangeOne)) {
            std::move_backward(rangeOne.first, pos, pos + 1);
 
            popFront();
            rangeOne = arrayOne();
            if (isInRangeFunc(pos, rangeOne)) {
                return pos + 1;
            }
 
            return rangeOne.first;
        }
 
        if (isInRangeFunc(pos, rangeTwo)) {
            std::move(pos + 1, rangeTwo.second, pos);
            popBack();
            if (!linearised()) {
                return pos;
            }
            return arrayOne().second;
        }
 
        static constexpr bool Invalid_iterator_is_used = false;
        static_cast<void>(Invalid_iterator_is_used);
        COMMS_ASSERT(Invalid_iterator_is_used);
        return invalidIter();
    }
 
    Iterator erase(Iterator pos)
    {
        COMMS_ASSERT(pos != end());
        COMMS_ASSERT(!empty());
        Pointer elem = &(*pos);
        auto rangeOne = arrayOne();
        auto rangeTwo = arrayTwo();
 
        auto isInRangeFunc =
            [](Pointer elemPtr, const LinearisedIteratorRange range) -> bool
            {
                return ((&(*range.first) <= elemPtr) && (elemPtr < &(*range.second)));
            };
 
        COMMS_ASSERT(isInRangeFunc(elem, rangeOne) ||
                isInRangeFunc(elem, rangeTwo));
 
        if (isInRangeFunc(elem, rangeOne)) {
            std::move_backward(rangeOne.first, elem, elem + 1);
 
            popFront();
            rangeOne = arrayOne();
            if (isInRangeFunc(elem, rangeOne)) {
                return pos + 1;
            }
 
            return begin();
        }
 
        if (isInRangeFunc(elem, rangeTwo)) {
            std::move(elem + 1, rangeTwo.second, elem);
            popBack();
            if (!linearised()) {
                return pos;
            }
            return end();
        }
 
        static constexpr bool Invalid_iterator_is_used = false;
        static_cast<void>(Invalid_iterator_is_used);
        COMMS_ASSERT(Invalid_iterator_is_used);
        return end();
    }
 
    Iterator begin()
    {
        return Iterator(*this, reinterpret_cast<LinearisedIterator>(&m_data[0]));
    }
 
    ConstIterator begin() const
    {
        return cbegin();
    }
 
    ConstIterator cbegin() const
    {
        return ConstIterator(*this, reinterpret_cast<ConstLinearisedIterator>(&m_data[0]));
    }
 
    Iterator end()
    {
        return Iterator(*this, reinterpret_cast<LinearisedIterator>(&m_data[size()]));
    }
 
    ConstIterator end() const
    {
        return cend();
    }
 
    ConstIterator cend() const
    {
        return ConstIterator(*this, reinterpret_cast<ConstLinearisedIterator>(&m_data[size()]));
    }
 
    template <typename TOther>
    void assignElements(TOther&& other)
    {
        static_assert(std::is_base_of<StaticQueueBase, typename std::decay<TOther>::type>::value,
            "Assignment works only on the same types");
 
        using DecayedQueueType = typename std::decay<decltype(other)>::type;
        using NonRefQueueType = typename std::remove_reference<decltype(other)>::type;
 
        using QueueValueType =
            typename comms::util::Conditional<
                std::is_const<NonRefQueueType>::value
            >::template Type<
                const typename DecayedQueueType::ValueType,
                typename DecayedQueueType::ValueType
            >;
 
        using ElemRefType =
            typename comms::util::Conditional<
                std::is_rvalue_reference<decltype(other)>::value
            >::template Type<
                typename std::add_rvalue_reference<QueueValueType>::type,
                typename std::add_lvalue_reference<QueueValueType>::type
            >;
 
        COMMS_ASSERT(other.size() <= capacity());
        COMMS_ASSERT(empty());
 
        auto rangeOne = other.arrayOne();
        for (auto iter = rangeOne.first; iter != rangeOne.second; ++iter) {
            pushBackNotFull(std::forward<ElemRefType>(*iter));
        }
 
        auto rangeTwo = other.arrayTwo();
        for (auto iter = rangeTwo.first; iter != rangeTwo.second; ++iter) {
            pushBackNotFull(std::forward<ElemRefType>(*iter));
        }
    }
 
    template <typename U>
    void pushBack(U&& value)
    {
        COMMS_ASSERT(!full());
        if (full()) {
            return;
        }
        pushBackNotFull(std::forward<U>(value));
    }
 
    template <typename... TArgs>
    void emplaceBack(TArgs&&... args)
    {
        COMMS_ASSERT(!full());
        if (full()) {
            return;
        }
        emplaceBackNotFull(std::forward<TArgs>(args)...);
    }
 
    template <typename U>
    void pushFront(U&& value)
    {
        COMMS_ASSERT(!full());
        if (full()) {
            return;
        }
 
        pushFrontNotFull(std::forward<U>(value));
    }
 
    template <typename U>
    LinearisedIterator insert(LinearisedIterator pos, U&& value)
    {
        COMMS_ASSERT(!full());
        if (full()) {
            return invalidIter();
        }
 
        return insertNotFull(pos, std::forward<U>(value));
    }
 
    bool operator==(const StaticQueueBase& other) const
    {
        if (size() != other.size()) {
            return false;
        }
 
        auto rangeOne = arrayOne();
        auto rangeOneSize = std::distance(rangeOne.first, rangeOne.second);
        auto rangeTwo = arrayTwo();
        auto otherRangeOne = other.arrayOne();
        auto otherRangeOneSize = std::distance(otherRangeOne.first, otherRangeOne.second);
        auto otherRangeTwo = other.arrayTwo();
 
        auto firstCompSize = std::min(rangeOneSize, otherRangeOneSize);
        auto firstCompEnd = rangeOne.first + firstCompSize;
 
        auto currIter = rangeOne.first;
        auto otherCurrIter = otherRangeOne.first;
        if (!std::equal(currIter, firstCompEnd, otherCurrIter)) {
            return false;
        }
 
        currIter = firstCompEnd;
        otherCurrIter += firstCompSize;
 
        if (currIter != rangeOne.first) {
            otherCurrIter = otherRangeTwo.first;
            if (!std::equal(currIter, rangeOne.second, otherCurrIter)) {
                return false;
            }
            otherCurrIter += rangeOne.second - currIter;
            currIter = rangeTwo.first;
        }
        else {
            currIter = rangeTwo.first;
            if (!std::equal(otherCurrIter, otherRangeOne.second, currIter)) {
                return false;
            }
 
            currIter += otherRangeOne.second - otherCurrIter;
            otherCurrIter = otherRangeOne.first;
        }
 
        COMMS_ASSERT(std::distance(currIter, rangeTwo.second) == std::distance(otherCurrIter, otherRangeTwo.second));
        return std::equal(currIter, rangeTwo.second, otherCurrIter);
    }
 
    bool operator!=(const StaticQueueBase& other) const
    {
        return !(*this == other);
    }
 
private:
 
    template <typename U>
    void createValueAtIndex(U&& value, std::size_t index)
    {
        COMMS_ASSERT(index < capacity());
        Reference elementRef = elementAtIndex(index);
        auto elementPtr = new(&elementRef) ValueType(std::forward<U>(value));
        static_cast<void>(elementPtr);
    }
 
    template <typename U>
    void pushBackNotFull(U&& value)
    {
        COMMS_ASSERT(!full());
        createValueAtIndex(std::forward<U>(value), size());
        ++m_count;
    }
 
    template <typename... TArgs>
    void emplaceBackNotFull(TArgs&&... args)
    {
        COMMS_ASSERT(!full());
        Reference elementRef = elementAtIndex(size());
        auto elementPtr = new(&elementRef) ValueType(std::forward<TArgs>(args)...);
        static_cast<void>(elementPtr);
        ++m_count;
    }
 
    template <typename U>
    void pushFrontNotFull(U&& value)
    {
        COMMS_ASSERT(!full());
        createValueAtIndex(std::forward<U>(value), capacity() - 1);
        if (m_startIdx == 0) {
            m_startIdx = capacity() - 1;
        }
        else {
            --m_startIdx;
        }
 
        ++m_count;
    }
 
    template <typename U>
    LinearisedIterator insertNotFull(LinearisedIterator pos, U&& value)
    {
        COMMS_ASSERT(!full());
        COMMS_ASSERT(pos != invalidIter());
        auto rangeOne = arrayOne();
        auto rangeTwo = arrayTwo();
 
        if (pos == rangeOne.first) {
            pushFrontNotFull(std::forward<U>(value));
            return arrayOne().first;
        }
 
        if (pos == rangeTwo.second) {
            pushBackNotFull(std::forward<U>(value));
            return arrayTwo().second - 1;
        }
 
        auto isInRangeFunc = [](LinearisedIterator pos, const LinearisedIteratorRange range) -> bool
            {
                return ((range.first <= pos) && (pos < range.second));
            };
 
        COMMS_ASSERT(isInRangeFunc(pos, rangeOne) ||
                isInRangeFunc(pos, rangeTwo));
 
        if (isInRangeFunc(pos, rangeOne)) {
            pushFrontNotFull(std::move(front())); // move first element
 
            std::move(rangeOne.first + 1, pos, rangeOne.first);
            *pos = std::forward<U>(value);
            return pos;
        }
 
        if (isInRangeFunc(pos, rangeTwo)) {
            pushBackNotFull(std::move(back())); // move last element
            std::move_backward(pos, rangeTwo.second - 1, rangeTwo.second);
            *pos = std::forward<U>(value);
            return pos;
        }
 
        return invalidIter();
    }
 
    Reference elementAtIndex(std::size_t index) {
        auto constThis = static_cast<const StaticQueueBase*>(this);
        return const_cast<Reference>(constThis->elementAtIndex(index));
    }
 
    ConstReference elementAtIndex(std::size_t index) const
    {
        std::size_t rawIdx = m_startIdx + index;
        while (capacity() <= rawIdx) {
            rawIdx = rawIdx - capacity();
        }
 
        auto cellAddr = &m_data[rawIdx];
        return *(reinterpret_cast<ConstPointer>(cellAddr));
    }
 
    template <typename TIter>
    void lineariseByMove(
        const std::pair<TIter, TIter> firstRange,
        const std::pair<TIter, TIter> secondRange)
    {
        auto movConstructFirstSize =
            std::min(
                std::size_t(std::distance(firstRange.first, firstRange.second)),
                capacity() - size());
        auto movConstructFirstEnd = firstRange.first + movConstructFirstSize;
        COMMS_ASSERT(movConstructFirstEnd <= firstRange.second);
        COMMS_ASSERT(movConstructFirstSize <= (firstRange.second - firstRange.first));
 
        auto newPlacePtr = secondRange.second;
        for (auto iter = firstRange.first; iter != movConstructFirstEnd; ++iter) {
            auto ptr = new (&(*newPlacePtr)) ValueType(std::move(*iter));
            static_cast<void>(ptr);
            ++newPlacePtr;
        }
 
        std::move(movConstructFirstEnd, firstRange.second, newPlacePtr);
        newPlacePtr += (firstRange.second - movConstructFirstEnd);
 
        auto movConstructTwoSize = 0;
        if (newPlacePtr < firstRange.first) {
            movConstructTwoSize =
                std::min(std::distance(newPlacePtr, firstRange.first),
                         std::distance(secondRange.first, secondRange.second));
        }
 
        auto movConstructTwoEnd = secondRange.first + movConstructTwoSize;
        for (auto iter = secondRange.first; iter != movConstructTwoEnd; ++iter) {
            auto ptr = new (&(*newPlacePtr)) ValueType(std::move(*iter));
            static_cast<void>(ptr);
            ++newPlacePtr;
        }
 
        std::move(movConstructTwoEnd, secondRange.second, newPlacePtr);
        newPlacePtr += (secondRange.second - movConstructTwoEnd);
 
        for (auto iter = std::max(newPlacePtr, firstRange.first); iter != firstRange.second; ++iter) {
            iter->~T();
        }
 
        for (auto iter = secondRange.first; iter != secondRange.second; ++iter) {
            iter->~T();
        }
    }
 
    void lineariseByMoveOneTwo(
        const LinearisedIteratorRange& rangeOne,
        const LinearisedIteratorRange& rangeTwo)
    {
        lineariseByMove(rangeOne, rangeTwo);
        m_startIdx = std::distance(rangeTwo.first, rangeTwo.second);
    }
 
    void lineariseByMoveTwoOne(
        const LinearisedIteratorRange& rangeOne,
        const LinearisedIteratorRange& rangeTwo)
    {
        using RevIter = std::reverse_iterator<Pointer>;
        lineariseByMove(
            std::make_pair(RevIter(rangeTwo.second), RevIter(rangeTwo.first)),
            std::make_pair(RevIter(rangeOne.second), RevIter(rangeOne.first)));
 
        m_startIdx = (capacity() - std::distance(rangeOne.first, rangeOne.second)) - size();
    }
 
    void lineariseByPopOne()
    {
        if (linearised()) {
            return;
        }
 
        ValueType tmp(std::move(front()));
        popFront();
        lineariseByPopOne();
        if (m_startIdx == 0) {
            using RevIter = std::reverse_iterator<LinearisedIterator>;
            auto target =
                RevIter(reinterpret_cast<LinearisedIterator>(&m_data[capacity()]));
            moveRange(rlbegin(), rlend(), target);
            m_startIdx = capacity() - size();
        }
        pushFront(std::move(tmp));
        COMMS_ASSERT(linearised());
    }
 
    void lineariseByPopTwo()
    {
        if (linearised()) {
            return;
        }
 
        ValueType tmp(std::move(back()));
        popBack();
        lineariseByPopTwo();
        if (m_startIdx != 0) {
            auto target = reinterpret_cast<LinearisedIterator>(&m_data[0]);
            moveRange(lbegin(), lend(), target);
            m_startIdx = 0;
        }
        pushBack(std::move(tmp));
        COMMS_ASSERT(linearised());
    }
 
    template <typename TIter>
    void moveRange(TIter rangeBeg, TIter rangeEnd, TIter target)
    {
        COMMS_ASSERT(target < rangeBeg);
        auto moveConstructSize =
            std::min(
                std::distance(rangeBeg, rangeEnd),
                std::distance(target, rangeBeg));
 
        TIter moveConstructEnd = rangeBeg + moveConstructSize;
        for (auto iter = rangeBeg; iter != moveConstructEnd; ++iter) {
            auto ptr = new (&(*target)) ValueType(std::move(*iter));
            static_cast<void>(ptr);
            ++target;
        }
 
        COMMS_ASSERT(target < moveConstructEnd);
        std::move(moveConstructEnd, rangeEnd, target);
        target += std::distance(moveConstructEnd, rangeEnd);
 
        for (auto iter = std::max(target, rangeBeg); iter != rangeEnd; ++iter) {
            iter->~T();
        }
    }
 
    StorageTypePtr const m_data;
    const std::size_t m_capacity;
    std::size_t m_startIdx;
    std::size_t m_count;
};
 
template <typename T>
template <typename TDerived, typename TQueueType>
class StaticQueueBase<T>::IteratorBase
{
    friend class StaticQueueBase<T>;
public:
 
    IteratorBase(const IteratorBase&) = default;
 
    ~IteratorBase() noexcept = default;
 
protected:
    using Derived = TDerived;
    using QueueType = TQueueType;
    using ArrayIterator = decltype(std::declval<QueueType>().lbegin());
    using IteratorCategory = typename std::iterator_traits<ArrayIterator>::iterator_category;
    using iterator_category = IteratorCategory;
    using ValueType = typename std::iterator_traits<ArrayIterator>::value_type;
    using value_type = ValueType;
    using DifferenceType = typename std::iterator_traits<ArrayIterator>::difference_type;
    using difference_type = DifferenceType;
    using Pointer = typename std::iterator_traits<ArrayIterator>::pointer;
    using pointer = Pointer;
    using ConstPointer =
        typename std::add_pointer<
            typename std::add_const<
                typename std::remove_pointer<Pointer>::type
            >::type
        >::type;
    using Reference = typename std::iterator_traits<ArrayIterator>::reference;
    using reference = Reference;
    using ConstReference = typename std::add_const<Reference>::type;
 
    IteratorBase(QueueType& queue, ArrayIterator iterator)
        : m_queue(queue),
          m_iterator(iterator)
    {
    }
 
    Derived& operator=(const IteratorBase& other)
    {
        COMMS_ASSERT(&m_queue == &other.m_queue);
        m_iterator = other.m_iterator; // No need to check for self assignment
        return static_cast<Derived&>(*this);
    }
 
    Derived& operator++()
    {
        ++m_iterator;
        return static_cast<Derived&>(*this);
    }
 
    Derived operator++(int)
    {
        IteratorBase copy(*this);
        ++m_iterator;
        return std::move(*(static_cast<Derived*>(&copy)));
    }
 
    Derived& operator--()
    {
        --m_iterator;
        return static_cast<Derived&>(*this);
    }
 
    Derived operator--(int)
    {
        IteratorBase copy(*this);
        --m_iterator;
        return std::move(*(static_cast<Derived*>(&copy)));
    }
 
    Derived& operator+=(DifferenceType value)
    {
        m_iterator += value;
        return static_cast<Derived&>(*this);
    }
 
    Derived& operator-=(DifferenceType value)
    {
        m_iterator -= value;
        return static_cast<Derived&>(*this);
    }
 
    Derived operator+(DifferenceType value) const
    {
        IteratorBase copy(*this);
        copy += value;
        return std::move(*(static_cast<Derived*>(&copy)));
    }
 
    Derived operator-(DifferenceType value) const
    {
        IteratorBase copy(*this);
        copy -= value;
        return std::move(*(static_cast<Derived*>(&copy)));
    }
 
    DifferenceType operator-(const IteratorBase& other) const
    {
        return m_iterator - other.m_iterator;
    }
 
    bool operator==(const IteratorBase& other) const
    {
        return (m_iterator == other.m_iterator);
    }
 
    bool operator!=(const IteratorBase& other) const
    {
        return (m_iterator != other.m_iterator);
    }
 
    bool operator<(const IteratorBase& other) const
    {
        return m_iterator < other.m_iterator;
    }
 
    bool operator<=(const IteratorBase& other) const
    {
        return m_iterator <= other.m_iterator;
    }
 
    bool operator>(const IteratorBase& other) const
    {
        return m_iterator > other.m_iterator;
    }
 
    bool operator>=(const IteratorBase& other) const
    {
        return m_iterator >= other.m_iterator;
    }
 
    Reference operator*()
    {
        auto& constThisRef = static_cast<const IteratorBase&>(*this);
        auto& constRef = *constThisRef;
        return const_cast<Reference>(constRef);
    }
 
    ConstReference operator*() const
    {
        auto begCell = reinterpret_cast<ArrayIterator>(&m_queue.m_data[0]);
        auto idx = m_iterator - begCell;
        COMMS_ASSERT(0 <= idx);
        return m_queue[static_cast<std::size_t>(idx)];
    }
 
    Pointer operator->()
    {
        return &(*(*this));
    }
 
    ConstPointer operator->() const
    {
        return &(*(*this));
    }
 
    QueueType& getQueue() {
        return m_queue;
    }
 
    typename std::add_const<QueueType&>::type getQueue() const
    {
        return m_queue;
    }
 
    ArrayIterator& getIterator() {
        return m_iterator;
    }
 
    typename std::add_const<ArrayIterator>::type& getIterator() const
    {
        return m_iterator;
    }
 
private:
 
    QueueType& m_queue; 
    ArrayIterator m_iterator; 
};
 
template <typename T>
class StaticQueueBase<T>::ConstIterator :
            public StaticQueueBase<T>::template
                IteratorBase<typename StaticQueueBase<T>::ConstIterator, const StaticQueueBase<T> >
{
    using Base = typename StaticQueueBase<T>::template
        IteratorBase<typename StaticQueueBase<T>::ConstIterator, const StaticQueueBase<T> >;
 
public:
    using QueueType = typename Base::QueueType;
    using ArrayIterator = typename Base::ArrayIterator;
 
    ConstIterator(const ConstIterator&) = default;
    ~ConstIterator() noexcept = default;
 
    ConstIterator(QueueType& queue, ArrayIterator iterator)
        : Base(queue, iterator)
    {
    }
 
};
 
template <typename T>
class StaticQueueBase<T>::Iterator :
            public StaticQueueBase<T>::template
                IteratorBase<typename StaticQueueBase<T>::Iterator, StaticQueueBase<T> >
{
    using Base = typename StaticQueueBase<T>::template
        IteratorBase<typename StaticQueueBase<T>::Iterator, StaticQueueBase<T> >;
 
public:
    using QueueType = typename Base::QueueType;
    using ArrayIterator = typename Base::ArrayIterator;
 
    Iterator(const Iterator&) = default;
    ~Iterator() noexcept = default;
 
    Iterator(QueueType& queue, ArrayIterator iterator)
        : Base(queue, iterator)
    {
    }
 
    operator ConstIterator() const
    {
        return ConstIterator(Base::getQueue(), Base::getIterator());
    }
};
 
template <typename TWrapperElemType, typename TQueueElemType>
class CastWrapperQueueBase : public StaticQueueBase<TQueueElemType>
{
    using Base = StaticQueueBase<TQueueElemType>;
    using WrapperElemType = TWrapperElemType;
 
    using BaseValueType = typename Base::ValueType;
    using BaseStorageTypePtr = typename Base::StorageTypePtr;
    using BaseReference = typename Base::Reference;
    using BaseConstReference = typename Base::ConstReference;
    using BasePointer = typename Base::Pointer;
    using BaseConstPointer = typename Base::ConstPointer;
    using BaseLinearisedIterator = typename Base::LinearisedIterator;
    using BaseConstLinearisedIterator = typename Base::ConstLinearisedIterator;
    using BaseReverseLinearisedIterator = typename Base::ReverseLinearisedIterator;
    using BaseConstReverseLinearisedIterator = typename Base::ConstReverseLinearisedIterator;
    using BaseLinearisedIteratorRange = typename Base::LinearisedIteratorRange;
    using BaseConstLinearisedIteratorRange = typename Base::ConstLinearisedIteratorRange;
 
public:
 
    class ConstIterator;
    class Iterator;
 
protected:
    using ValueType = WrapperElemType;
    using StorageType = comms::util::AlignedStorage<sizeof(ValueType), std::alignment_of<ValueType>::value>;
    using StorageTypePtr = StorageType*;
    using Reference = ValueType&;
    using ConstReference = const ValueType&;
    using Pointer = ValueType*;
    using ConstPointer = const ValueType*;
    using LinearisedIterator = Pointer;
    using ConstLinearisedIterator = ConstPointer;
    using ReverseLinearisedIterator = std::reverse_iterator<LinearisedIterator>;
    using ConstReverseLinearisedIterator = std::reverse_iterator<ConstLinearisedIterator>;
    using LinearisedIteratorRange = std::pair<LinearisedIterator, LinearisedIterator>;
    using ConstLinearisedIteratorRange = std::pair<ConstLinearisedIterator, ConstLinearisedIterator>;
 
    CastWrapperQueueBase(StorageTypePtr data, std::size_t capacity)
        : Base(reinterpret_cast<BaseStorageTypePtr>(data), capacity)
    {
        static_assert(sizeof(ValueType) == sizeof(BaseValueType),
            "The times must have identical size.");
    }
 
    ~CastWrapperQueueBase() noexcept = default;
 
    CastWrapperQueueBase& operator=(const CastWrapperQueueBase& other) = default;
    CastWrapperQueueBase& operator=(CastWrapperQueueBase&& other) = default;
 
    Reference front()
    {
        return reinterpret_cast<Reference>(Base::front());
    }
 
    ConstReference front() const
    {
        return reinterpret_cast<ConstReference>(Base::front());
    }
 
    Reference back()
    {
        return reinterpret_cast<Reference>(Base::back());
    }
 
    ConstReference back() const
    {
        return reinterpret_cast<Reference>(Base::back());
    }
 
    Reference operator[](std::size_t index)
    {
        return reinterpret_cast<Reference>(Base::operator[](index));
    }
 
    ConstReference operator[](std::size_t index) const
    {
        return reinterpret_cast<ConstReference>(Base::operator[](index));
    }
 
    Reference at(std::size_t index)
    {
        return reinterpret_cast<Reference>(Base::at(index));
    }
 
    ConstReference at(std::size_t index) const
    {
        return reinterpret_cast<ConstReference>(Base::at(index));
    }
 
    int indexOf(ConstReference element) const
    {
        return Base::indexOf(reinterpret_cast<BaseConstReference>(element));
    }
 
    LinearisedIterator invalidIter()
    {
        return reinterpret_cast<LinearisedIterator>(Base::invalidIter());
    }
 
    ConstLinearisedIterator invalidIter() const
    {
        return reinterpret_cast<ConstLinearisedIterator>(Base::invalidIter());
    }
 
    ReverseLinearisedIterator invalidReverseIter()
    {
        return ReverseLinearisedIterator(
            reinterpret_cast<LinearisedIterator>(
                Base::invalidReverseIter().base()));
    }
 
    ConstReverseLinearisedIterator invalidReverseIter() const
    {
        return ConstReverseLinearisedIterator(
            reinterpret_cast<ConstLinearisedIterator>(
                Base::invalidReverseIter().base()));
    }
 
    LinearisedIterator lbegin()
    {
        return reinterpret_cast<LinearisedIterator>(Base::lbegin());
    }
 
    ConstLinearisedIterator lbegin() const
    {
        return reinterpret_cast<ConstLinearisedIterator>(Base::lbegin());
    }
 
    ConstLinearisedIterator clbegin() const
    {
        return reinterpret_cast<ConstLinearisedIterator>(Base::clbegin());
    }
 
    ReverseLinearisedIterator rlbegin()
    {
        return ReverseLinearisedIterator(
            reinterpret_cast<LinearisedIterator>(
                Base::rlbegin().base()));
    }
 
    ConstReverseLinearisedIterator rlbegin() const
    {
        return ConstReverseLinearisedIterator(
            reinterpret_cast<ConstLinearisedIterator>(
                Base::rlbegin().base()));
    }
 
    ConstReverseLinearisedIterator crlbegin() const
    {
        return ConstReverseLinearisedIterator(
            reinterpret_cast<ConstLinearisedIterator>(
                Base::crlbegin().base()));
    }
 
    LinearisedIterator lend()
    {
        return reinterpret_cast<LinearisedIterator>(Base::lend());
    }
 
    ConstLinearisedIterator lend() const
    {
        return reinterpret_cast<ConstLinearisedIterator>(Base::lend());
    }
 
    ConstLinearisedIterator clend() const
    {
        return reinterpret_cast<ConstLinearisedIterator>(Base::clend());
    }
 
    ReverseLinearisedIterator rlend()
    {
        return ReverseLinearisedIterator(
            reinterpret_cast<LinearisedIterator>(
                Base::rlend().base()));
    }
 
    ConstReverseLinearisedIterator rlend() const
    {
        return ConstReverseLinearisedIterator(
            reinterpret_cast<ConstLinearisedIterator>(
                Base::rlend().base()));
    }
 
    ConstReverseLinearisedIterator crlend() const
    {
        return ConstReverseLinearisedIterator(
            reinterpret_cast<ConstLinearisedIterator>(
                Base::crlend().base()));
    }
 
    LinearisedIteratorRange arrayOne()
    {
        auto range = Base::arrayOne();
        return LinearisedIteratorRange(
            reinterpret_cast<LinearisedIterator>(range.first),
            reinterpret_cast<LinearisedIterator>(range.second));
    }
 
    ConstLinearisedIteratorRange arrayOne() const
    {
        auto range = Base::arrayOne();
        return ConstLinearisedIteratorRange(
            reinterpret_cast<ConstLinearisedIterator>(range.first),
            reinterpret_cast<ConstLinearisedIterator>(range.second));
 
    }
 
    LinearisedIteratorRange arrayTwo()
    {
        auto range = Base::arrayTwo();
        return LinearisedIteratorRange(
            reinterpret_cast<LinearisedIterator>(range.first),
            reinterpret_cast<LinearisedIterator>(range.second));
 
    }
 
    ConstLinearisedIteratorRange arrayTwo() const
    {
        auto range = Base::arrayTwo();
        return ConstLinearisedIteratorRange(
            reinterpret_cast<ConstLinearisedIterator>(range.first),
            reinterpret_cast<ConstLinearisedIterator>(range.second));
 
    }
 
    LinearisedIterator erase(LinearisedIterator pos)
    {
        return reinterpret_cast<LinearisedIterator>(
            Base::erase(
                reinterpret_cast<BaseLinearisedIterator>(pos)));
    }
 
    Iterator erase(Iterator pos)
    {
        auto tmp = Base::erase(pos);
        return *(reinterpret_cast<Iterator*>(&tmp));
    }
 
    Iterator begin()
    {
        auto tmp = Base::begin();
        return *(reinterpret_cast<Iterator*>(&tmp));
    }
 
    ConstIterator begin() const
    {
        auto tmp = Base::begin();
        return *(reinterpret_cast<ConstIterator*>(&tmp));
    }
 
    ConstIterator cbegin() const
    {
        auto tmp = Base::cbegin();
        return *(reinterpret_cast<ConstIterator*>(&tmp));
 
    }
 
    Iterator end()
    {
        auto tmp = Base::end();
        return *(reinterpret_cast<Iterator*>(&tmp));
    }
 
    ConstIterator end() const
    {
        auto tmp = Base::end();
        return *(reinterpret_cast<ConstIterator*>(&tmp));
    }
 
    ConstIterator cend() const
    {
        auto tmp = Base::cend();
        return *(reinterpret_cast<ConstIterator*>(&tmp));
    }
 
    void pushBack(ConstReference value)
    {
        Base::pushBack(reinterpret_cast<BaseConstReference>(value));
    }
 
    void pushFront(ConstReference value)
    {
        Base::pushFront(reinterpret_cast<BaseConstReference>(value));
    }
 
    LinearisedIterator insert(LinearisedIterator pos, ConstReference value)
    {
        return reinterpret_cast<LinearisedIterator>(
            Base::insert(
                reinterpret_cast<BaseLinearisedIterator>(pos),
                reinterpret_cast<BaseConstReference>(value)));
    }
 
    void assignElements(const CastWrapperQueueBase& other)
    {
        Base::assignElements(static_cast<const Base&>(other));
    }
 
    void assignElements(CastWrapperQueueBase&& other)
    {
        Base::assignElements(static_cast<Base&&>(std::move(other)));
    }
};
 
template <typename TWrapperElemType, typename TQueueElemType>
class CastWrapperQueueBase<TWrapperElemType, TQueueElemType>::ConstIterator :
                            public StaticQueueBase<TQueueElemType>::ConstIterator
{
    using Base = typename StaticQueueBase<TQueueElemType>::ConstIterator;
public:
    ConstIterator(const ConstIterator&) = default;
    ConstIterator& operator=(const ConstIterator&) = default;
    ~ConstIterator() noexcept = default;
 
protected:
    using ExpectedQueueType = const StaticQueueBase<TWrapperElemType>;
    using ActualQueueType = const StaticQueueBase<TQueueElemType>;
    using ValueType = TWrapperElemType;
    using Reference = const ValueType&;
    using ConstReference = const ValueType&;
    using Pointer = const ValueType*;
    using ConstPointer = const ValueType*;
    using DifferenceType = typename Base::DifferenceType;
 
    ConstIterator(ExpectedQueueType& queue, Pointer iterator)
        : Base(reinterpret_cast<ActualQueueType&>(queue), iterator)
    {
    }
 
    ConstIterator& operator++()
    {
        Base::operator++();
        return *this;
    }
 
    ConstIterator operator++(int dummy)
    {
        auto tmp = Base::operator++(dummy);
        return *(static_cast<ConstIterator*>(&tmp));
    }
 
    ConstIterator& operator--()
    {
        Base::operator--();
        return *this;
    }
 
    ConstIterator operator--(int dummy)
    {
        auto tmp = Base::operator--(dummy);
        return *(static_cast<ConstIterator*>(&tmp));
    }
 
    ConstIterator& operator+=(DifferenceType value)
    {
        Base::operator+=(value);
        return *this;
    }
 
    ConstIterator& operator-=(DifferenceType value)
    {
        Base::operator-=(value);
        return *this;
    }
 
    ConstIterator operator+(DifferenceType value) const
    {
        auto tmp = Base::operator+(value);
        return *(static_cast<ConstIterator*>(&tmp));
    }
 
    ConstIterator operator-(DifferenceType value) const
    {
        auto tmp = Base::operator-(value);
        return *(static_cast<ConstIterator*>(&tmp));
    }
 
    DifferenceType operator-(const ConstIterator& other) const
    {
        return Base::operator-(other);
    }
 
    Reference operator*()
    {
        auto& ref = Base::operator*();
        return reinterpret_cast<Reference>(ref);
    }
 
    ConstReference operator*() const
    {
        auto& ref = Base::operator*();
        return reinterpret_cast<ConstReference>(ref);
    }
 
    Pointer operator->()
    {
        auto* ptr = Base::operator->();
        return reinterpret_cast<Pointer>(ptr);
    }
 
    ConstPointer operator->() const
    {
        auto* ptr = Base::operator->();
        return reinterpret_cast<ConstPointer>(ptr);
    }
};
 
template <typename TWrapperElemType, typename TQueueElemType>
class CastWrapperQueueBase<TWrapperElemType, TQueueElemType>::Iterator :
                            public StaticQueueBase<TQueueElemType>::Iterator
{
    using Base = typename StaticQueueBase<TQueueElemType>::Iterator;
public:
    Iterator(const Iterator&) = default;
    Iterator& operator=(const Iterator&) = default;
    ~Iterator() noexcept = default;
 
protected:
    using ExpectedQueueType = const StaticQueueBase<TWrapperElemType>;
    using ActualQueueType = const StaticQueueBase<TQueueElemType>;
    using ValueType = TWrapperElemType;
    using Reference = ValueType&;
    using ConstReference = const ValueType&;
    using Pointer = ValueType*;
    using ConstPointer = const ValueType*;
    using DifferenceType = typename Base::DifferenceType;
 
    Iterator(ExpectedQueueType& queue, Pointer iterator)
        : Base(reinterpret_cast<ActualQueueType&>(queue), iterator)
    {
    }
 
    Iterator& operator++()
    {
        Base::operator++();
        return *this;
    }
 
    Iterator operator++(int dummy)
    {
        auto tmp = Base::operator++(dummy);
        return *(static_cast<Iterator*>(&tmp));
    }
 
    Iterator& operator--()
    {
        Base::operator--();
        return *this;
    }
 
    Iterator operator--(int dummy)
    {
        auto tmp = Base::operator--(dummy);
        return *(static_cast<Iterator*>(&tmp));
    }
 
    Iterator& operator+=(DifferenceType value)
    {
        Base::operator+=(value);
        return *this;
    }
 
    Iterator& operator-=(DifferenceType value)
    {
        Base::operator-=(value);
        return *this;
    }
 
    Iterator operator+(DifferenceType value) const
    {
        auto tmp = Base::operator+(value);
        return *(static_cast<Iterator*>(&tmp));
    }
 
    Iterator operator-(DifferenceType value) const
    {
        auto tmp = Base::operator-(value);
        return *(static_cast<Iterator*>(&tmp));
    }
 
    DifferenceType operator-(const Iterator& other) const
    {
        return Base::operator-(other);
    }
 
    Reference operator*()
    {
        auto& ref = Base::operator*();
        return reinterpret_cast<Reference>(ref);
    }
 
    ConstReference operator*() const
    {
        auto& ref = Base::operator*();
        return reinterpret_cast<ConstReference>(ref);
    }
 
    Pointer operator->()
    {
        auto* ptr = Base::operator->();
        return reinterpret_cast<Pointer>(ptr);
    }
 
    ConstPointer operator->() const
    {
        auto* ptr = Base::operator->();
        return reinterpret_cast<ConstPointer>(ptr);
    }
};
 
template <typename T>
class StaticQueueBaseOptimised : public StaticQueueBase<T>
{
    usign Base = StaticQueueBase<T>;
protected:
 
    using StorageTypePtr = typename Base::StorageTypePtr;
 
    StaticQueueBaseOptimised(StorageTypePtr data, std::size_t capacity)
        : Base(data, capacity)
    {
    }
 
    ~StaticQueueBaseOptimised() noexcept = default;
 
    StaticQueueBaseOptimised& operator=(const StaticQueueBaseOptimised& other) = default;
    StaticQueueBaseOptimised& operator=(StaticQueueBaseOptimised&& other) = default;
};
 
template <>
class StaticQueueBaseOptimised<std::int8_t> : public CastWrapperQueueBase<std::int8_t, std::uint8_t>
{
    using Base = CastWrapperQueueBase<std::int8_t, std::uint8_t>;
protected:
 
    using StorageTypePtr = typename Base::StorageTypePtr;
 
    StaticQueueBaseOptimised(StorageTypePtr data, std::size_t capacity)
        : Base(data, capacity)
    {
    }
 
    ~StaticQueueBaseOptimised() noexcept = default;
    StaticQueueBaseOptimised& operator=(const StaticQueueBaseOptimised& other) = default;
    StaticQueueBaseOptimised& operator=(StaticQueueBaseOptimised&& other) = default;
};
 
template <>
class StaticQueueBaseOptimised<std::int16_t> : public CastWrapperQueueBase<std::int16_t, std::uint16_t>
{
    using Base = CastWrapperQueueBase<std::int16_t, std::uint16_t>;
protected:
 
    using StorageTypePtr = typename Base::StorageTypePtr;
 
    StaticQueueBaseOptimised(StorageTypePtr data, std::size_t capacity)
        : Base(data, capacity)
    {
    }
 
    ~StaticQueueBaseOptimised() noexcept = default;
    StaticQueueBaseOptimised& operator=(const StaticQueueBaseOptimised& other) = default;
    StaticQueueBaseOptimised& operator=(StaticQueueBaseOptimised&& other) = default;
};
 
template <>
class StaticQueueBaseOptimised<std::int32_t> : public CastWrapperQueueBase<std::int32_t, std::uint32_t>
{
    using Base = CastWrapperQueueBase<std::int32_t, std::uint32_t>;
protected:
 
    using StorageTypePtr = typename Base::StorageTypePtr;
 
    StaticQueueBaseOptimised(StorageTypePtr data, std::size_t capacity)
        : Base(data, capacity)
    {
    }
 
    ~StaticQueueBaseOptimised() noexcept = default;
    StaticQueueBaseOptimised& operator=(const StaticQueueBaseOptimised& other) = default;
    StaticQueueBaseOptimised& operator=(StaticQueueBaseOptimised&& other) = default;
};
 
template <>
class StaticQueueBaseOptimised<std::int64_t> : public CastWrapperQueueBase<std::int64_t, std::uint64_t>
{
    using Base = CastWrapperQueueBase<std::int64_t, std::uint64_t>;
protected:
 
    using StorageTypePtr = typename Base::StorageTypePtr;
 
    StaticQueueBaseOptimised(StorageTypePtr data, std::size_t capacity)
        : Base(data, capacity)
    {
    }
 
    ~StaticQueueBaseOptimised() noexcept = default;
    StaticQueueBaseOptimised& operator=(const StaticQueueBaseOptimised& other) = default;
    StaticQueueBaseOptimised& operator=(StaticQueueBaseOptimised&& other) = default;
};
 
template <typename T>
class StaticQueueBaseOptimised<T*> : public CastWrapperQueueBase<T*, typename comms::util::SizeToType<sizeof(T*)>::Type>
{
    using Base = CastWrapperQueueBase<T*, typename comms::util::SizeToType<sizeof(T*)>::Type>;
protected:
 
    using Base = typename Base::StorageTypePtr;
 
    StaticQueueBaseOptimised(StorageTypePtr data, std::size_t capacity)
        : Base(data, capacity)
    {
    }
 
    ~StaticQueueBaseOptimised() noexcept = default;
    StaticQueueBaseOptimised& operator=(const StaticQueueBaseOptimised& other) = default;
    StaticQueueBaseOptimised& operator=(StaticQueueBaseOptimised&& other) = default;
};
 
}  // namespace details
 
 
template <typename T, std::size_t TSize>
class StaticQueue : public details::StaticQueueBaseOptimised<T>
{
    using Base = details::StaticQueueBaseOptimised<T>;
 
    using StorageType = typename Base::StorageType;
public:
    using ValueType = typename Base::ValueType;
 
    using value_type = ValueType;
 
    using SizeType = typename Base::SizeType;
 
    using size_type = SizeType;
 
    using Reference = typename Base::Reference;
 
    using reference = Reference;
 
    using ConstReference = typename Base::ConstReference;
 
    using const_reference = ConstReference;
 
    using Pointer = typename Base::Pointer;
 
    using pointer = Pointer;
 
    using ConstPointer = typename Base::ConstPointer;
 
    using const_pointer = ConstPointer;
 
    using LinearisedIterator = typename Base::LinearisedIterator;
 
    using ConstLinearisedIterator = typename Base::ConstLinearisedIterator;
 
    using ReverseLinearisedIterator = typename Base::ReverseLinearisedIterator;
 
    using ConstReverseLinearisedIterator = typename Base::ConstReverseLinearisedIterator;
 
    using LinearisedIteratorRange = typename Base::LinearisedIteratorRange;
 
    using ConstLinearisedIteratorRange = typename Base::ConstLinearisedIteratorRange;
 
    class ConstIterator;
 
    using const_iterator = ConstIterator;
 
    class Iterator;
 
    using iterator = Iterator;
 
    // Member functions
    StaticQueue()
        : Base(&m_array[0], TSize)
    {
    }
 
    StaticQueue(const StaticQueue& queue)
        : Base(&m_array[0], TSize)
    {
        Base::assignElements(queue);
    }
 
    StaticQueue(StaticQueue&& queue)
        : Base(&m_array[0], TSize)
    {
        Base::assignElements(std::move(queue));
    }
 
    template <std::size_t TAnySize>
    StaticQueue(const StaticQueue<T, TAnySize>& queue)
        : Base(&m_array[0], TSize)
    {
        Base::assignElements(queue);
    }
 
    template <std::size_t TAnySize>
    StaticQueue(StaticQueue<T, TAnySize>&& queue)
        : Base(&m_array[0], TSize)
    {
        Base::assignElements(std::move(queue));
    }
 
    ~StaticQueue() noexcept
    {
        clear();
    }
 
    StaticQueue& operator=(const StaticQueue& queue)
    {
        return static_cast<StaticQueue&>(Base::operator=(queue));
    }
 
    StaticQueue& operator=(StaticQueue&& queue)
    {
        return static_cast<StaticQueue&>(Base::operator=(std::move(queue)));
    }
 
    template <std::size_t TAnySize>
    StaticQueue& operator=(const StaticQueue<T, TAnySize>& queue)
    {
        return static_cast<StaticQueue&>(Base::operator=(queue));
    }
 
    template <std::size_t TAnySize>
    StaticQueue& operator=(StaticQueue<T, TAnySize>&& queue)
    {
        return static_cast<StaticQueue&>(Base::operator=(std::move(queue)));
    }
 
    static constexpr std::size_t capacity()
    {
        return TSize;
    }
 
    std::size_t size() const
    {
        return Base::size();
    }
 
    bool empty() const
    {
        return Base::empty();
    }
 
    bool isEmpty() const
    {
        return empty();
    }
 
    bool full() const
    {
        return Base::full();
    }
 
    bool isFull() const
    {
        return full();
    }
 
    void clear()
    {
        Base::clear();
    }
 
    void popBack()
    {
        Base::popBack();
    }
 
    inline void pop_back()
    {
        popBack();
    }
 
    void popBack(std::size_t count)
    {
        Base::popBack(count);
    }
 
    void pop_back(std::size_t count)
    {
        popBack(count);
    }
 
    void popFront()
    {
        Base::popFront();
    }
 
    inline void pop_front()
    {
        popFront();
    }
 
    void popFront(std::size_t count)
    {
        Base::popFront(count);
    }
 
    inline void pop_front(std::size_t count)
    {
        popFront(count);
    }
 
    template <typename U>
    void pushBack(U&& value)
    {
        Base::pushBack(std::forward<U>(value));
    }
 
    template <typename... TArgs>
    void emplaceBack(TArgs&&... args)
    {
        Base::emplaceBack(std::forward<TArgs>(args)...);
    }
 
    template <typename U>
    inline void push_back(U&& value)
    {
        pushBack(std::forward<U>(value));
    }
 
    template <typename U>
    void pushFront(U&& value)
    {
        Base::pushFront(std::forward<U>(value));
    }
 
    template <typename U>
    inline void push_front(U&& value)
    {
        pushFront(std::forward<U>(value));
    }
 
    template <typename U>
    LinearisedIterator insert(LinearisedIterator pos, U&& value)
    {
        return Base::insert(pos, std::forward<U>(value));
    }
 
    Reference front()
    {
        return Base::front();
    }
 
    ConstReference front() const
    {
        return Base::front();
    }
 
    Reference back()
    {
        return Base::back();
    }
 
    ConstReference back() const
    {
        return Base::back();
    }
 
    Reference operator[](std::size_t index)
    {
        return Base::operator[](index);
    }
 
    ConstReference operator[](std::size_t index) const
    {
        return Base::operator[](index);
    }
 
    Reference at(std::size_t index)
    {
        return Base::at(index);
    }
 
    ConstReference at(std::size_t index) const
    {
        return Base::at(index);
    }
 
    int indexOf(ConstReference element) const
    {
        return Base::indexOf(element);
    }
 
    LinearisedIterator invalidIter()
    {
        return Base::invalidIter();
    }
 
    ConstLinearisedIterator invalidIter() const
    {
        return Base::invalidIter();
    }
 
    ReverseLinearisedIterator invalidReverseIter()
    {
        return Base::invalidReverseIter();
    }
 
    ConstReverseLinearisedIterator invalidReverseIter() const
    {
        return Base::invalidReverseIter();
    }
 
    LinearisedIterator lbegin()
    {
        return Base::lbegin();
    }
 
    ConstLinearisedIterator lbegin() const
    {
        return Base::lbegin();
    }
 
    ConstLinearisedIterator clbegin() const
    {
        return Base::clbegin();
    }
 
    ReverseLinearisedIterator rlbegin()
    {
        return Base::rlbegin();
    }
 
    ConstReverseLinearisedIterator rlbegin() const
    {
        return Base::rlbegin();
    }
 
    ConstReverseLinearisedIterator crlbegin() const
    {
        return Base::crlbegin();
    }
 
    LinearisedIterator lend()
    {
        return Base::lend();
    }
 
    ConstLinearisedIterator lend() const
    {
        return Base::lend();
    }
 
    ConstLinearisedIterator clend() const
    {
        return Base::clend();
    }
 
    ReverseLinearisedIterator rlend()
    {
        return Base::rlend();
    }
 
    ConstReverseLinearisedIterator rlend() const
    {
        return Base::rlend();
    }
 
    ConstReverseLinearisedIterator crlend() const
    {
        return Base::crlend();
    }
 
    void linearise()
    {
        Base::linearise();
    }
 
    bool linearised() const
    {
        return Base::linearised();
    }
 
    bool isLinearised() const
    {
        return linearised();
    }
 
    LinearisedIteratorRange arrayOne()
    {
        return Base::arrayOne();
    }
 
    ConstLinearisedIteratorRange arrayOne() const
    {
        return Base::arrayOne();
    }
 
    LinearisedIteratorRange arrayTwo()
    {
        return Base::arrayTwo();
    }
 
    ConstLinearisedIteratorRange arrayTwo() const
    {
        return Base::arrayTwo();
    }
 
    void resize(std::size_t newSize)
    {
        Base::resize(newSize);
    }
 
    LinearisedIterator erase(LinearisedIterator pos)
    {
        return Base::erase(pos);
    }
 
    Iterator erase(Iterator pos)
    {
        auto iter = Base::erase(pos);
        return *(static_cast<Iterator*>(&iter));
    }
 
    Iterator begin()
    {
        auto iter = Base::begin();
        return *(static_cast<Iterator*>(&iter));
    }
 
    ConstIterator begin() const
    {
        auto iter = Base::begin();
        return *(static_cast<ConstIterator*>(&iter));
    }
 
    ConstIterator cbegin() const
    {
        auto iter = Base::cbegin();
        return *(static_cast<ConstIterator*>(&iter));
    }
 
    Iterator end()
    {
        auto iter = Base::end();
        return *(static_cast<Iterator*>(&iter));
    }
 
    ConstIterator end() const
    {
        auto iter = Base::end();
        return *(static_cast<ConstIterator*>(&iter));
    }
 
    ConstIterator cend() const
    {
        auto iter = Base::end();
        return *(static_cast<ConstIterator*>(&iter));
    }
 
    template <std::size_t TAnySize>
    bool operator==(const StaticQueue<T, TAnySize>& other) const
    {
        return Base::operator==(other);
    }
 
    template <std::size_t TAnySize>
    bool operator!=(const StaticQueue<T, TAnySize>& other) const
    {
        return Base::operator!=(other);
    }
 
private:
    using ArrayType = std::array<StorageType, TSize>;
    alignas(alignof(T)) ArrayType m_array;
};
 
template <typename T, std::size_t TSize>
class StaticQueue<T, TSize>::ConstIterator : public StaticQueue<T, TSize>::Base::ConstIterator
{
    using Base = typename StaticQueue<T, TSize>::Base::ConstIterator;
public:
 
    using IteratorCategory = typename Base::IteratorCategory;
 
    using iterator_category = IteratorCategory;
 
    using ValueType = typename Base::ValueType;
 
    using value_type = ValueType;
 
    using DifferenceType = typename Base::DifferenceType;
 
    using difference_type = DifferenceType;
 
    using Pointer = typename Base::Pointer;
 
    using pointer = Pointer;
 
    using ConstPointer = typename Base::ConstPointer;
 
    using Reference = typename Base::Reference;
 
    using reference = Reference;
 
    using ConstReference = typename Base::ConstReference;
 
    using QueueType = StaticQueue<T, TSize>;
 
    using ConstLinearisedIterator = typename QueueType::ConstLinearisedIterator;
 
    ConstIterator(const QueueType& queue, ConstLinearisedIterator iterator)
        : Base(queue, iterator)
    {
    }
 
    ConstIterator(const ConstIterator&) = default;
 
    ConstIterator& operator=(const ConstIterator& other)
    {
        return static_cast<ConstIterator&>(Base::operator=(other));
    }
 
    ConstIterator& operator++()
    {
        return static_cast<ConstIterator&>(Base::operator++());
    }
 
    ConstIterator operator++(int dummyParam)
    {
        auto tmp = Base::operator++(dummyParam);
        return *(static_cast<ConstIterator*>(&tmp));
    }
 
    ConstIterator& operator--()
    {
        return static_cast<ConstIterator&>(Base::operator--());
    }
 
    ConstIterator operator--(int dummyParam)
    {
        auto tmp = Base::operator--(dummyParam);
        return *(static_cast<ConstIterator*>(&tmp));
    }
 
    ConstIterator& operator+=(DifferenceType value)
    {
        return static_cast<ConstIterator&>(Base::operator+=(value));
    }
 
    ConstIterator& operator-=(DifferenceType value)
    {
        return static_cast<ConstIterator&>(Base::operator-=(value));
    }
 
    ConstIterator operator+(DifferenceType value) const
    {
        auto tmp = Base::operator+(value);
        return *(static_cast<ConstIterator*>(&tmp));
    }
 
    ConstIterator operator-(DifferenceType value) const
    {
        auto tmp = Base::operator-(value);
        return *(static_cast<ConstIterator*>(&tmp));
    }
 
    DifferenceType operator-(const ConstIterator& other) const
    {
        return Base::operator-(other);
    }
 
    bool operator==(const ConstIterator& other) const
    {
        return Base::operator==(other);
    }
 
    bool operator!=(const ConstIterator& other) const
    {
        return Base::operator!=(other);
    }
 
    bool operator<(const ConstIterator& other) const
    {
        return Base::operator<(other);
    }
 
    bool operator<=(const ConstIterator& other) const
    {
        return Base::operator<=(other);
    }
 
    bool operator>(const ConstIterator& other) const
    {
        return Base::operator>(other);
    }
 
    bool operator>=(const ConstIterator& other) const
    {
        return Base::operator>=(other);
    }
 
    Reference operator*()
    {
        return Base::operator*();
    }
 
    ConstReference operator*() const
    {
        return Base::operator*();
    }
 
    Pointer operator->()
    {
        return Base::operator->();
    }
 
    ConstPointer operator->() const
    {
        return Base::operator->();
    }
};
 
template <typename T, std::size_t TSize>
class StaticQueue<T, TSize>::Iterator : public StaticQueue<T, TSize>::Base::Iterator
{
    using Base = typename StaticQueue<T, TSize>::Base::Iterator;
public:
 
    using IteratorCategory = typename Base::IteratorCategory;
 
    using iterator_category = IteratorCategory;
 
    using ValueType = typename Base::ValueType;
 
    using value_type = ValueType;
 
    using DifferenceType = typename Base::DifferenceType;
 
    using difference_type = DifferenceType;
 
    using Pointer = typename Base::Pointer;
 
    using pointer = Pointer;
 
    using ConstPointer = typename Base::ConstPointer;
 
    using Reference = typename Base::Reference;
 
    using reference = Reference;
 
    using ConstReference = typename Base::ConstReference;
 
    using QueueType = StaticQueue<T, TSize>;
 
    using LinearisedIterator = typename QueueType::LinearisedIterator;
 
    using ConstLinearisedIterator = typename QueueType::ConstLinearisedIterator;
 
    Iterator(QueueType& queue, LinearisedIterator iterator)
        : Base(queue, iterator)
    {
    }
 
    Iterator(const Iterator&) = default;
 
    Iterator& operator=(const Iterator& other)
    {
        return static_cast<Iterator&>(Base::operator=(other));
    }
 
    Iterator& operator++()
    {
        return static_cast<Iterator&>(Base::operator++());
    }
 
    Iterator operator++(int dummyParam)
    {
        auto tmp = Base::operator++(dummyParam);
        return *(static_cast<Iterator*>(&tmp));
    }
 
    Iterator& operator--()
    {
        return static_cast<Iterator&>(Base::operator--());
    }
 
    Iterator operator--(int dummyParam)
    {
        auto tmp = Base::operator--(dummyParam);
        return *(static_cast<Iterator*>(&tmp));
    }
 
    Iterator& operator+=(DifferenceType value)
    {
        return static_cast<Iterator&>(Base::operator+=(value));
    }
 
    Iterator& operator-=(DifferenceType value)
    {
        return static_cast<Iterator&>(Base::operator-=(value));
    }
 
    Iterator operator+(DifferenceType value) const
    {
        auto tmp = Base::operator+(value);
        return *(static_cast<Iterator*>(&tmp));
    }
 
    Iterator operator-(DifferenceType value) const
    {
        auto tmp = Base::operator-(value);
        return *(static_cast<Iterator*>(&tmp));
    }
 
    DifferenceType operator-(const Iterator& other) const
    {
        return Base::operator-(other);
    }
 
    bool operator==(const Iterator& other) const
    {
        return Base::operator==(other);
    }
 
    bool operator!=(const Iterator& other) const
    {
        return Base::operator!=(other);
    }
 
    bool operator<(const Iterator& other) const
    {
        return Base::operator<(other);
    }
 
    bool operator<=(const Iterator& other) const
    {
        return Base::operator<=(other);
    }
 
    bool operator>(const Iterator& other) const
    {
        return Base::operator>(other);
    }
 
    bool operator>=(const Iterator& other) const
    {
        return Base::operator>=(other);
    }
 
    Reference operator*()
    {
        return Base::operator*();
    }
 
    ConstReference operator*() const
    {
        return Base::operator*();
    }
 
    Pointer operator->()
    {
        return Base::operator->();
    }
 
    ConstPointer operator->() const
    {
        return Base::operator->();
    }
 
    operator ConstIterator() const
    {
        auto iter = static_cast<ConstLinearisedIterator>(Base::getIterator());
        const auto& queue = static_cast<QueueType&>(Base::getQueue());
        return ConstIterator(queue, iter);
    }
};
 
 
}  // namespace util
 
}  // namespace comms
 
COMMS_MSVC_WARNING_POP