git / moonbite-core / src/uint256.h · raw

// Copyright (c) 2009-2010 Satoshi Nakamoto// Copyright (c) 2009-2019 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 BITCOIN_UINT256_H#define BITCOIN_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 // BITCOIN_UINT256_H