ByteSpan.h

Go to the documentation of this file.

// Copyright Onix Solutions Limited [OnixS]. All rights reserved.
//
// This software owned by Onix Solutions Limited [OnixS] and is protected by copyright law
// and international copyright treaties.
//
// Access to and use of the software is governed by the terms of the applicable OnixS Software
// Services Agreement (the Agreement) and Customer end user license agreements granting
// a non-assignable, non-transferable and non-exclusive license to use the software
// for it's own data processing purposes under the terms defined in the Agreement.
//
// Except as otherwise granted within the terms of the Agreement, copying or reproduction of any part
// of this source code or associated reference material to any other location for further reproduction
// or redistribution, and any amendments to this copyright notice, are expressly prohibited.
//
// Any reproduction or redistribution for sale or hiring of the Software not in accordance with
// the terms of the Agreement is a violation of copyright law.
//
#pragma once
 
#include <OnixS/CME/MDH/ABI.h>
 
#if defined(ONIXS_CMEMDH_CXX20)
#include <span>
#endif
 
#include <array>
#include <cassert>
#include <cstddef>
#include <cstdint>
#include <iterator>
#include <string>
#include <type_traits>
#include <utility>
 
ONIXS_CME_MDH_TESTING_NAMESPACE_BEGIN
 
#if defined(ONIXS_CMEMDH_CXX20)

using ByteSpan = std::span<const std::uint8_t>;
 
#else
 
namespace ByteSpanDetails {
 
template <class Value>
constexpr Value* toAddress(Value* value) noexcept
{
    return value;
}
 
template <class Iterator>
auto toAddress(const Iterator& value) noexcept(noexcept(value.operator->()))
    -> decltype(value.operator->())
{
    return value.operator->();
}
 
} // namespace ByteSpanDetails

class ByteSpan
{
public:
    using element_type = const std::uint8_t;

    using value_type = typename std::remove_cv<element_type>::type;

    using size_type = std::size_t;

    using difference_type = std::ptrdiff_t;

    using pointer = element_type*;

    using const_pointer = const element_type*;

    using reference = element_type&;

    using const_reference = const element_type&;

    using iterator = pointer;

    using reverse_iterator = std::reverse_iterator<iterator>;
 
    enum : size_type
    {
        extent = static_cast<size_type>(-1)
    };

    constexpr ByteSpan() noexcept
        : data_(nullptr)
        , size_(0)
    {
    }

    template <
        class Data,
        typename std::enable_if<
            std::is_pointer<Data>::value && std::is_convertible<Data, pointer>::value,
            int
        >::type = 0
    >
    constexpr ByteSpan(Data data, size_type size) noexcept
        : data_(static_cast<pointer>(data))
        , size_(size)
    {
    }

    template <
        class First,
        class End,
        typename std::enable_if<
            std::is_pointer<First>::value && std::is_convertible<First, pointer>::value &&
                std::is_pointer<End>::value && std::is_convertible<End, pointer>::value,
            int
        >::type = 0
    >
    constexpr ByteSpan(First first, End last) noexcept
        : data_(static_cast<pointer>(first))
        , size_(first == nullptr
                    ? 0
                    : static_cast<size_type>(static_cast<pointer>(last) - static_cast<pointer>(first)))
    {
    }

    template <
        class Iterator,
        typename std::enable_if<
            !std::is_pointer<Iterator>::value &&
                std::is_convertible<
                    decltype(ByteSpanDetails::toAddress(std::declval<const Iterator&>())),
                    pointer
                >::value,
            int
        >::type = 0
    >
    ByteSpan(Iterator first, size_type size) noexcept(noexcept(ByteSpanDetails::toAddress(first)))
        : data_(size == 0 ? nullptr : static_cast<pointer>(ByteSpanDetails::toAddress(first)))
        , size_(size)
    {
    }

    template <
        class Iterator,
        class End,
        typename std::enable_if<
            !std::is_pointer<Iterator>::value &&
                std::is_convertible<
                    decltype(ByteSpanDetails::toAddress(std::declval<const Iterator&>())),
                    pointer
                >::value &&
                std::is_convertible<
                    decltype(std::declval<End>() - std::declval<Iterator>()),
                    difference_type
                >::value,
            int
        >::type = 0
    >
    ByteSpan(Iterator first, End last)
        noexcept(noexcept(ByteSpanDetails::toAddress(first)) && noexcept(last - first))
        : data_(nullptr)
        , size_(static_cast<size_type>(last - first))
    {
        if (size_ != 0)
        {
            data_ = static_cast<pointer>(ByteSpanDetails::toAddress(first));
        }
    }

