hash.h File Reference

#include <iostream>
#include <stddef.h>
#include <stdexcept>
#include "common/pod-class.h"
#include "generic-ops.h"
#include "hex.h"
#include "span.h"
#include "hash-ops.h"

Include dependency graph for hash.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Classes
struct	crypto::is_blob_type< T >
	a descriptor for dispatching serialize More...
union	crypto::hash_state

Namespaces
namespace	crypto
	crypto namespace.
namespace	crypto::serialization
namespace	detail
	declaration and default definition for the functions used the API
namespace	crypto::serialization::detail

Macros
#define	true   1
#define	false   0
#define	_MSC_STDINT_H_
#define	_W64
#define	INT8_MIN   ((int8_t)_I8_MIN)
#define	INT8_MAX   _I8_MAX
#define	INT16_MIN   ((int16_t)_I16_MIN)
#define	INT16_MAX   _I16_MAX
#define	INT32_MIN   ((int32_t)_I32_MIN)
#define	INT32_MAX   _I32_MAX
#define	INT64_MIN   ((int64_t)_I64_MIN)
#define	INT64_MAX   _I64_MAX
#define	UINT8_MAX   _UI8_MAX
#define	UINT16_MAX   _UI16_MAX
#define	UINT32_MAX   _UI32_MAX
#define	UINT64_MAX   _UI64_MAX
#define	INT_LEAST8_MIN   INT8_MIN
#define	INT_LEAST8_MAX   INT8_MAX
#define	INT_LEAST16_MIN   INT16_MIN
#define	INT_LEAST16_MAX   INT16_MAX
#define	INT_LEAST32_MIN   INT32_MIN
#define	INT_LEAST32_MAX   INT32_MAX
#define	INT_LEAST64_MIN   INT64_MIN
#define	INT_LEAST64_MAX   INT64_MAX
#define	UINT_LEAST8_MAX   UINT8_MAX
#define	UINT_LEAST16_MAX   UINT16_MAX
#define	UINT_LEAST32_MAX   UINT32_MAX
#define	UINT_LEAST64_MAX   UINT64_MAX
#define	INT_FAST8_MIN   INT8_MIN
#define	INT_FAST8_MAX   INT8_MAX
#define	INT_FAST16_MIN   INT16_MIN
#define	INT_FAST16_MAX   INT16_MAX
#define	INT_FAST32_MIN   INT32_MIN
#define	INT_FAST32_MAX   INT32_MAX
#define	INT_FAST64_MIN   INT64_MIN
#define	INT_FAST64_MAX   INT64_MAX
#define	UINT_FAST8_MAX   UINT8_MAX
#define	UINT_FAST16_MAX   UINT16_MAX
#define	UINT_FAST32_MAX   UINT32_MAX
#define	UINT_FAST64_MAX   UINT64_MAX
#define	INTPTR_MIN   INT32_MIN
#define	INTPTR_MAX   INT32_MAX
#define	UINTPTR_MAX   UINT32_MAX
#define	INTMAX_MIN   INT64_MIN
#define	INTMAX_MAX   INT64_MAX
#define	UINTMAX_MAX   UINT64_MAX
#define	PTRDIFF_MIN   _I32_MIN
#define	PTRDIFF_MAX   _I32_MAX
#define	SIG_ATOMIC_MIN   INT_MIN
#define	SIG_ATOMIC_MAX   INT_MAX
#define	SIZE_MAX   _UI32_MAX
#define	WCHAR_MIN   0
#define	WCHAR_MAX   _UI16_MAX
#define	WINT_MIN   0
#define	WINT_MAX   _UI16_MAX
#define	INT8_C(val)
#define	INT16_C(val)
#define	INT32_C(val)
#define	INT64_C(val)
#define	UINT8_C(val)
#define	UINT16_C(val)
#define	UINT32_C(val)
#define	UINT64_C(val)
#define	INTMAX_C   INT64_C
#define	UINTMAX_C   UINT64_C
#define	BLOB_SERIALIZER(T)
#define	VARIANT_TAG(Archive, Type, Tag)
#define	BEGIN_SERIALIZE()
#define	BEGIN_SERIALIZE_OBJECT()
#define	PREPARE_CUSTOM_VECTOR_SERIALIZATION(size, vec, min_wire)
#define	END_SERIALIZE()
#define	FIELD_N(t, f)
#define	FIELD(f)
#define	FIELDS(f)
#define	VARINT_FIELD(f)
#define	VARINT_FIELD_N(t, f)
#define	MAGIC_FIELD(m)
#define	VERSION_FIELD(v)
#define	CONTAINER_FIELD_CAPPED(f, c)
#define	LITTLE_ENDIAN   1234
#define	BIG_ENDIAN   4321
#define	PDP_ENDIAN   3412
#define	BYTE_ORDER   LITTLE_ENDIAN
#define	IDENT16(x)
#define	IDENT32(x)
#define	IDENT64(x)
#define	SWAP16(x)
#define	SWAP32(x)
#define	SWAP64(x)
#define	UNUSED
#define	SWAP16LE   IDENT16
#define	SWAP16BE   SWAP16
#define	swap16le   ident16
#define	swap16be   swap16
#define	mem_inplace_swap16le   mem_inplace_ident
#define	mem_inplace_swap16be   mem_inplace_swap16
#define	memcpy_swap16le   memcpy_ident16
#define	memcpy_swap16be   memcpy_swap16
#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
#define	SWAP16BE   IDENT16
#define	SWAP16LE   SWAP16
#define	swap16be   ident16
#define	swap16le   swap16
#define	mem_inplace_swap16be   mem_inplace_ident
#define	mem_inplace_swap16le   mem_inplace_swap16
#define	memcpy_swap16be   memcpy_ident16
#define	memcpy_swap16le   memcpy_swap16
#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
#define	PUSH_WARNINGS   _Pragma("GCC diagnostic push")
#define	POP_WARNINGS   _Pragma("GCC diagnostic pop")
#define	DISABLE_VS_WARNINGS(w)
#define	DISABLE_GCC_WARNING   DISABLE_GCC_AND_CLANG_WARNING
#define	DISABLE_CLANG_WARNING(w)
#define	DISABLE_GCC_AND_CLANG_WARNING(w)
#define	RX_BLOCK_VERSION   12

