ArrayView.h

Go to the documentation of this file.

//
// Copyright 2017 - 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 <algorithm>
#include <iterator>
 
namespace comms
{
 
namespace util
{
 
template <typename T>
class ArrayView
{
public:
    using value_type = T;
 
    using ValueType = value_type;
 
    using pointer = T*;
 
    using Pointer = pointer;
 
    using const_pointer = const T*;
 
    using ConstPointer = const_pointer;
 
    using reference = T&;
 
    using Reference = reference;
 
    using const_reference = const T&;
 
    using ConstReference = const_reference;
 
    using size_type = std::size_t;
 
    using SizeType = size_type;
 
    using const_iterator = const_pointer;
 
    using ConstIterator = const_iterator;
 
    using iterator = const_iterator;
 
    using Iterator = iterator;
 
    using const_reverse_iterator = std::reverse_iterator<const_iterator>;
 
    using ConstReverseIterator = const_reverse_iterator;
 
    using reverse_iterator = const_reverse_iterator;
 
    using ReverseIterator = reverse_iterator;
 
    ArrayView() noexcept = default;
 
    ArrayView(const ArrayView&) noexcept = default;
 
    ArrayView(const_pointer data, size_type len) noexcept
      : m_data(data),
        m_len(len)
    {
    }
 
    template <typename TIter>
    ArrayView(TIter iter, size_type len) noexcept
      : m_data(reinterpret_cast<const_pointer>(&(*iter))),
        m_len(len)
    {
    }
 
    template <std::size_t TN>
    ArrayView(const T (&data)[TN]) noexcept
      : m_data(data),
        m_len(TN)
    {
    }
 
    template <std::size_t TN>
    ArrayView(T (&data)[TN]) noexcept
      : m_data(data),
        m_len(TN)
    {
    }
 
    template <typename TIter>
    ArrayView(TIter first, TIter last) noexcept
      : m_data(reinterpret_cast<const_pointer>(&(*first))),
        m_len(static_cast<std::size_t>(std::distance(first, last)))
    {
        COMMS_ASSERT(0 <= std::distance(first, last));
    }
 
    ~ArrayView() noexcept = default;
 
    ArrayView& operator=(const ArrayView&) = default;
 
    template <std::size_t TN>
    ArrayView& operator=(const T (&data)[TN])
    {
        m_data = data;
        m_len = TN;
        return *this;
    }
 
    template <std::size_t TN>
    ArrayView& operator=(T (&data)[TN])
    {
        m_data = data;
        m_len = TN;
        return *this;
    }
 
    constexpr const_iterator begin() const noexcept
    {
        return m_data;
    }
 
    constexpr const_iterator cbegin() const noexcept
    {
        return begin();
    }
 
    constexpr const_iterator end() const noexcept
    {
        return begin() + m_len;
    }
 
    constexpr const_iterator cend() const noexcept
    {
        return end();
    }
 
    const_reverse_iterator rbegin() const noexcept
    {
        return std::reverse_iterator<const_iterator>(end());
    }
 
    const_reverse_iterator crbegin() const noexcept
    {
        return rbegin();
    }
 
    reverse_iterator rend() const noexcept
    {
        return std::reverse_iterator<const_iterator>(begin());
    }
 
    const_reverse_iterator crend() const noexcept
    {
        return rend();
    }
 
    constexpr const_reference operator[](size_type pos) const
    {
        return m_data[pos];
    }
 
    const_reference at(size_type pos) const
    {
        COMMS_ASSERT(pos < m_len);
        return m_data[pos];
    }
 
    constexpr const_reference front() const
    {
        return m_data[0];
    }
 
    constexpr const_reference back() const
    {
        return m_data[m_len - 1U];
    }
 
    constexpr size_type size() const noexcept
    {
        return m_len;
    }
 
    constexpr size_type length() const noexcept
    {
        return size();
    }
 
    constexpr bool empty() const noexcept
    {
        return size() == 0U;
    }
 
    void remove_prefix(size_type n)
    {
        std::advance(m_data, n);
        m_len -= n;
    }
 
    void remove_suffix(size_type n)
    {
        m_len -= n;
    }
 
    void swap(ArrayView& other) noexcept
    {
        std::swap(m_data, other.m_data);
        std::swap(m_len, other.m_len);
    }
 
    const_pointer data() const
    {
        return m_data;
    }
 
private:
    const_pointer m_data = nullptr;
    size_type m_len = 0;
};
 
template<typename T>
bool operator<(const ArrayView<T>& view1, const ArrayView<T>& view2) noexcept
{
    return std::lexicographical_compare(view1.begin(), view1.end(), view2.begin(), view2.end());
}
 
template<typename T>
bool operator<=(const ArrayView<T>& view1, const ArrayView<T>& view2) noexcept
{
    return !(view2 < view1);
}
 
template<typename T>
bool operator>(const ArrayView<T>& view1, const ArrayView<T>& view2) noexcept
{
    return (view2 < view1);
}
 
template<typename T>
bool operator>=(const ArrayView<T>& view1, const ArrayView<T>& view2) noexcept
{
    return !(view1 < view2);
}
 
template<typename T>
bool operator==(const ArrayView<T>& view1, const ArrayView<T>& view2) noexcept
{
    return
        (view1.size() == view2.size()) &&
        std::equal(view1.begin(), view1.end(), view2.begin());
}
 
template<typename T>
bool operator!=(const ArrayView<T>& view1, const ArrayView<T>& view2) noexcept
{
    return !(view1 == view2);
}
 
} // namespace util
 
} // namespace comms
 
namespace std
{
 
template <typename T>
void swap(comms::util::ArrayView<T>& view1, comms::util::ArrayView<T>& view2)
{
    view1.swap(view2);
}
 
}  // namespace std