    template <size_type Count>
    constexpr ByteSpan(const value_type (&array)[Count]) noexcept
        : data_(array)
        , size_(Count)
    {
    }

    template <size_type Count>
    ByteSpan(const std::array<value_type, Count>& array) noexcept
        : data_(array.data())
        , size_(Count)
    {
    }

    template <
        class Range,
        typename std::enable_if<
            !std::is_same<typename std::decay<Range>::type, ByteSpan>::value &&
                std::is_convertible<
                    decltype(std::declval<Range>().data()),
                    pointer
                >::value &&
                std::is_convertible<
                    decltype(std::declval<Range>().size()),
                    size_type
                >::value,
            int
        >::type = 0
    >
    ByteSpan(Range&& range)
        noexcept(
            noexcept(std::forward<Range>(range).data()) &&
            noexcept(std::forward<Range>(range).size()))
        : data_(static_cast<pointer>(std::forward<Range>(range).data()))
        , size_(static_cast<size_type>(std::forward<Range>(range).size()))
    {
    }

    constexpr iterator begin() const noexcept
    {
        return data_;
    }

    constexpr iterator end() const noexcept
    {
        return pointerAt(size_);
    }

    reverse_iterator rbegin() const noexcept
    {
        return reverse_iterator(end());
    }

    reverse_iterator rend() const noexcept
    {
        return reverse_iterator(begin());
    }

    constexpr reference operator[](size_type index) const noexcept
    {
        return data_[index];
    }

    reference front() const noexcept
    {
        assert(!empty());
        return data_[0];
    }

    reference back() const noexcept
    {
        assert(!empty());
        return data_[size_ - 1];
    }

    constexpr pointer data() const noexcept
    {
        return data_;
    }

    constexpr size_type size() const noexcept
    {
        return size_;
    }

    constexpr size_type size_bytes() const noexcept
    {
        return size_ * sizeof(element_type);
    }

    constexpr bool empty() const noexcept
    {
        return size_ == 0;
    }

    template <size_type Count>
    ByteSpan first() const noexcept
    {
        assert(Count <= size_);
        return ByteSpan(data_, Count);
    }

    ByteSpan first(size_type count) const noexcept
    {
        assert(count <= size_);
        return ByteSpan(data_, count);
    }

    template <size_type Count>
    ByteSpan last() const noexcept
    {
        assert(Count <= size_);
        return ByteSpan(pointerAt(size_ - Count), Count);
    }

    ByteSpan last(size_type count) const noexcept
    {
        assert(count <= size_);
        return ByteSpan(pointerAt(size_ - count), count);
    }

    template <size_type Offset, size_type Count = extent>
    ByteSpan subspan() const noexcept
    {
        assert(Offset <= size_);
        const size_type count = Count == extent ? size_ - Offset : Count;
        assert(count <= size_ - Offset);
        return ByteSpan(pointerAt(Offset), count);
    }

    ByteSpan subspan(size_type offset, size_type count = extent) const noexcept
    {
        assert(offset <= size_);
        const size_type actualCount = count == extent ? size_ - offset : count;
        assert(actualCount <= size_ - offset);
        return ByteSpan(pointerAt(offset), actualCount);
    }
 
private:
    constexpr pointer pointerAt(size_type offset) const noexcept
    {
        return data_ == nullptr ? nullptr : data_ + offset;
    }
 
    pointer data_;
    size_type size_;
};
 
#endif

ONIXS_CMEMDH_EXPORTED
void toStr(std::string& str, ByteSpan span);

inline std::string toStr(ByteSpan span)
{
    std::string str;
 
    toStr(str, span);
 
    return str;
}

ONIXS_CMEMDH_EXPORTED
void toStr(std::string& str, const ByteSpan spans[], size_t spansCount);

inline std::string toStr(const ByteSpan spans[], size_t spansCount)
{
    std::string str;
 
    toStr(str, spans, spansCount);
 
    return str;
}
 
ONIXS_CME_MDH_TESTING_NAMESPACE_END