Typedefs
typedef int	crypto::bool
typedef signed char	crypto::int8_t
typedef signed short	crypto::int16_t
typedef signed int	crypto::int32_t
typedef unsigned char	crypto::uint8_t
typedef unsigned short	crypto::uint16_t
typedef unsigned int	crypto::uint32_t
typedef signed __int64	crypto::int64_t
typedef unsigned __int64	crypto::uint64_t
typedef int8_t	crypto::int_least8_t
typedef int16_t	crypto::int_least16_t
typedef int32_t	crypto::int_least32_t
typedef int64_t	crypto::int_least64_t
typedef uint8_t	crypto::uint_least8_t
typedef uint16_t	crypto::uint_least16_t
typedef uint32_t	crypto::uint_least32_t
typedef uint64_t	crypto::uint_least64_t
typedef int8_t	crypto::int_fast8_t
typedef int16_t	crypto::int_fast16_t
typedef int32_t	crypto::int_fast32_t
typedef int64_t	crypto::int_fast64_t
typedef uint8_t	crypto::uint_fast8_t
typedef uint16_t	crypto::uint_fast16_t
typedef uint32_t	crypto::uint_fast32_t
typedef uint64_t	crypto::uint_fast64_t
typedef _W64 signed int	crypto::intptr_t
typedef _W64 unsigned int	crypto::uintptr_t
typedef int64_t	crypto::intmax_t
typedef uint64_t	crypto::uintmax_t

Enumerations
enum	{ crypto::HASH_SIZE = 32 , crypto::HASH_DATA_AREA = 136 }

Functions
template<class Archive, class T>
std::enable_if_t< is_blob_type< T >::type::value, bool >	crypto::do_serialize (Archive &ar, T &v)
	main function for dispatching serialization for a given pair of archive and value types
