blob_uint256.h

Go to the documentation of this file.

// Copyright (c) 2009-2010 Satoshi Nakamoto
// Copyright (c) 2009-2014 The Bitcoin developers
// Copyright (c) 2014-2015 The Dash developers
// Copyright (c) 2015-2018 The PIVX developers
// Distributed under the MIT software license, see the accompanying
// file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
#ifndef PRCY_BLOB_UINT256_H
#define PRCY_BLOB_UINT256_H
 
#include <assert.h>
#include <cstring>
#include <stdexcept>
#include <stdint.h>
#include <string>
#include <vector>
 
template<unsigned int BITS>
class base_blob
{
public:
    // todo: make this protected
    enum { WIDTH=BITS/8 };
    uint8_t data[WIDTH];
 
    base_blob()
    {
        SetNull();
    }
 
    explicit base_blob(const std::vector<unsigned char>& vch);
 
    bool IsNull() const
    {
        for (int i = 0; i < WIDTH; i++)
            if (data[i] != 0)
                return false;
        return true;
    }
 
    void SetNull()
    {
        memset(data, 0, sizeof(data));
    }
 
    friend inline bool operator==(const base_blob& a, const base_blob& b) { return memcmp(a.data, b.data, sizeof(a.data)) == 0; }
    friend inline bool operator!=(const base_blob& a, const base_blob& b) { return memcmp(a.data, b.data, sizeof(a.data)) != 0; }
    friend inline bool operator<(const base_blob& a, const base_blob& b) { return memcmp(a.data, b.data, sizeof(a.data)) < 0; }
 
    std::string GetHex() const;
    void SetHex(const char* psz);
    void SetHex(const std::string& str);
    std::string ToString() const;
 
    unsigned char* begin()
    {
        return &data[0];
    }
 
    unsigned char* end()
    {
        return &data[WIDTH];
    }
 
    const unsigned char* begin() const
    {
        return &data[0];
    }
 
    const unsigned char* end() const
    {
        return &data[WIDTH];
    }
 
    unsigned int size() const
    {
        return sizeof(data);
    }
 
    unsigned int GetSerializeSize(int nType, int nVersion) const
    {
        return sizeof(data);
    }
 
    template<typename Stream>
    void Serialize(Stream& s, int nType, int nVersion) const
    {
        s.write((char*)data, sizeof(data));
    }
 
    template<typename Stream>
    void Unserialize(Stream& s, int nType, int nVersion)
    {
        s.read((char*)data, sizeof(data));
    }
};
 
class blob_uint160 : public base_blob<160> {
public:
    blob_uint160() {}
    blob_uint160(const base_blob<160>& b) : base_blob<160>(b) {}
    explicit blob_uint160(const std::vector<unsigned char>& vch) : base_blob<160>(vch) {}
};
 
class blob_uint256 : public base_blob<256> {
public:
    blob_uint256() {}
    blob_uint256(const base_blob<256>& b) : base_blob<256>(b) {}
    explicit blob_uint256(const std::vector<unsigned char>& vch) : base_blob<256>(vch) {}
 
    uint64_t GetCheapHash() const
    {
        uint64_t result;
        memcpy((void*)&result, (void*)data, 8);
        return result;
    }
 
    uint64_t GetHash(const blob_uint256& salt) const;
};
 
/* uint256 from const char *.
 * This is a separate function because the constructor uint256(const char*) can result
 * in dangerously catching uint256(0).
 */
inline blob_uint256 blob_uint256S(const char *str)
{
    blob_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 blob_uint256 blob_uint256S(const std::string& str)
{
    return blob_uint256S(str.c_str());
}
 
const blob_uint256 BLOB_UINT256_ZERO = blob_uint256();
const blob_uint256 BLOB_UINT256_ONE = blob_uint256S("0000000000000000000000000000000000000000000000000000000000000001");
 
#endif // PRCY_BLOB_UINT256_H