Bitcoin Core  0.20.99
P2P Digital Currency
uint256.cpp
Go to the documentation of this file.
1 // Copyright (c) 2009-2010 Satoshi Nakamoto
2 // Copyright (c) 2009-2019 The Bitcoin Core developers
3 // Distributed under the MIT software license, see the accompanying
4 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
5 
6 #include <uint256.h>
7 
8 #include <util/strencodings.h>
9 
10 #include <string.h>
11 
12 template <unsigned int BITS>
13 base_blob<BITS>::base_blob(const std::vector<unsigned char>& vch)
14 {
15  assert(vch.size() == sizeof(m_data));
16  memcpy(m_data, vch.data(), sizeof(m_data));
17 }
18 
19 template <unsigned int BITS>
20 std::string base_blob<BITS>::GetHex() const
21 {
22  uint8_t m_data_rev[WIDTH];
23  for (int i = 0; i < WIDTH; ++i) {
24  m_data_rev[i] = m_data[WIDTH - 1 - i];
25  }
26  return HexStr(m_data_rev);
27 }
28 
29 template <unsigned int BITS>
30 void base_blob<BITS>::SetHex(const char* psz)
31 {
32  memset(m_data, 0, sizeof(m_data));
33 
34  // skip leading spaces
35  while (IsSpace(*psz))
36  psz++;
37 
38  // skip 0x
39  if (psz[0] == '0' && ToLower(psz[1]) == 'x')
40  psz += 2;
41 
42  // hex string to uint
43  size_t digits = 0;
44  while (::HexDigit(psz[digits]) != -1)
45  digits++;
46  unsigned char* p1 = (unsigned char*)m_data;
47  unsigned char* pend = p1 + WIDTH;
48  while (digits > 0 && p1 < pend) {
49  *p1 = ::HexDigit(psz[--digits]);
50  if (digits > 0) {
51  *p1 |= ((unsigned char)::HexDigit(psz[--digits]) << 4);
52  p1++;
53  }
54  }
55 }
56 
57 template <unsigned int BITS>
58 void base_blob<BITS>::SetHex(const std::string& str)
59 {
60  SetHex(str.c_str());
61 }
62 
63 template <unsigned int BITS>
64 std::string base_blob<BITS>::ToString() const
65 {
66  return (GetHex());
67 }
68 
69 // Explicit instantiations for base_blob<160>
70 template base_blob<160>::base_blob(const std::vector<unsigned char>&);
71 template std::string base_blob<160>::GetHex() const;
72 template std::string base_blob<160>::ToString() const;
73 template void base_blob<160>::SetHex(const char*);
74 template void base_blob<160>::SetHex(const std::string&);
75 
76 // Explicit instantiations for base_blob<256>
77 template base_blob<256>::base_blob(const std::vector<unsigned char>&);
78 template std::string base_blob<256>::GetHex() const;
79 template std::string base_blob<256>::ToString() const;
80 template void base_blob<256>::SetHex(const char*);
81 template void base_blob<256>::SetHex(const std::string&);
82 
84  static uint256* one = new uint256(uint256S("0000000000000000000000000000000000000000000000000000000000000001"));
85  return *one;
86 }
base_blob()
Definition: uint256.h:23
std::string ToLower(const std::string &str)
Returns the lowercase equivalent of the given string.
signed char HexDigit(char c)
uint256 & UINT256_ONE()
Definition: uint256.cpp:83
uint256 uint256S(const char *str)
Definition: uint256.h:133
std::string ToString() const
Definition: uint256.cpp:64
std::string HexStr(const Span< const uint8_t > s)
Convert a span of bytes to a lower-case hexadecimal string.
256-bit opaque blob.
Definition: uint256.h:123
void * memcpy(void *a, const void *b, size_t c)
constexpr bool IsSpace(char c) noexcept
Tests if the given character is a whitespace character.
Definition: strencodings.h:84
std::string GetHex() const
Definition: uint256.cpp:20
void SetHex(const char *psz)
Definition: uint256.cpp:30