template<class Archive, class T>
std::enable_if_t< boost::is_integral< T >::value, bool >	crypto::do_serialize (Archive &ar, T &v)
template<class Archive, class T>
auto	crypto::do_serialize (Archive &ar, T &v) -> decltype(v.member_do_serialize(ar), true)
template<class Archive>
bool	crypto::do_serialize (Archive &ar, bool &v)
template<typename T, template< bool > class A>
constexpr bool	crypto::serialization::detail::prepare_custom_vector_serialization (size_t, const std::vector< T > &vec, size_t, const A< true > &) noexcept
template<typename T, template< bool > class A>
bool	crypto::serialization::detail::prepare_custom_vector_serialization (const size_t size, std::vector< T > &vec, const size_t min_size, const A< false > &ar)
template<class Archive>
bool	crypto::serialization::detail::do_check_stream_state (Archive &ar, boost::mpl::bool_< true >, bool noeof)
template<class Archive>
bool	crypto::serialization::detail::do_check_stream_state (Archive &ar, boost::mpl::bool_< false >, bool noeof)
template<class Archive>
bool	crypto::serialization::check_stream_state (Archive &ar, bool noeof=false)
template<class Archive, class T>
bool	crypto::serialization::serialize (Archive &ar, T &v)
template<class Archive, class T>
bool	crypto::serialization::serialize_noeof (Archive &ar, T &v)
template<template< bool > class Archive>
bool	crypto::do_serialize (Archive< false > &ar, std::string &str)
template<template< bool > class Archive>
bool	crypto::do_serialize (Archive< true > &ar, std::string &str)
static uint32_t	crypto::rol32 (uint32_t x, int r)
static uint64_t	crypto::rol64 (uint64_t x, int r)
static uint64_t	crypto::hi_dword (uint64_t val)
static uint64_t	crypto::lo_dword (uint64_t val)
static uint64_t	crypto::mul128 (uint64_t multiplier, uint64_t multiplicand, uint64_t *product_hi)
static uint64_t	crypto::div_with_reminder (uint64_t dividend, uint32_t divisor, uint32_t *remainder)
static uint32_t	crypto::div128_32 (uint64_t dividend_hi, uint64_t dividend_lo, uint32_t divisor, uint64_t *quotient_hi, uint64_t *quotient_lo)
void	crypto::div128_64 (uint64_t dividend_hi, uint64_t dividend_lo, uint64_t divisor, uint64_t *quotient_hi, uint64_t *quotient_lo, uint64_t *remainder_hi, uint64_t *remainder_lo)
static void	crypto::add64clamp (uint64_t *value, uint64_t add)
static void	crypto::sub64clamp (uint64_t *value, uint64_t sub)
static uint16_t	crypto::ident16 (uint16_t x)
static uint32_t	crypto::ident32 (uint32_t x)
static uint64_t	crypto::ident64 (uint64_t x)
static uint16_t	crypto::swap16 (uint16_t x)
static uint32_t	crypto::swap32 (uint32_t x)
static uint64_t	crypto::swap64 (uint64_t x)
static void	crypto::mem_inplace_ident (void *mem UNUSED, size_t n UNUSED)
static void	crypto::mem_inplace_swap16 (void *mem, size_t n)
static void	crypto::mem_inplace_swap32 (void *mem, size_t n)
static void	crypto::mem_inplace_swap64 (void *mem, size_t n)
static void	crypto::memcpy_ident16 (void *dst, const void *src, size_t n)
static void	crypto::memcpy_ident32 (void *dst, const void *src, size_t n)
static void	crypto::memcpy_ident64 (void *dst, const void *src, size_t n)
static void	crypto::memcpy_swap16 (void *dst, const void *src, size_t n)
static void	crypto::memcpy_swap32 (void *dst, const void *src, size_t n)
static void	crypto::memcpy_swap64 (void *dst, const void *src, size_t n)
static void *	crypto::padd (void *p, size_t i)
static const void *	crypto::cpadd (const void *p, size_t i)
static void	crypto::place_length (uint8_t *buffer, size_t bufsize, size_t length)
void	crypto::hash_permutation (union hash_state *state)
void	crypto::hash_process (union hash_state *state, const uint8_t *buf, size_t count)
void	crypto::cn_fast_hash (const void *data, size_t length, char *hash)
void	crypto::cn_slow_hash (const void *data, size_t length, char *hash, int variant, int prehashed, uint64_t height)
void	crypto::hash_extra_blake (const void *data, size_t length, char *hash)
void	crypto::hash_extra_groestl (const void *data, size_t length, char *hash)
void	crypto::hash_extra_jh (const void *data, size_t length, char *hash)
void	crypto::hash_extra_skein (const void *data, size_t length, char *hash)
void	crypto::tree_hash (const char(*hashes)[HASH_SIZE], size_t count, char *root_hash)
bool	crypto::tree_path (size_t count, size_t idx, uint32_t *path)
bool	crypto::tree_branch (const char(*hashes)[HASH_SIZE], size_t count, const char *hash, char(*branch)[HASH_SIZE], size_t *depth, uint32_t *path)
bool	crypto::tree_branch_hash (const char hash[HASH_SIZE], const char(*branch)[HASH_SIZE], size_t depth, uint32_t path, char root[HASH_SIZE])
bool	crypto::is_branch_in_tree (const char hash[HASH_SIZE], const char root[HASH_SIZE], const char(*branch)[HASH_SIZE], size_t depth, uint32_t path)
void	crypto::rx_slow_hash_allocate_state (void)
void	crypto::rx_slow_hash_free_state (void)
uint64_t	crypto::rx_seedheight (const uint64_t height)
void	crypto::rx_seedheights (const uint64_t height, uint64_t *seed_height, uint64_t *next_height)
void	crypto::rx_set_main_seedhash (const char *seedhash, size_t max_dataset_init_threads)
void	crypto::rx_slow_hash (const char *seedhash, const void *data, size_t length, char *result_hash)
void	crypto::rx_set_miner_thread (uint32_t value, size_t max_dataset_init_threads)
uint32_t	crypto::rx_get_miner_thread (void)
void	crypto::cn_fast_hash (const void *data, std::size_t length, hash &hash)
hash	crypto::cn_fast_hash (const void *data, std::size_t length)
static constexpr void	crypto::cn_variant1_check (const std::size_t length, const int variant)
void	crypto::cn_slow_hash (const void *data, std::size_t length, hash &hash, int variant=0, uint64_t height=0)
void	crypto::cn_slow_hash_prehashed (const void *data, std::size_t length, hash &hash, int variant=0, uint64_t height=0)
void	crypto::tree_hash (const hash *hashes, std::size_t count, hash &root_hash)
std::ostream &	crypto::operator<< (std::ostream &o, const crypto::hash &v)
std::ostream &	crypto::operator<< (std::ostream &o, const crypto::hash8 &v)
bool	crypto::operator< (const hash &lhs, const hash &rhs) noexcept
bool	crypto::operator> (const hash &lhs, const hash &rhs) noexcept

