view.hpp

Go to the documentation of this file.

 
#ifndef JOIN_CORE_VIEW_HPP
#define JOIN_CORE_VIEW_HPP
 
// C++.
#include <type_traits>
#include <string_view>
#include <algorithm>
#include <concepts>
#include <compare>
#include <limits>
 
// C.
#include <cassert>
#include <cstdint>
#include <cstddef>
 
namespace join
{
    template <typename Type>
    class __attribute__ ((packed)) View
    {
    public:
        constexpr View () noexcept = default;
 
        constexpr View (Type* data, size_t size) noexcept
        : _data (data)
        , _size (static_cast<uint32_t> (size))
        {
            assert (size <= std::numeric_limits<uint32_t>::max ());
        }
 
        constexpr Type* data () const noexcept
        {
            return _data;
        }
 
        constexpr size_t size () const noexcept
        {
            return _size;
        }
 
        constexpr bool empty () const noexcept
        {
            return _size == 0;
        }
 
        constexpr Type* begin () const noexcept
        {
            return _data;
        }
 
        constexpr Type* end () const noexcept
        {
            return _data + _size;
        }
 
        constexpr Type& operator[] (size_t pos) const noexcept
        {
            return _data[pos];
        }
 
    private:
        Type* _data = nullptr;
 
        uint32_t _size = 0;
    };
 
    template <typename Type>
    constexpr bool operator== (const View<Type>& lhs, const View<Type>& rhs)
    {
        return std::equal (lhs.begin (), lhs.end (), rhs.begin (), rhs.end ());
    }
 
    template <typename Type>
    constexpr std::partial_ordering operator<=> (const View<Type>& lhs, const View<Type>& rhs)
    {
        return std::lexicographical_compare_three_way (lhs.begin (), lhs.end (), rhs.begin (), rhs.end ());
    }
 
    template <typename Type>
        requires std::same_as<std::remove_const_t<Type>, char>
    constexpr bool operator== (const View<Type>& lhs, const View<Type>& rhs)
    {
        return std::string_view (lhs.data (), lhs.size ()) == std::string_view (rhs.data (), rhs.size ());
    }
 
    template <typename Type>
        requires std::same_as<std::remove_const_t<Type>, char>
    constexpr std::partial_ordering operator<=> (const View<Type>& lhs, const View<Type>& rhs)
    {
        return std::string_view (lhs.data (), lhs.size ()) <=> std::string_view (rhs.data (), rhs.size ());
    }
}
 
#endif