hexutils.hpp

Go to the documentation of this file.

#ifndef IROHA_HEXUTILS_HPP
#define IROHA_HEXUTILS_HPP

#include <iterator>
#include <string>

#include <boost/algorithm/hex.hpp>
#include <boost/optional.hpp>
#include "common/result.hpp"
#include "interfaces/common_objects/byte_range.hpp"

namespace iroha {

  template <typename Container>
  inline auto hexstringToBytestringSize(Container const &c)
      -> decltype(c.size()) {
    return (c.size() + 1) / 2;
  }

  template <typename Container>
  inline auto bytestringToHexstringSize(Container const &c)
      -> decltype(c.size()) {
    return c.size() * 2;
  }

  template <typename OutputContainer>
  inline void bytestringToHexstringAppend(
      shared_model::interface::types::ByteRange input,
      OutputContainer &destination) {
    static_assert(sizeof(*input.data()) == sizeof(uint8_t), "type mismatch");
    const auto beg = reinterpret_cast<const uint8_t *>(input.data());
    const auto end = beg + input.size();
    destination.reserve(destination.size() + bytestringToHexstringSize(input));
    boost::algorithm::hex_lower(beg, end, std::back_inserter(destination));
  }

  inline std::string bytestringToHexstring(std::string_view str) {
    std::string result;
    bytestringToHexstringAppend(
        shared_model::interface::types::makeByteRange(str), result);
    return result;
  }

  inline iroha::expected::Result<std::string, const char *>
  hexstringToBytestringResult(std::string_view str) {
    using namespace iroha::expected;
    if (str.empty()) {
      return makeError("Empty hex string.");
    }
    if (str.size() % 2 != 0) {
      return makeError("Hex string contains uneven number of characters.");
    }
    std::string result;
    result.reserve(hexstringToBytestringSize(str));
    try {
      boost::algorithm::unhex(
          str.begin(), str.end(), std::back_inserter(result));
    } catch (const boost::algorithm::hex_decode_error &e) {
      return makeError(e.what());
    }
    return iroha::expected::makeValue(std::move(result));
  }

  /*[[deprecated]]*/ inline boost::optional<std::string> hexstringToBytestring(
      std::string_view str) {
    return iroha::expected::resultToOptionalValue(
        hexstringToBytestringResult(str));
  }

  template <typename T,
            typename = std::enable_if_t<std::is_arithmetic<T>::value>>
  inline std::string numToHexstring(const T val) {
    std::stringstream ss;
    ss << std::hex << std::setfill('0') << std::setw(sizeof(T) * 2) << val;
    return ss.str();
  }

}  // namespace iroha

#endif  // IROHA_HEXUTILS_HPP