hexutil.hpp

Go to the documentation of this file.

#ifndef KAGOME_HEXUTIL_HPP
#define KAGOME_HEXUTIL_HPP

#include <string_view>
#include <vector>

#include <gsl/span>
#include "outcome/outcome.hpp"

namespace kagome::common {

  enum class UnhexError {
    NOT_ENOUGH_INPUT = 1,
    NON_HEX_INPUT,
    VALUE_OUT_OF_RANGE,
    MISSING_0X_PREFIX,
    UNKNOWN
  };

  std::string int_to_hex(uint64_t n, size_t fixed_width = 2) noexcept;

  std::string hex_upper(gsl::span<const uint8_t> bytes) noexcept;

  std::string hex_lower(gsl::span<const uint8_t> bytes) noexcept;

  std::string hex_lower_0x(gsl::span<const uint8_t> bytes) noexcept;

  inline std::string hex_lower_0x(const uint8_t *data, size_t size) noexcept {
    return hex_lower_0x(gsl::span<const uint8_t>(data, size));
  }

  outcome::result<std::vector<uint8_t>> unhex(std::string_view hex);

  outcome::result<std::vector<uint8_t>> unhexWith0x(std::string_view hex);

  template <class T, typename = std::enable_if<std::is_unsigned_v<T>>>
  outcome::result<T> unhexNumber(std::string_view value) {
    std::vector<uint8_t> bytes;
    OUTCOME_TRY(bts, common::unhexWith0x(value));
    bytes = std::move(bts);

    if (bytes.size() > sizeof(T)) {
      return UnhexError::VALUE_OUT_OF_RANGE;
    }

    T result{0u};
    for (auto b : bytes) {
      // check if `multiply by 10` will cause overflow
      if constexpr (sizeof(T) > 1) {
        result <<= 8u;
      } else {
        result = 0;
      }
      result += b;
    }

    return result;
  }

}  // namespace kagome::common

OUTCOME_HPP_DECLARE_ERROR(kagome::common, UnhexError);

#endif  // KAGOME_HEXUTIL_HPP