Code moves

2018-03-24 23:54:20 +01:00
parent 41bc79b30b
commit 8eab244229
9 changed files with 26 additions and 742 deletions
@@ -1,84 +0,0 @@
-// Copyright (c) 2012-2013 The Cryptonote developers
-// Distributed under the MIT/X11 software license, see the accompanying
-// file COPYING or http://www.opensource.org/licenses/mit-license.php.
-
-#pragma once
-
-#include <boost/archive/binary_oarchive.hpp>
-#include <boost/archive/binary_iarchive.hpp>
-
-
-namespace tools
-{
-  template<class t_object>
-  bool serialize_obj_to_file(t_object& obj, const std::string& file_path)
-  {
-    TRY_ENTRY();
-#if defined(_MSC_VER)
-    // Need to know HANDLE of file to call FlushFileBuffers
-    HANDLE data_file_handle = ::CreateFile(file_path.c_str(), GENERIC_WRITE, 0, NULL, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL);
-    if (INVALID_HANDLE_VALUE == data_file_handle)
-      return false;
-
-    int data_file_descriptor = _open_osfhandle((intptr_t)data_file_handle, 0);
-    if (-1 == data_file_descriptor)
-    {
-      ::CloseHandle(data_file_handle);
-      return false;
-    }
-
-    FILE* data_file_file = _fdopen(data_file_descriptor, "wb");
-    if (0 == data_file_file)
-    {
-      // Call CloseHandle is not necessary
-      _close(data_file_descriptor);
-      return false;
-    }
-
-    // HACK: undocumented constructor, this code may not compile
-    std::ofstream data_file(data_file_file);
-    if (data_file.fail())
-    {
-      // Call CloseHandle and _close are not necessary
-      fclose(data_file_file);
-      return false;
-    }
-#else
-    std::ofstream data_file;
-    data_file.open(file_path , std::ios_base::binary | std::ios_base::out| std::ios::trunc);
-    if (data_file.fail())
-      return false;
-#endif
-
-    boost::archive::binary_oarchive a(data_file);
-    a << obj;
-    if (data_file.fail())
-      return false;
-
-    data_file.flush();
-#if defined(_MSC_VER)
-    // To make sure the file is fully stored on disk
-    ::FlushFileBuffers(data_file_handle);
-    fclose(data_file_file);
-#endif
-
-    return true;
-    CATCH_ENTRY_L0("serialize_obj_to_file", false);
-  }
-
-  template<class t_object>
-  bool unserialize_obj_from_file(t_object& obj, const std::string& file_path)
-  {
-    TRY_ENTRY();
-
-    std::ifstream data_file;  
-    data_file.open( file_path, std::ios_base::binary | std::ios_base::in);
-    if(data_file.fail())
-      return false;
-    boost::archive::binary_iarchive a(data_file);
-
-    a >> obj;
-    return !data_file.fail();
-    CATCH_ENTRY_L0("unserialize_obj_from_file", false);
-  }
-}
@@ -1,177 +0,0 @@
-// Copyright (c) 2012-2013 The Cryptonote developers
-// Distributed under the MIT/X11 software license, see the accompanying
-// file COPYING or http://www.opensource.org/licenses/mit-license.php.
-
-#pragma once
-
-#include <iostream>
-#include <type_traits>
-
-#include <boost/program_options/parsers.hpp>
-#include <boost/program_options/options_description.hpp>
-#include <boost/program_options/variables_map.hpp>
-#include "include_base_utils.h"
-
-namespace command_line
-{
-  template<typename T, bool required = false>
-  struct arg_descriptor;
-
-  template<typename T>
-  struct arg_descriptor<T, false>
-  {
-    typedef T value_type;
-
-    const char* name;
-    const char* description;
-    T default_value;
-    bool not_use_default;
-  };
-
-  template<typename T>
-  struct arg_descriptor<std::vector<T>, false>
-  {
-    typedef std::vector<T> value_type;
-
-    const char* name;
-    const char* description;
-  };
-
-  template<typename T>
-  struct arg_descriptor<T, true>
-  {
-    static_assert(!std::is_same<T, bool>::value, "Boolean switch can't be required");
-
-    typedef T value_type;
-
-    const char* name;
-    const char* description;
-  };
-
-  template<typename T>
-  boost::program_options::typed_value<T, char>* make_semantic(const arg_descriptor<T, true>& /*arg*/)
-  {
-    return boost::program_options::value<T>()->required();
-  }
-
-  template<typename T>
-  boost::program_options::typed_value<T, char>* make_semantic(const arg_descriptor<T, false>& arg)
-  {
-    auto semantic = boost::program_options::value<T>();
-    if (!arg.not_use_default)
-      semantic->default_value(arg.default_value);
-    return semantic;
-  }
-
-  template<typename T>
-  boost::program_options::typed_value<T, char>* make_semantic(const arg_descriptor<T, false>& arg, const T& def)
-  {
-    auto semantic = boost::program_options::value<T>();
-    if (!arg.not_use_default)
-      semantic->default_value(def);
-    return semantic;
-  }
-
-  template<typename T>
-  boost::program_options::typed_value<std::vector<T>, char>* make_semantic(const arg_descriptor<std::vector<T>, false>& /*arg*/)
-  {
-    auto semantic = boost::program_options::value< std::vector<T> >();
-    semantic->default_value(std::vector<T>(), "");
-    return semantic;
-  }
-
-  template<typename T, bool required>
-  void add_arg(boost::program_options::options_description& description, const arg_descriptor<T, required>& arg, bool unique = true)
-  {
-    if (0 != description.find_nothrow(arg.name, false))
-    {
-      CHECK_AND_ASSERT_MES(!unique, void(), "Argument already exists: " << arg.name);
-      return;
-    }
-
-    description.add_options()(arg.name, make_semantic(arg), arg.description);
-  }
-
-  template<typename T>
-  void add_arg(boost::program_options::options_description& description, const arg_descriptor<T, false>& arg, const T& def, bool unique = true)
-  {
-    if (0 != description.find_nothrow(arg.name, false))
-    {
-      CHECK_AND_ASSERT_MES(!unique, void(), "Argument already exists: " << arg.name);
-      return;
-    }
-
-    description.add_options()(arg.name, make_semantic(arg, def), arg.description);
-  }
-
-  template<>
-  inline void add_arg(boost::program_options::options_description& description, const arg_descriptor<bool, false>& arg, bool unique)
-  {
-    if (0 != description.find_nothrow(arg.name, false))
-    {
-      CHECK_AND_ASSERT_MES(!unique, void(), "Argument already exists: " << arg.name);
-      return;
-    }
-
-    description.add_options()(arg.name, boost::program_options::bool_switch(), arg.description);
-  }
-
-  template<typename charT>
-  boost::program_options::basic_parsed_options<charT> parse_command_line(int argc, const charT* const argv[],
-    const boost::program_options::options_description& desc, bool allow_unregistered = false)
-  {
-    auto parser = boost::program_options::command_line_parser(argc, argv);
-    parser.options(desc);
-    if (allow_unregistered)
-    {
-      parser.allow_unregistered();
-    }
-    return parser.run();
-  }
-
-  template<typename F>
-  bool handle_error_helper(const boost::program_options::options_description& desc, F parser)
-  {
-    try
-    {
-      return parser();
-    }
-    catch (std::exception& e)
-    {
-      std::cerr << "Failed to parse arguments: " << e.what() << std::endl;
-      std::cerr << desc << std::endl;
-      return false;
-    }
-    catch (...)
-    {
-      std::cerr << "Failed to parse arguments: unknown exception" << std::endl;
-      std::cerr << desc << std::endl;
-      return false;
-    }
-  }
-
-  template<typename T, bool required>
-  bool has_arg(const boost::program_options::variables_map& vm, const arg_descriptor<T, required>& arg)
-  {
-    auto value = vm[arg.name];
-    return !value.empty();
-  }
-
-
-  template<typename T, bool required>
-  T get_arg(const boost::program_options::variables_map& vm, const arg_descriptor<T, required>& arg)
-  {
-    return vm[arg.name].template as<T>();
-  }
- 
-  template<>
-  inline bool has_arg<bool, false>(const boost::program_options::variables_map& vm, const arg_descriptor<bool, false>& arg)
-  {
-    return get_arg<bool, false>(vm, arg);
-  }
-
-
-  extern const arg_descriptor<bool> arg_help;
-  extern const arg_descriptor<bool> arg_version;
-  extern const arg_descriptor<std::string> arg_data_dir;
-}
@@ -1,205 +0,0 @@
-// Copyright (c) 2012-2013 The Cryptonote developers
-// Distributed under the MIT/X11 software license, see the accompanying
-// file COPYING or http://www.opensource.org/licenses/mit-license.php.
-
-#pragma once
-
-#include <assert.h>
-#include <stdbool.h>
-#include <stdint.h>
-#include <string.h>
-#include <sys/param.h>
-
-#if defined(_MSC_VER)
-#include <stdlib.h>
-
-static inline uint32_t rol32(uint32_t x, int r) {
-  static_assert(sizeof(uint32_t) == sizeof(unsigned int), "this code assumes 32-bit integers");
-  return _rotl(x, r);
-}
-
-static inline uint64_t rol64(uint64_t x, int r) {
-  return _rotl64(x, r);
-}
-
-#else
-
-static inline uint32_t rol32(uint32_t x, int r) {
-  return (x << (r & 31)) | (x >> (-r & 31));
-}
-
-static inline uint64_t rol64(uint64_t x, int r) {
-  return (x << (r & 63)) | (x >> (-r & 63));
-}
-
-#endif
-
-static inline uint64_t hi_dword(uint64_t val) {
-  return val >> 32;
-}
-
-static inline uint64_t lo_dword(uint64_t val) {
-  return val & 0xFFFFFFFF;
-}
-
-static inline uint64_t mul128(uint64_t multiplier, uint64_t multiplicand, uint64_t* product_hi) {
-  // multiplier   = ab = a * 2^32 + b
-  // multiplicand = cd = c * 2^32 + d
-  // ab * cd = a * c * 2^64 + (a * d + b * c) * 2^32 + b * d
-  uint64_t a = hi_dword(multiplier);
-  uint64_t b = lo_dword(multiplier);
-  uint64_t c = hi_dword(multiplicand);
-  uint64_t d = lo_dword(multiplicand);
-
-  uint64_t ac = a * c;
-  uint64_t ad = a * d;
-  uint64_t bc = b * c;
-  uint64_t bd = b * d;
-
-  uint64_t adbc = ad + bc;
-  uint64_t adbc_carry = adbc < ad ? 1 : 0;
-
-  // multiplier * multiplicand = product_hi * 2^64 + product_lo
-  uint64_t product_lo = bd + (adbc << 32);
-  uint64_t product_lo_carry = product_lo < bd ? 1 : 0;
-  *product_hi = ac + (adbc >> 32) + (adbc_carry << 32) + product_lo_carry;
-  assert(ac <= *product_hi);
-
-  return product_lo;
-}
-
-static inline uint64_t div_with_reminder(uint64_t dividend, uint32_t divisor, uint32_t* remainder) {
-  dividend |= ((uint64_t)*remainder) << 32;
-  *remainder = dividend % divisor;
-  return dividend / divisor;
-}
-
-// Long division with 2^32 base
-static inline uint32_t div128_32(uint64_t dividend_hi, uint64_t dividend_lo, uint32_t divisor, uint64_t* quotient_hi, uint64_t* quotient_lo) {
-  uint64_t dividend_dwords[4];
-  uint32_t remainder = 0;
-
-  dividend_dwords[3] = hi_dword(dividend_hi);
-  dividend_dwords[2] = lo_dword(dividend_hi);
-  dividend_dwords[1] = hi_dword(dividend_lo);
-  dividend_dwords[0] = lo_dword(dividend_lo);
-
-  *quotient_hi  = div_with_reminder(dividend_dwords[3], divisor, &remainder) << 32;
-  *quotient_hi |= div_with_reminder(dividend_dwords[2], divisor, &remainder);
-  *quotient_lo  = div_with_reminder(dividend_dwords[1], divisor, &remainder) << 32;
-  *quotient_lo |= div_with_reminder(dividend_dwords[0], divisor, &remainder);
-
-  return remainder;
-}
-
-#define IDENT32(x) ((uint32_t) (x))
-#define IDENT64(x) ((uint64_t) (x))
-
-#define SWAP32(x) ((((uint32_t) (x) & 0x000000ff) << 24) | \
-  (((uint32_t) (x) & 0x0000ff00) <<  8) | \
-  (((uint32_t) (x) & 0x00ff0000) >>  8) | \
-  (((uint32_t) (x) & 0xff000000) >> 24))
-#define SWAP64(x) ((((uint64_t) (x) & 0x00000000000000ff) << 56) | \
-  (((uint64_t) (x) & 0x000000000000ff00) << 40) | \
-  (((uint64_t) (x) & 0x0000000000ff0000) << 24) | \
-  (((uint64_t) (x) & 0x00000000ff000000) <<  8) | \
-  (((uint64_t) (x) & 0x000000ff00000000) >>  8) | \
-  (((uint64_t) (x) & 0x0000ff0000000000) >> 24) | \
-  (((uint64_t) (x) & 0x00ff000000000000) >> 40) | \
-  (((uint64_t) (x) & 0xff00000000000000) >> 56))
-
-static inline uint32_t ident32(uint32_t x) { return x; }
-static inline uint64_t ident64(uint64_t x) { return x; }
-
-static inline uint32_t swap32(uint32_t x) {
-  x = ((x & 0x00ff00ff) << 8) | ((x & 0xff00ff00) >> 8);
-  return (x << 16) | (x >> 16);
-}
-static inline uint64_t swap64(uint64_t x) {
-  x = ((x & 0x00ff00ff00ff00ff) <<  8) | ((x & 0xff00ff00ff00ff00) >>  8);
-  x = ((x & 0x0000ffff0000ffff) << 16) | ((x & 0xffff0000ffff0000) >> 16);
-  return (x << 32) | (x >> 32);
-}
-
-#if defined(__GNUC__)
-#define UNUSED __attribute__((unused))
-#else
-#define UNUSED
-#endif
-static inline void mem_inplace_ident(void *mem UNUSED, size_t n UNUSED) { }
-#undef UNUSED
-
-static inline void mem_inplace_swap32(void *mem, size_t n) {
-  size_t i;
-  for (i = 0; i < n; i++) {
-    ((uint32_t *) mem)[i] = swap32(((const uint32_t *) mem)[i]);
-  }
-}
-static inline void mem_inplace_swap64(void *mem, size_t n) {
-  size_t i;
-  for (i = 0; i < n; i++) {
-    ((uint64_t *) mem)[i] = swap64(((const uint64_t *) mem)[i]);
-  }
-}
-
-static inline void memcpy_ident32(void *dst, const void *src, size_t n) {
-  memcpy(dst, src, 4 * n);
-}
-static inline void memcpy_ident64(void *dst, const void *src, size_t n) {
-  memcpy(dst, src, 8 * n);
-}
-
-static inline void memcpy_swap32(void *dst, const void *src, size_t n) {
-  size_t i;
-  for (i = 0; i < n; i++) {
-    ((uint32_t *) dst)[i] = swap32(((const uint32_t *) src)[i]);
-  }
-}
-static inline void memcpy_swap64(void *dst, const void *src, size_t n) {
-  size_t i;
-  for (i = 0; i < n; i++) {
-    ((uint64_t *) dst)[i] = swap64(((const uint64_t *) src)[i]);
-  }
-}
-
-#if !defined(BYTE_ORDER) || !defined(LITTLE_ENDIAN) || !defined(BIG_ENDIAN)
-static_assert(false, "BYTE_ORDER is undefined. Perhaps, GNU extensions are not enabled");
-#endif
-
-#if BYTE_ORDER == LITTLE_ENDIAN
-#define SWAP32LE IDENT32
-#define SWAP32BE SWAP32
-#define swap32le ident32
-#define swap32be swap32
-#define mem_inplace_swap32le mem_inplace_ident
-#define mem_inplace_swap32be mem_inplace_swap32
-#define memcpy_swap32le memcpy_ident32
-#define memcpy_swap32be memcpy_swap32
-#define SWAP64LE IDENT64
-#define SWAP64BE SWAP64
-#define swap64le ident64
-#define swap64be swap64
-#define mem_inplace_swap64le mem_inplace_ident
-#define mem_inplace_swap64be mem_inplace_swap64
-#define memcpy_swap64le memcpy_ident64
-#define memcpy_swap64be memcpy_swap64
-#endif
-
-#if BYTE_ORDER == BIG_ENDIAN
-#define SWAP32BE IDENT32
-#define SWAP32LE SWAP32
-#define swap32be ident32
-#define swap32le swap32
-#define mem_inplace_swap32be mem_inplace_ident
-#define mem_inplace_swap32le mem_inplace_swap32
-#define memcpy_swap32be memcpy_ident32
-#define memcpy_swap32le memcpy_swap32
-#define SWAP64BE IDENT64
-#define SWAP64LE SWAP64
-#define swap64be ident64
-#define swap64le swap64
-#define mem_inplace_swap64be mem_inplace_ident
-#define mem_inplace_swap64le mem_inplace_swap64
-#define memcpy_swap64be memcpy_ident64
-#define memcpy_swap64le memcpy_swap64
-#endif
@@ -1,11 +0,0 @@
-// Copyright (c) 2012-2013 The Cryptonote developers
-// Distributed under the MIT/X11 software license, see the accompanying
-// file COPYING or http://www.opensource.org/licenses/mit-license.php.
-
-#pragma once
-
-#if defined(_MSC_VER)
-#define POD_CLASS struct
-#else
-#define POD_CLASS class
-#endif
@@ -1,117 +0,0 @@
-// Copyright (c) 2012-2013 The Cryptonote developers
-// Distributed under the MIT/X11 software license, see the accompanying
-// file COPYING or http://www.opensource.org/licenses/mit-license.php.
-
-#pragma once
-
-#include <boost/serialization/split_free.hpp>
-#include <unordered_map>
-#include <unordered_set>
-
-namespace boost
-{
-  namespace serialization
-  {
-    template <class Archive, class h_key, class hval>
-    inline void save(Archive &a, const std::unordered_map<h_key, hval> &x, const boost::serialization::version_type ver)
-    {
-      size_t s = x.size();
-      a << s;
-      BOOST_FOREACH(auto& v, x)
-      {
-        a << v.first;
-        a << v.second;
-      }
-    }
-
-    template <class Archive, class h_key, class hval>
-    inline void load(Archive &a, std::unordered_map<h_key, hval> &x, const boost::serialization::version_type ver)
-    {
-      x.clear();
-      size_t s = 0;
-      a >> s;
-      for(size_t i = 0; i != s; i++)
-      {
-        h_key k;
-        hval v;
-        a >> k;
-        a >> v;
-        x.insert(std::pair<h_key, hval>(k, v));
-      }
-    }
-
-
-    template <class Archive, class h_key, class hval>
-    inline void save(Archive &a, const std::unordered_multimap<h_key, hval> &x, const boost::serialization::version_type ver)
-    {
-      size_t s = x.size();
-      a << s;
-      BOOST_FOREACH(auto& v, x)
-      {
-        a << v.first;
-        a << v.second;
-      }
-    }
-
-    template <class Archive, class h_key, class hval>
-    inline void load(Archive &a, std::unordered_multimap<h_key, hval> &x, const boost::serialization::version_type ver)
-    {
-      x.clear();
-      size_t s = 0;
-      a >> s;
-      for(size_t i = 0; i != s; i++)
-      {
-        h_key k;
-        hval v;
-        a >> k;
-        a >> v;
-        x.emplace(k, v);
-      }
-    }
-
-
-    template <class Archive, class hval>
-    inline void save(Archive &a, const std::unordered_set<hval> &x, const boost::serialization::version_type ver)
-    {
-      size_t s = x.size();
-      a << s;
-      BOOST_FOREACH(auto& v, x)
-      {
-        a << v;
-      }
-    }
-
-    template <class Archive, class hval>
-    inline void load(Archive &a, std::unordered_set<hval> &x, const boost::serialization::version_type ver)
-    {
-      x.clear();
-      size_t s = 0;
-      a >> s;
-      for(size_t i = 0; i != s; i++)
-      {
-        hval v;
-        a >> v;
-        x.insert(v);
-      }
-    }
-
-
-    template <class Archive, class h_key, class hval>
-    inline void serialize(Archive &a, std::unordered_map<h_key, hval> &x, const boost::serialization::version_type ver)
-    {
-      split_free(a, x, ver);
-    }
-
-    template <class Archive, class h_key, class hval>
-    inline void serialize(Archive &a, std::unordered_multimap<h_key, hval> &x, const boost::serialization::version_type ver)
-    {
-      split_free(a, x, ver);
-    }
-
-    template <class Archive, class hval>
-    inline void serialize(Archive &a, std::unordered_set<hval> &x, const boost::serialization::version_type ver)
-    {
-      split_free(a, x, ver);
-    }
-  }
-}
@@ -1,86 +0,0 @@
-// Copyright (c) 2012-2013 The Cryptonote developers
-// Distributed under the MIT/X11 software license, see the accompanying
-// file COPYING or http://www.opensource.org/licenses/mit-license.php.
-
-#pragma once 
-
-#include <mutex>
-#include <system_error>
-#include <boost/filesystem.hpp>
-
-#include "crypto/crypto.h"
-#include "crypto/hash.h"
-#include "misc_language.h"
-#include "p2p/p2p_protocol_defs.h"
-
-namespace tools
-{
-  std::string get_default_data_dir();
-  std::string get_os_version_string();
-  bool create_directories_if_necessary(const std::string& path);
-  std::error_code replace_file(const std::string& replacement_name, const std::string& replaced_name);
-
-  inline crypto::hash get_proof_of_trust_hash(const nodetool::proof_of_trust& pot)
-  {
-    std::string s;
-    s.append(reinterpret_cast<const char*>(&pot.peer_id), sizeof(pot.peer_id));
-    s.append(reinterpret_cast<const char*>(&pot.time), sizeof(pot.time));
-    return crypto::cn_fast_hash(s.data(), s.size());
-  }
-
-
-  class signal_handler
-  {
-  public:
-    template<typename T>
-    static bool install(T t)
-    {
-#if defined(WIN32)
-      bool r = TRUE == ::SetConsoleCtrlHandler(&win_handler, TRUE);
-      if (r)
-      {
-        m_handler = t;
-      }
-      return r;
-#else
-      signal(SIGINT, posix_handler);
-      signal(SIGTERM, posix_handler);
-      m_handler = t;
-      return true;
-#endif
-    }
-
-  private:
-#if defined(WIN32)
-    static BOOL WINAPI win_handler(DWORD type)
-    {
-      if (CTRL_C_EVENT == type || CTRL_BREAK_EVENT == type)
-      {
-        handle_signal();
-        return TRUE;
-      }
-      else
-      {
-        LOG_PRINT_RED_L0("Got control signal " << type << ". Exiting without saving...");
-        return FALSE;
-      }
-      return TRUE;
-    }
-#else
-    static void posix_handler(int /*type*/)
-    {
-      handle_signal();
-    }
-#endif
-
-    static void handle_signal()
-    {
-      static std::mutex m_mutex;
-      std::unique_lock<std::mutex> lock(m_mutex);
-      m_handler();
-    }
-
-  private:
-    static std::function<void(void)> m_handler;
-  };
-}
@@ -1,62 +0,0 @@
-// Copyright (c) 2012-2013 The Cryptonote developers
-// Distributed under the MIT/X11 software license, see the accompanying
-// file COPYING or http://www.opensource.org/licenses/mit-license.php.
-
-#pragma once
-
-#include <limits>
-#include <type_traits>
-#include <utility>
-#include <sstream>
-#include <string>
-
-namespace tools {
-
-    template<typename OutputIt, typename T>
-    typename std::enable_if<std::is_integral<T>::value && std::is_unsigned<T>::value, void>::type
-    write_varint(OutputIt &&dest, T i) {
-        while (i >= 0x80) {
-            *dest++ = (static_cast<char>(i) & 0x7f) | 0x80;
-            i >>= 7;
-        }
-        *dest++ = static_cast<char>(i);
-    }
-
-    template<typename t_type>
-    std::string get_varint_data(const t_type& v)
-    {
-      std::stringstream ss;
-      write_varint(std::ostreambuf_iterator<char>(ss), v);
-      return ss.str();
-    }
-
-    template<int bits, typename InputIt, typename T>
-    typename std::enable_if<std::is_integral<T>::value && std::is_unsigned<T>::value && 0 <= bits && bits <= std::numeric_limits<T>::digits, int>::type
-    read_varint(InputIt &&first, InputIt &&last, T &i) {
-        int read = 0;
-        i = 0;
-        for (int shift = 0;; shift += 7) {
-            if (first == last) {
-                return read; // End of input.
-            }
-            unsigned char byte = *first++;
-            ++read;
-            if (shift + 7 >= bits && byte >= 1 << (bits - shift)) {
-                return -1; // Overflow.
-            }
-            if (byte == 0 && shift != 0) {
-                return -2; // Non-canonical representation.
-            }
-            i |= static_cast<T>(byte & 0x7f) << shift;
-            if ((byte & 0x80) == 0) {
-                break;
-            }
-        }
-        return read;
-    }
-
-    template<typename InputIt, typename T>
-    int read_varint(InputIt &&first, InputIt &&last, T &i) {
-        return read_varint<std::numeric_limits<T>::digits, InputIt, T>(std::move(first), std::move(last), i);
-    }
-}