ArrayView.h

Go to the documentation of this file.

//
// Copyright 2017 - 2024 (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 <algorithm>
#include <iterator>
 
#include "comms/Assert.h"
 
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
      : data_(data),
        len_(len)
    {
    }
 
    template <typename TIter>
    ArrayView(TIter iter, size_type len) noexcept
      : data_(reinterpret_cast<const_pointer>(&(*iter))),
        len_(len)
    {
    }
 
    template <std::size_t TN>
    ArrayView(const T (&data)[TN]) noexcept
      : data_(data),
        len_(TN)
    {
    }
 
    template <std::size_t TN>
    ArrayView(T (&data)[TN]) noexcept
      : data_(data),
        len_(TN)
    {
    }
 
    ~ArrayView() noexcept = default;
 
    ArrayView& operator=(const ArrayView&) = default;
 
    template <std::size_t TN>
    ArrayView& operator=(const T (&data)[TN])
    {
        data_ = data;
        len_ = TN;
        return *this;
    }
 
    template <std::size_t TN>
    ArrayView& operator=(T (&data)[TN])
    {
        data_ = data;
        len_ = TN;
        return *this;
    }
 
    constexpr const_iterator begin() const noexcept
    {
        return data_;
    }
 
    constexpr const_iterator cbegin() const noexcept
    {
        return begin();
    }
 
    constexpr const_iterator end() const noexcept
    {
        return begin() + 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 data_[pos];
    }
 
    const_reference at(size_type pos) const
    {
        COMMS_ASSERT(pos < len_);
        return data_[pos];
    }
 
    constexpr const_reference front() const
    {
        return data_[0];
    }
 
    constexpr const_reference back() const
    {
        return data_[len_ - 1U];
    }
 
    constexpr size_type size() const noexcept
    {
        return 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(data_, n);
        len_ -= n;
    }
 
    void remove_suffix(size_type n)
    {
        len_ -= n;
    }
 
    void swap(ArrayView& other) noexcept
    {
        std::swap(data_, other.data_);
        std::swap(len_, other.len_);
    }
 
 
private:
    const_pointer data_ = nullptr;
    size_type 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