bytes.hpp

// EVMC: Ethereum Client-VM Connector API.
// Copyright 2024 The EVMC Authors.
// Licensed under the Apache License, Version 2.0.
#pragma once
 
#include <algorithm>
#include <cstring>
#include <string>
#include <string_view>
 
namespace evmc
{
template <typename T>
struct byte_traits : std::char_traits<char>
{
    static_assert(sizeof(T) == 1, "type must be a byte");
 
    using char_type = T;  
 
    static constexpr void assign(char_type& c1, const char_type& c2) { c1 = c2; }
 
    static constexpr char_type* assign(char_type* ptr, std::size_t count, char_type value)
    {
        std::fill_n(ptr, count, value);
        return ptr;
    }
 
    static constexpr bool eq(char_type a, char_type b) { return a == b; }
 
    static constexpr bool lt(char_type a, char_type b) { return a < b; }
 
    static constexpr char_type* move(char_type* dest, const char_type* src, std::size_t count)
    {
        if (dest < src)
            std::copy_n(src, count, dest);
        else if (src < dest)
            std::copy_backward(src, src + count, dest + count);
        return dest;
    }
 
    static constexpr char_type* copy(char_type* dest, const char_type* src, std::size_t count)
    {
        std::copy_n(src, count, dest);
        return dest;
    }
 
    static constexpr int compare(const char_type* a, const char_type* b, std::size_t count)
    {
        for (; count != 0; --count, ++a, ++b)
        {
            if (lt(*a, *b))
                return -1;
            if (lt(*b, *a))
                return 1;
        }
        return 0;
    }
 
    // TODO: Not constexpr
    static std::size_t length(const char_type* s)
    {
        return std::strlen(reinterpret_cast<const char*>(s));
    }
 
    static constexpr const char_type* find(const char_type* s,
                                           std::size_t count,
                                           const char_type& value)
    {
        const auto end = s + count;
        const auto p = std::find(s, end, value);
        return p != end ? p : nullptr;
    }
};
 
using bytes = std::basic_string<unsigned char, byte_traits<unsigned char>>;
 
using bytes_view = std::basic_string_view<unsigned char, byte_traits<unsigned char>>;
}  // namespace evmc