text: // Copyright (c) 2009-2010 Satoshi Nakamoto
  // Copyright (c) 2009-2020 The Bitcoin Core developers
  // Distributed under the MIT software license, see the accompanying
  // file COPYING or http://www.opensource.org/licenses/mit-license.php.
  
  #ifndef BGL_UINT256_H
  #define BGL_UINT256_H
  
  #include <assert.h>
  #include <cstring>
  #include <stdint.h>
  #include <string>
  #include <vector>
  
  /** Template base class for fixed-sized opaque blobs. */
  template<unsigned int BITS>
  class base_blob
  {
  protected:
      static constexpr int WIDTH = BITS / 8;
      uint8_t m_data[WIDTH];
  public:
      /* construct 0 value by default */
      constexpr base_blob() : m_data() {}
  
      /* constructor for constants between 1 and 255 */
      constexpr explicit base_blob(uint8_t v) : m_data{v} {}
  
      explicit base_blob(const std::vector<unsigned char>& vch);
  
      bool IsNull() const
      {
          for (int i = 0; i < WIDTH; i++)
              if (m_data[i] != 0)
                  return false;
          return true;
      }
  
      void SetNull()
      {
          memset(m_data, 0, sizeof(m_data));
      }
  
      inline int Compare(const base_blob& other) const { return memcmp(m_data, other.m_data, sizeof(m_data)); }
  
      friend inline bool operator==(const base_blob& a, const base_blob& b) { return a.Compare(b) == 0; }
      friend inline bool operator!=(const base_blob& a, const base_blob& b) { return a.Compare(b) != 0; }
      friend inline bool operator<(const base_blob& a, const base_blob& b) { return a.Compare(b) < 0; }
  
      std::string GetHex() const;
      void SetHex(const char* psz);
      void SetHex(const std::string& str);
      std::string ToString() const;
  
      const unsigned char* data() const { return m_data; }
      unsigned char* data() { return m_data; }
  
      unsigned char* begin()
      {
          return &m_data[0];
      }
  
      unsigned char* end()
      {
          return &m_data[WIDTH];
      }
  
      const unsigned char* begin() const
      {
          return &m_data[0];
      }
  
      const unsigned char* end() const
      {
          return &m_data[WIDTH];
      }
  
      unsigned int size() const
      {
          return sizeof(m_data);
      }
  
      uint64_t GetUint64(int pos) const
      {
          const uint8_t* ptr = m_data + pos * 8;
          return ((uint64_t)ptr[0]) | \
                 ((uint64_t)ptr[1]) << 8 | \
                 ((uint64_t)ptr[2]) << 16 | \
                 ((uint64_t)ptr[3]) << 24 | \
                 ((uint64_t)ptr[4]) << 32 | \
                 ((uint64_t)ptr[5]) << 40 | \
                 ((uint64_t)ptr[6]) << 48 | \
                 ((uint64_t)ptr[7]) << 56;
      }
  
      template<typename Stream>
      void Serialize(Stream& s) const
      {
          s.write((char*)m_data, sizeof(m_data));
      }
  
      template<typename Stream>
      void Unserialize(Stream& s)
      {
          s.read((char*)m_data, sizeof(m_data));
      }
  };
  
  /** 160-bit opaque blob.
   * @note This type is called uint160 for historical reasons only. It is an opaque
   * blob of 160 bits and has no integer operations.
   */
  class uint160 : public base_blob<160> {
  public:
      constexpr uint160() {}
      explicit uint160(const std::vector<unsigned char>& vch) : base_blob<160>(vch) {}
  };
  
  /** 256-bit opaque blob.
   * @note This type is called uint256 for historical reasons only. It is an
   * opaque blob of 256 bits and has no integer operations. Use arith_uint256 if
   * those are required.
   */
  class uint256 : public base_blob<256> {
  public:
      constexpr uint256() {}
      constexpr explicit uint256(uint8_t v) : base_blob<256>(v) {}
      explicit uint256(const std::vector<unsigned char>& vch) : base_blob<256>(vch) {}
      static const uint256 ZERO;
      static const uint256 ONE;
  };
  
  /* uint256 from const char *.
   * This is a separate function because the constructor uint256(const char*) can result
   * in dangerously catching uint256(0).
   */
  inline uint256 uint256S(const char *str)
  {
      uint256 rv;
      rv.SetHex(str);
      return rv;
  }
  /* uint256 from std::string.
   * This is a separate function because the constructor uint256(const std::string &str) can result
   * in dangerously catching uint256(0) via std::string(const char*).
   */
  inline uint256 uint256S(const std::string& str)
  {
      uint256 rv;
      rv.SetHex(str);
      return rv;
  }
  
  
  #endif // BGL_UINT256_H
  