Variables
	crypto::PUSH_WARNINGS
POD_CLASS	crypto::hash
POD_CLASS	crypto::hash8
static constexpr crypto::hash	crypto::null_hash = {}
static constexpr crypto::hash8	crypto::null_hash8 = {}

Macro Definition Documentation

_MSC_STDINT_H_

#define _MSC_STDINT_H_

_W64

#define _W64

BEGIN_SERIALIZE

#define BEGIN_SERIALIZE

(

)

Value:

template <bool W, template <bool> class Archive>          \
bool member_do_serialize(Archive<W> &ar) {

BEGIN_SERIALIZE_OBJECT

#define BEGIN_SERIALIZE_OBJECT

(

)

Value:

template <bool W, template <bool> class Archive>          \
bool member_do_serialize(Archive<W> &ar) {                    \
  ar.begin_object();                          \
  bool r = do_serialize_object(ar);                   \
  ar.end_object();                            \
  return r;                               \
}                                 \
template <bool W, template <bool> class Archive>          \
bool do_serialize_object(Archive<W> &ar){

BIG_ENDIAN

#define BIG_ENDIAN   4321

BLOB_SERIALIZER

#define BLOB_SERIALIZER

(

T

)

Value:

template<>                                \
struct is_blob_type<T> {                      \
  typedef boost::true_type type;                  \
}

BYTE_ORDER

#define BYTE_ORDER   LITTLE_ENDIAN

CONTAINER_FIELD_CAPPED

#define CONTAINER_FIELD_CAPPED	(		f,
			c )

Value:

do {                          \
  ar.tag(#f);                     \
  bool r = do_serialize(ar, f, c);            \
  if (!r || !ar.good()) return false;         \
} while(0);

DISABLE_CLANG_WARNING

#define DISABLE_CLANG_WARNING

(

w

)

DISABLE_GCC_AND_CLANG_WARNING

#define DISABLE_GCC_AND_CLANG_WARNING

(

w

)

Value:

_Pragma(BOOST_PP_STRINGIZE(GCC diagnostic ignored BOOST_PP_STRINGIZE(-W##w)))

DISABLE_GCC_WARNING

#define DISABLE_GCC_WARNING   DISABLE_GCC_AND_CLANG_WARNING

DISABLE_VS_WARNINGS

#define DISABLE_VS_WARNINGS

(

w

)

END_SERIALIZE

#define END_SERIALIZE

(

)

Value:

return ar.good();             \
}

false

#define false   0

FIELD

#define FIELD

(

f

)

Value:

do {                          \
  ar.tag(#f);                     \
  bool r = do_serialize(ar, f);           \
  if (!r || !ar.good()) return false;         \
} while(0);

FIELD_N

#define FIELD_N	(		t,
			f )

Value:

do {                          \
  ar.tag(t);                      \
  bool r = do_serialize(ar, f);           \
  if (!r || !ar.good()) return false;         \
} while(0);

FIELDS

#define FIELDS

(

f

)

Value:

do {                                  \
  bool r = do_serialize(ar, f);                   \
  if (!r || !ar.good()) return false;                 \
} while(0);

IDENT16

#define IDENT16

(

x

)

Value:

((uint16_t) (x))

IDENT32

#define IDENT32

(

x

)

Value:

((uint32_t) (x))

IDENT64

#define IDENT64

(

x

)

Value:

((uint64_t) (x))

INT16_C

#define INT16_C

(

val

)

Value:

val##i16

INT16_MAX

#define INT16_MAX   _I16_MAX

INT16_MIN

#define INT16_MIN   ((int16_t)_I16_MIN)

INT32_C

#define INT32_C

(

val

)

Value:

val##i32

INT32_MAX

#define INT32_MAX   _I32_MAX

INT32_MIN

#define INT32_MIN   ((int32_t)_I32_MIN)

INT64_C

#define INT64_C

(

val

)

Value:

val##i64

INT64_MAX

#define INT64_MAX   _I64_MAX

INT64_MIN

#define INT64_MIN   ((int64_t)_I64_MIN)

INT8_C

#define INT8_C

(

val

)

Value:

val##i8

INT8_MAX

#define INT8_MAX   _I8_MAX

INT8_MIN

#define INT8_MIN   ((int8_t)_I8_MIN)

INT_FAST16_MAX

#define INT_FAST16_MAX   INT16_MAX

INT_FAST16_MIN

#define INT_FAST16_MIN   INT16_MIN

INT_FAST32_MAX

#define INT_FAST32_MAX   INT32_MAX

INT_FAST32_MIN

#define INT_FAST32_MIN   INT32_MIN

INT_FAST64_MAX

#define INT_FAST64_MAX   INT64_MAX

INT_FAST64_MIN

#define INT_FAST64_MIN   INT64_MIN

INT_FAST8_MAX

#define INT_FAST8_MAX   INT8_MAX

INT_FAST8_MIN

#define INT_FAST8_MIN   INT8_MIN

INT_LEAST16_MAX

#define INT_LEAST16_MAX   INT16_MAX

INT_LEAST16_MIN

#define INT_LEAST16_MIN   INT16_MIN

INT_LEAST32_MAX

#define INT_LEAST32_MAX   INT32_MAX

INT_LEAST32_MIN

#define INT_LEAST32_MIN   INT32_MIN

INT_LEAST64_MAX

#define INT_LEAST64_MAX   INT64_MAX

INT_LEAST64_MIN

#define INT_LEAST64_MIN   INT64_MIN

INT_LEAST8_MAX

#define INT_LEAST8_MAX   INT8_MAX

INT_LEAST8_MIN

#define INT_LEAST8_MIN   INT8_MIN

INTMAX_C

#define INTMAX_C   INT64_C

INTMAX_MAX

#define INTMAX_MAX   INT64_MAX

INTMAX_MIN

#define INTMAX_MIN   INT64_MIN

INTPTR_MAX

#define INTPTR_MAX   INT32_MAX

INTPTR_MIN

#define INTPTR_MIN   INT32_MIN

LITTLE_ENDIAN

#define LITTLE_ENDIAN   1234

MAGIC_FIELD

#define MAGIC_FIELD

(

m

)

Value:

std::string magic = m;            \
do {                      \
  ar.tag("magic");                \
  ar.serialize_blob((void*)magic.data(), magic.size()); \
  if (!ar.good()) return false;       \
  if (magic != m) return false;       \
} while(0);

mem_inplace_swap16be [1/2]

#define mem_inplace_swap16be   mem_inplace_ident

mem_inplace_swap16be [2/2]

#define mem_inplace_swap16be   mem_inplace_swap16

mem_inplace_swap16le [1/2]

#define mem_inplace_swap16le   mem_inplace_swap16

mem_inplace_swap16le [2/2]

#define mem_inplace_swap16le   mem_inplace_ident

mem_inplace_swap32be [1/2]

#define mem_inplace_swap32be   mem_inplace_ident

mem_inplace_swap32be [2/2]

#define mem_inplace_swap32be   mem_inplace_swap32

mem_inplace_swap32le [1/2]

#define mem_inplace_swap32le   mem_inplace_swap32

mem_inplace_swap32le [2/2]

#define mem_inplace_swap32le   mem_inplace_ident

mem_inplace_swap64be [1/2]

#define mem_inplace_swap64be   mem_inplace_ident

mem_inplace_swap64be [2/2]

#define mem_inplace_swap64be   mem_inplace_swap64

mem_inplace_swap64le [1/2]

#define mem_inplace_swap64le   mem_inplace_swap64

mem_inplace_swap64le [2/2]

#define mem_inplace_swap64le   mem_inplace_ident

memcpy_swap16be [1/2]

#define memcpy_swap16be   memcpy_ident16

memcpy_swap16be [2/2]

#define memcpy_swap16be   memcpy_swap16

memcpy_swap16le [1/2]

#define memcpy_swap16le   memcpy_swap16

memcpy_swap16le [2/2]

#define memcpy_swap16le   memcpy_ident16

memcpy_swap32be [1/2]

#define memcpy_swap32be   memcpy_ident32

memcpy_swap32be [2/2]

#define memcpy_swap32be   memcpy_swap32

memcpy_swap32le [1/2]

#define memcpy_swap32le   memcpy_swap32

memcpy_swap32le [2/2]

#define memcpy_swap32le   memcpy_ident32

memcpy_swap64be [1/2]

#define memcpy_swap64be   memcpy_ident64

memcpy_swap64be [2/2]

#define memcpy_swap64be   memcpy_swap64

memcpy_swap64le [1/2]

#define memcpy_swap64le   memcpy_swap64

memcpy_swap64le [2/2]

#define memcpy_swap64le   memcpy_ident64

PDP_ENDIAN

#define PDP_ENDIAN   3412

POP_WARNINGS

#define POP_WARNINGS   _Pragma("GCC diagnostic pop")

PREPARE_CUSTOM_VECTOR_SERIALIZATION

#define PREPARE_CUSTOM_VECTOR_SERIALIZATION	(		size,
			vec,
			min_wire )

Value:

do \
{ \
  if (!::serialization::detail::prepare_custom_vector_serialization(size, vec, min_wire, ar)) \
    return false; \
} while (0);

PTRDIFF_MAX

#define PTRDIFF_MAX   _I32_MAX

PTRDIFF_MIN

#define PTRDIFF_MIN   _I32_MIN

PUSH_WARNINGS

#define PUSH_WARNINGS   _Pragma("GCC diagnostic push")

RX_BLOCK_VERSION

#define RX_BLOCK_VERSION   12

SIG_ATOMIC_MAX

#define SIG_ATOMIC_MAX   INT_MAX

SIG_ATOMIC_MIN

#define SIG_ATOMIC_MIN   INT_MIN

SIZE_MAX

#define SIZE_MAX   _UI32_MAX

SWAP16

#define SWAP16

(

x

)

Value:

((((uint16_t) (x) & 0x00ff) << 8) | \
(((uint16_t) (x) & 0xff00) >> 8))

SWAP16BE [1/2]

#define SWAP16BE   IDENT16

SWAP16BE [2/2]

#define SWAP16BE   SWAP16

swap16be [1/2]

#define swap16be   ident16

swap16be [2/2]

#define swap16be   swap16

SWAP16LE [1/2]

#define SWAP16LE   SWAP16

SWAP16LE [2/2]

#define SWAP16LE   IDENT16

swap16le [1/2]

#define swap16le   swap16

swap16le [2/2]

#define swap16le   ident16

SWAP32

#define SWAP32

(

x

)

Value:

((((uint32_t) (x) & 0x000000ff) << 24) | \
(((uint32_t) (x) & 0x0000ff00) <<  8) | \
(((uint32_t) (x) & 0x00ff0000) >>  8) | \
(((uint32_t) (x) & 0xff000000) >> 24))

SWAP32BE [1/2]

#define SWAP32BE   IDENT32

SWAP32BE [2/2]

#define SWAP32BE   SWAP32

swap32be [1/2]

#define swap32be   ident32

swap32be [2/2]

#define swap32be   swap32

SWAP32LE [1/2]

#define SWAP32LE   SWAP32

SWAP32LE [2/2]

#define SWAP32LE   IDENT32

swap32le [1/2]

#define swap32le   swap32

swap32le [2/2]

#define swap32le   ident32

SWAP64

#define SWAP64

(

x

)

Value:

((((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))

SWAP64BE [1/2]

#define SWAP64BE   IDENT64

SWAP64BE [2/2]

#define SWAP64BE   SWAP64

swap64be [1/2]

#define swap64be   ident64

swap64be [2/2]

#define swap64be   swap64

SWAP64LE [1/2]

#define SWAP64LE   SWAP64

SWAP64LE [2/2]

#define SWAP64LE   IDENT64

swap64le [1/2]

#define swap64le   swap64

swap64le [2/2]

#define swap64le   ident64

true

#define true   1

UINT16_C

#define UINT16_C

(

val

)

Value:

val##ui16

UINT16_MAX

#define UINT16_MAX   _UI16_MAX

UINT32_C

#define UINT32_C

(

val

)

Value:

val##ui32

UINT32_MAX

#define UINT32_MAX   _UI32_MAX

UINT64_C

#define UINT64_C

(

val

)

Value:

val##ui64

UINT64_MAX

#define UINT64_MAX   _UI64_MAX

UINT8_C

#define UINT8_C

(

val

)

Value:

val##ui8

UINT8_MAX

#define UINT8_MAX   _UI8_MAX

UINT_FAST16_MAX

#define UINT_FAST16_MAX   UINT16_MAX

UINT_FAST32_MAX

#define UINT_FAST32_MAX   UINT32_MAX

UINT_FAST64_MAX

#define UINT_FAST64_MAX   UINT64_MAX

UINT_FAST8_MAX

#define UINT_FAST8_MAX   UINT8_MAX

UINT_LEAST16_MAX

#define UINT_LEAST16_MAX   UINT16_MAX

UINT_LEAST32_MAX

#define UINT_LEAST32_MAX   UINT32_MAX

UINT_LEAST64_MAX

#define UINT_LEAST64_MAX   UINT64_MAX

UINT_LEAST8_MAX

#define UINT_LEAST8_MAX   UINT8_MAX

UINTMAX_C

#define UINTMAX_C   UINT64_C

UINTMAX_MAX

#define UINTMAX_MAX   UINT64_MAX

UINTPTR_MAX

#define UINTPTR_MAX   UINT32_MAX

UNUSED

#define UNUSED

VARIANT_TAG

#define VARIANT_TAG	(		Archive,
			Type,
			Tag )

Value:

template <bool W>                         \
struct variant_serialization_traits<Archive<W>, Type> {       \
  static inline typename Archive<W>::variant_tag_type get_tag() { \
    return Tag;                           \
  }                                   \
}

VARINT_FIELD

#define VARINT_FIELD

(

f

)

Value:

do {                      \
  ar.tag(#f);                 \
  ar.serialize_varint(f);         \
  if (!ar.good()) return false;       \
} while(0);

VARINT_FIELD_N

#define VARINT_FIELD_N	(		t,
			f )

Value:

do {                      \
  ar.tag(t);                  \
  ar.serialize_varint(f);         \
  if (!ar.good()) return false;       \
} while(0);

VERSION_FIELD

#define VERSION_FIELD

(

v

)

Value:

uint32_t version = v;             \
do {                      \
  ar.tag("version");              \
  ar.serialize_varint(version);       \
  if (!ar.good()) return false;       \
} while(0);

WCHAR_MAX

#define WCHAR_MAX   _UI16_MAX

WCHAR_MIN

#define WCHAR_MIN   0

WINT_MAX

#define WINT_MAX   _UI16_MAX

WINT_MIN

#define WINT_MIN   0