BinaryView.h

#ifndef TENDUKE_CORE_BINARYVIEW_H
#define TENDUKE_CORE_BINARYVIEW_H
 
#include "./DataSpan.h"
 
#include <cstring>
#include <limits>
#include <stdexcept>
#include <string>
 
namespace tenduke { namespace utl {

class BinaryView : public virtual ::tenduke::utl::DataSpan
{
public:
    BinaryView(
        const unsigned char *data,
        const std::size_t size
    ) : data_(data)
      , size_(size)
    {
    }

    const unsigned char * data() const override
    {
        return data_;
    }

    std::size_t size_bytes() const override
    {
        return size_;
    }
 
private:
    const unsigned char *data_;
    std::size_t size_;
};

inline BinaryView empty_view()
{
    return {nullptr, 0};
}

inline BinaryView make_view(
    const unsigned char* data,
    const std::size_t size
) {
    return {data, size};
}

template <std::size_t N>
inline BinaryView make_view(unsigned char (&arr)[N])
{
    return BinaryView(arr, N);
}

inline BinaryView make_view(const char *value)
{
    return {
        reinterpret_cast<const unsigned char*>(value),
        std::strlen((const char*)value)
    };
}

inline BinaryView make_view(const std::string &value)
{
    return {
        reinterpret_cast<const unsigned char*>(value.data()),
        value.size()
    };
}

inline BinaryView make_view(
    const ::tenduke::utl::DataSpan &value,
    const std::size_t offset,
    const std::size_t length = (std::numeric_limits<std::size_t>::max)()
)
{
    if (offset > value.size_bytes()) {
        throw std::out_of_range("offset is out of range");
    }
    const std::size_t remaining = value.size_bytes() - offset;
    const std::size_t actual = (length == (std::numeric_limits<std::size_t>::max)())
        ? remaining
        : length;
    if (actual > remaining) {
        throw std::out_of_range("length is out of range");
    }
    return {value.data() + offset, actual};
}
 
}}
 
#endif //TENDUKE_CORE_BINARYVIEW_H