Simple DSL AAPI based on. More...

#include <vector>
#include <deque>
#include <list>
#include <set>
#include <unordered_set>
#include <string>
#include <boost/type_traits/is_integral.hpp>
#include <boost/type_traits/integral_constant.hpp>

Include dependency graph for serialization.h:

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

Go to the source code of this file.

Classes
struct	is_blob_type< T >
	a descriptor for dispatching serialize More...
struct	has_free_serializer< T >
	a descriptor for dispatching serialize More...
struct	is_basic_type< T >
	a descriptor for dispatching serialize More...
struct	is_basic_type< std::pair< F, S > >
struct	is_basic_type< std::string >
struct	serializer< Archive, T >
	... wouldn't a class be better? More...

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

Macros
#define	BLOB_SERIALIZER(T)
	makes the type have a blob serializer trait defined
#define	FREE_SERIALIZER(T)
	adds the has_free_serializer to the type
#define	VARIANT_TAG(Archive, Type, Tag)
	Adds the tag \tag to the Archive of Type.
#define	BEGIN_SERIALIZE()
	Begins the environment of the DSL \detailed for describing how to serialize an of an archive type.
#define	BEGIN_SERIALIZE_OBJECT()
	begins the environment of the DSL \detailed for described the serialization of an object
#define	PREPARE_CUSTOM_VECTOR_SERIALIZATION(size, vec)
#define	PREPARE_CUSTOM_DEQUE_SERIALIZATION(size, vec)
#define	END_SERIALIZE()
	self-explanatory
#define	VALUE(f)
	the same as FIELD(f)
#define	FIELD_N(t, f)
	serializes a field f tagged t
#define	FIELD(f)
	tags the field with the variable name and then serializes it
#define	FIELDS(f)
	does not add a tag to the serialized value
#define	VARINT_FIELD(f)
	tags and serializes the varint f
#define	VARINT_FIELD_N(t, f)
	tags (as t) and serializes the varint f

Functions
template<class Archive, class T>
bool	do_serialize (Archive &ar, T &v)
	just calls the serialize function defined for ar and v...
template<class Archive>
bool	do_serialize (Archive &ar, bool &v)
template<typename T>
void	serialization::detail::prepare_custom_vector_serialization (size_t size, std::vector< T > &vec, const boost::mpl::bool_< true > &)
template<typename T>
void	serialization::detail::prepare_custom_vector_serialization (size_t size, std::vector< T > &vec, const boost::mpl::bool_< false > &)
template<typename T>
void	serialization::detail::prepare_custom_deque_serialization (size_t size, std::deque< T > &vec, const boost::mpl::bool_< true > &)
template<typename T>
void	serialization::detail::prepare_custom_deque_serialization (size_t size, std::deque< T > &vec, const boost::mpl::bool_< false > &)
template<class Stream>
bool	serialization::detail::do_check_stream_state (Stream &s, boost::mpl::bool_< true >, bool noeof)
template<class Stream>
bool	serialization::detail::do_check_stream_state (Stream &s, boost::mpl::bool_< false >, bool noeof)
template<class Archive>
bool	serialization::check_stream_state (Archive &ar, bool noeof=false)
template<class Archive, class T>
bool	serialization::serialize (Archive &ar, T &v)
template<class Archive, class T>
bool	serialization::serialize_noeof (Archive &ar, T &v)

Detailed Description

Simple DSL AAPI based on.

\detailed is_blob_type and has_free_serializer are both descriptors for dispatching on to the serialize function.

The API itself defines a domain specific language via dirty macro hacks. Greenspun's tenth rule is very much in action throughout this entire code base.

Definition in file serialization.h.

Macro Definition Documentation

◆ BEGIN_SERIALIZE

#define BEGIN_SERIALIZE ( )

Value:

template <bool W, template <bool> class Archive> \

bool do_serialize(Archive<W> &ar) {

do_serialize

bool do_serialize(Archive< false > &ar, std::vector< crypto::signature > &v)

Definition crypto.h:44

Begins the environment of the DSL \detailed for describing how to serialize an of an archive type.

\macro BEGIN_SERIALIZE

Definition at line 182 of file hash.h.

◆ BEGIN_SERIALIZE_OBJECT

#define BEGIN_SERIALIZE_OBJECT ( )

Value:

template <bool W, template <bool> class Archive>          \
bool 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){

begins the environment of the DSL \detailed for described the serialization of an object

\macro BEGIN_SERIALIZE_OBJECT

Definition at line 191 of file hash.h.

// Copyrights(c) 2017-2021, The Electroneum Project
// Copyrights(c) 2014-2019, The Monero Project
// 
// All rights reserved.
// 
// Redistribution and use in source and binary forms, with or without modification, are
// permitted provided that the following conditions are met:
// 
// 1. Redistributions of source code must retain the above copyright notice, this list of
//    conditions and the following disclaimer.
// 
// 2. Redistributions in binary form must reproduce the above copyright notice, this list
//    of conditions and the following disclaimer in the documentation and/or other
//    materials provided with the distribution.
// 
// 3. Neither the name of the copyright holder nor the names of its contributors may be
//    used to endorse or promote products derived from this software without specific
//    prior written permission.
// 
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY
// EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
// MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL
// THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
// PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
// INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
// STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF
// THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
// 
// Parts of this file are originally copyright (c) 2012-2013 The Cryptonote developers
 
#pragma once
 
#include <stddef.h>
#include <iostream>
#include <boost/utility/value_init.hpp>
 
#include "common/pod-class.h"
#include "generic-ops.h"
#include "hex.h"
#include "span.h"
 
namespace crypto {
 
  extern "C" {
#include "hash-ops.h"
  }
 
#pragma pack(push, 1)
  POD_CLASS hash {
    char data[HASH_SIZE];
  };
  POD_CLASS hash8 {
    char data[8];
  };
  POD_CLASS hash64 {
    char data[64];
  };
#pragma pack(pop)
 
  static_assert(sizeof(hash) == HASH_SIZE, "Invalid structure size");
  static_assert(sizeof(hash8) == 8, "Invalid structure size");
  static_assert(sizeof(hash64) == 64, "Invalid structure size");
 
  /*
    Cryptonight hash functions
  */
 
  inline void cn_fast_hash(const void *data, std::size_t length, hash &hash) {
    cn_fast_hash(data, length, reinterpret_cast<char *>(&hash));
  }
 
  inline hash cn_fast_hash(const void *data, std::size_t length) {
    hash h;
    cn_fast_hash(data, length, reinterpret_cast<char *>(&h));
    return h;
  }
 
  inline void cn_slow_hash(const void *data, std::size_t length, hash &hash, int variant = 0, uint64_t height = 0) {
    cn_slow_hash(data, length, reinterpret_cast<char *>(&hash), variant, 0/*prehashed*/, height);
  }
 
  inline void cn_slow_hash_prehashed(const void *data, std::size_t length, hash &hash, int variant = 0, uint64_t height = 0) {
    cn_slow_hash(data, length, reinterpret_cast<char *>(&hash), variant, 1/*prehashed*/, height);
  }
 
  inline void tree_hash(const hash *hashes, std::size_t count, hash &root_hash) {
    tree_hash(reinterpret_cast<const char (*)[HASH_SIZE]>(hashes), count, reinterpret_cast<char *>(&root_hash));
  }
 
  inline std::ostream &operator <<(std::ostream &o, const crypto::hash &v) {
    epee::to_hex::formatted(o, epee::as_byte_span(v)); return o;
  }
  inline std::ostream &operator <<(std::ostream &o, const crypto::hash8 &v) {
    epee::to_hex::formatted(o, epee::as_byte_span(v)); return o;
  }
  inline std::ostream &operator <<(std::ostream &o, const crypto::hash64 &v) {
    epee::to_hex::formatted(o, epee::as_byte_span(v)); return o;
  }
 
  const static crypto::hash null_hash = boost::value_initialized<crypto::hash>();
  const static crypto::hash8 null_hash8 = boost::value_initialized<crypto::hash8>();
  const static crypto::hash64 null_hash64 = boost::value_initialized<crypto::hash64>();
}
 
CRYPTO_MAKE_HASHABLE(hash)
CRYPTO_MAKE_COMPARABLE(hash8)
CRYPTO_MAKE_COMPARABLE(hash64)

◆ BLOB_SERIALIZER

#define BLOB_SERIALIZER ( T )

Value:

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

makes the type have a blob serializer trait defined

\macro BLOB_SERIALIZER

Definition at line 148 of file hash.h.

// Copyrights(c) 2017-2021, The Electroneum Project
// Copyrights(c) 2014-2019, The Monero Project
// 
// All rights reserved.
// 
// Redistribution and use in source and binary forms, with or without modification, are
// permitted provided that the following conditions are met:
// 
// 1. Redistributions of source code must retain the above copyright notice, this list of
//    conditions and the following disclaimer.
// 
// 2. Redistributions in binary form must reproduce the above copyright notice, this list
//    of conditions and the following disclaimer in the documentation and/or other
//    materials provided with the distribution.
// 
// 3. Neither the name of the copyright holder nor the names of its contributors may be
//    used to endorse or promote products derived from this software without specific
//    prior written permission.
// 
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY
// EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
// MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL
// THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
// PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
// INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
// STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF
// THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
// 
// Parts of this file are originally copyright (c) 2012-2013 The Cryptonote developers
 
#pragma once
 
#include <stddef.h>
#include <iostream>
#include <boost/utility/value_init.hpp>
 
#include "common/pod-class.h"
#include "generic-ops.h"
#include "hex.h"
#include "span.h"
 
namespace crypto {
 
  extern "C" {
#include "hash-ops.h"
  }
 
#pragma pack(push, 1)
  POD_CLASS hash {
    char data[HASH_SIZE];
  };
  POD_CLASS hash8 {
    char data[8];
  };
  POD_CLASS hash64 {
    char data[64];
  };
#pragma pack(pop)
 
  static_assert(sizeof(hash) == HASH_SIZE, "Invalid structure size");
  static_assert(sizeof(hash8) == 8, "Invalid structure size");
  static_assert(sizeof(hash64) == 64, "Invalid structure size");
 
  /*
    Cryptonight hash functions
  */
 
  inline void cn_fast_hash(const void *data, std::size_t length, hash &hash) {
    cn_fast_hash(data, length, reinterpret_cast<char *>(&hash));
  }
 
  inline hash cn_fast_hash(const void *data, std::size_t length) {
    hash h;
    cn_fast_hash(data, length, reinterpret_cast<char *>(&h));
    return h;
  }
 
  inline void cn_slow_hash(const void *data, std::size_t length, hash &hash, int variant = 0, uint64_t height = 0) {
    cn_slow_hash(data, length, reinterpret_cast<char *>(&hash), variant, 0/*prehashed*/, height);
  }
 
  inline void cn_slow_hash_prehashed(const void *data, std::size_t length, hash &hash, int variant = 0, uint64_t height = 0) {
    cn_slow_hash(data, length, reinterpret_cast<char *>(&hash), variant, 1/*prehashed*/, height);
  }
 
  inline void tree_hash(const hash *hashes, std::size_t count, hash &root_hash) {
    tree_hash(reinterpret_cast<const char (*)[HASH_SIZE]>(hashes), count, reinterpret_cast<char *>(&root_hash));
  }
 
  inline std::ostream &operator <<(std::ostream &o, const crypto::hash &v) {
    epee::to_hex::formatted(o, epee::as_byte_span(v)); return o;
  }
  inline std::ostream &operator <<(std::ostream &o, const crypto::hash8 &v) {
    epee::to_hex::formatted(o, epee::as_byte_span(v)); return o;
  }
  inline std::ostream &operator <<(std::ostream &o, const crypto::hash64 &v) {
    epee::to_hex::formatted(o, epee::as_byte_span(v)); return o;
  }
 
  const static crypto::hash null_hash = boost::value_initialized<crypto::hash>();
  const static crypto::hash8 null_hash8 = boost::value_initialized<crypto::hash8>();
  const static crypto::hash64 null_hash64 = boost::value_initialized<crypto::hash64>();
}
 
CRYPTO_MAKE_HASHABLE(hash)
CRYPTO_MAKE_COMPARABLE(hash8)
CRYPTO_MAKE_COMPARABLE(hash64)

◆ END_SERIALIZE

#define END_SERIALIZE ( )

Value:

return ar.stream().good(); \

}

self-explanatory

\macro END_SERIALIZE

Definition at line 215 of file hash.h.

// Copyrights(c) 2017-2021, The Electroneum Project
// Copyrights(c) 2014-2019, The Monero Project
// 
// All rights reserved.
// 
// Redistribution and use in source and binary forms, with or without modification, are
// permitted provided that the following conditions are met:
// 
// 1. Redistributions of source code must retain the above copyright notice, this list of
//    conditions and the following disclaimer.
// 
// 2. Redistributions in binary form must reproduce the above copyright notice, this list
//    of conditions and the following disclaimer in the documentation and/or other
//    materials provided with the distribution.
// 
// 3. Neither the name of the copyright holder nor the names of its contributors may be
//    used to endorse or promote products derived from this software without specific
//    prior written permission.
// 
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY
// EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
// MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL
// THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
// PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
// INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
// STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF
// THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
// 
// Parts of this file are originally copyright (c) 2012-2013 The Cryptonote developers
 
#pragma once
 
#include <stddef.h>
#include <iostream>
#include <boost/utility/value_init.hpp>
 
#include "common/pod-class.h"
#include "generic-ops.h"
#include "hex.h"
#include "span.h"
 
namespace crypto {
 
  extern "C" {
#include "hash-ops.h"
  }
 
#pragma pack(push, 1)
  POD_CLASS hash {
    char data[HASH_SIZE];
  };
  POD_CLASS hash8 {
    char data[8];
  };
  POD_CLASS hash64 {
    char data[64];
  };
#pragma pack(pop)
 
  static_assert(sizeof(hash) == HASH_SIZE, "Invalid structure size");
  static_assert(sizeof(hash8) == 8, "Invalid structure size");
  static_assert(sizeof(hash64) == 64, "Invalid structure size");
 
  /*
    Cryptonight hash functions
  */
 
  inline void cn_fast_hash(const void *data, std::size_t length, hash &hash) {
    cn_fast_hash(data, length, reinterpret_cast<char *>(&hash));
  }
 
  inline hash cn_fast_hash(const void *data, std::size_t length) {
    hash h;
    cn_fast_hash(data, length, reinterpret_cast<char *>(&h));
    return h;
  }
 
  inline void cn_slow_hash(const void *data, std::size_t length, hash &hash, int variant = 0, uint64_t height = 0) {
    cn_slow_hash(data, length, reinterpret_cast<char *>(&hash), variant, 0/*prehashed*/, height);
  }
 
  inline void cn_slow_hash_prehashed(const void *data, std::size_t length, hash &hash, int variant = 0, uint64_t height = 0) {
    cn_slow_hash(data, length, reinterpret_cast<char *>(&hash), variant, 1/*prehashed*/, height);
  }
 
  inline void tree_hash(const hash *hashes, std::size_t count, hash &root_hash) {
    tree_hash(reinterpret_cast<const char (*)[HASH_SIZE]>(hashes), count, reinterpret_cast<char *>(&root_hash));
  }
 
  inline std::ostream &operator <<(std::ostream &o, const crypto::hash &v) {
    epee::to_hex::formatted(o, epee::as_byte_span(v)); return o;
  }
  inline std::ostream &operator <<(std::ostream &o, const crypto::hash8 &v) {
    epee::to_hex::formatted(o, epee::as_byte_span(v)); return o;
  }
  inline std::ostream &operator <<(std::ostream &o, const crypto::hash64 &v) {
    epee::to_hex::formatted(o, epee::as_byte_span(v)); return o;
  }
 
  const static crypto::hash null_hash = boost::value_initialized<crypto::hash>();
  const static crypto::hash8 null_hash8 = boost::value_initialized<crypto::hash8>();
  const static crypto::hash64 null_hash64 = boost::value_initialized<crypto::hash64>();
}
 
CRYPTO_MAKE_HASHABLE(hash)
CRYPTO_MAKE_COMPARABLE(hash8)
CRYPTO_MAKE_COMPARABLE(hash64)

◆ FIELD

#define FIELD ( f )

Value:

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

tags the field with the variable name and then serializes it

\macro FIELD(f)

Definition at line 244 of file hash.h.

// Copyrights(c) 2017-2021, The Electroneum Project
// Copyrights(c) 2014-2019, The Monero Project
// 
// All rights reserved.
// 
// Redistribution and use in source and binary forms, with or without modification, are
// permitted provided that the following conditions are met:
// 
// 1. Redistributions of source code must retain the above copyright notice, this list of
//    conditions and the following disclaimer.
// 
// 2. Redistributions in binary form must reproduce the above copyright notice, this list
//    of conditions and the following disclaimer in the documentation and/or other
//    materials provided with the distribution.
// 
// 3. Neither the name of the copyright holder nor the names of its contributors may be
//    used to endorse or promote products derived from this software without specific
//    prior written permission.
// 
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY
// EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
// MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL
// THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
// PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
// INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
// STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF
// THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
// 
// Parts of this file are originally copyright (c) 2012-2013 The Cryptonote developers
 
#pragma once
 
#include <stddef.h>
#include <iostream>
#include <boost/utility/value_init.hpp>
 
#include "common/pod-class.h"
#include "generic-ops.h"
#include "hex.h"
#include "span.h"
 
namespace crypto {
 
  extern "C" {
#include "hash-ops.h"
  }
 
#pragma pack(push, 1)
  POD_CLASS hash {
    char data[HASH_SIZE];
  };
  POD_CLASS hash8 {
    char data[8];
  };
  POD_CLASS hash64 {
    char data[64];
  };
#pragma pack(pop)
 
  static_assert(sizeof(hash) == HASH_SIZE, "Invalid structure size");
  static_assert(sizeof(hash8) == 8, "Invalid structure size");
  static_assert(sizeof(hash64) == 64, "Invalid structure size");
 
  /*
    Cryptonight hash functions
  */
 
  inline void cn_fast_hash(const void *data, std::size_t length, hash &hash) {
    cn_fast_hash(data, length, reinterpret_cast<char *>(&hash));
  }
 
  inline hash cn_fast_hash(const void *data, std::size_t length) {
    hash h;
    cn_fast_hash(data, length, reinterpret_cast<char *>(&h));
    return h;
  }
 
  inline void cn_slow_hash(const void *data, std::size_t length, hash &hash, int variant = 0, uint64_t height = 0) {
    cn_slow_hash(data, length, reinterpret_cast<char *>(&hash), variant, 0/*prehashed*/, height);
  }
 
  inline void cn_slow_hash_prehashed(const void *data, std::size_t length, hash &hash, int variant = 0, uint64_t height = 0) {
    cn_slow_hash(data, length, reinterpret_cast<char *>(&hash), variant, 1/*prehashed*/, height);
  }
 
  inline void tree_hash(const hash *hashes, std::size_t count, hash &root_hash) {
    tree_hash(reinterpret_cast<const char (*)[HASH_SIZE]>(hashes), count, reinterpret_cast<char *>(&root_hash));
  }
 
  inline std::ostream &operator <<(std::ostream &o, const crypto::hash &v) {
    epee::to_hex::formatted(o, epee::as_byte_span(v)); return o;
  }
  inline std::ostream &operator <<(std::ostream &o, const crypto::hash8 &v) {
    epee::to_hex::formatted(o, epee::as_byte_span(v)); return o;
  }
  inline std::ostream &operator <<(std::ostream &o, const crypto::hash64 &v) {
    epee::to_hex::formatted(o, epee::as_byte_span(v)); return o;
  }
 
  const static crypto::hash null_hash = boost::value_initialized<crypto::hash>();
  const static crypto::hash8 null_hash8 = boost::value_initialized<crypto::hash8>();
  const static crypto::hash64 null_hash64 = boost::value_initialized<crypto::hash64>();
}
 
CRYPTO_MAKE_HASHABLE(hash)
CRYPTO_MAKE_COMPARABLE(hash8)
CRYPTO_MAKE_COMPARABLE(hash64)

◆ FIELD_N

#define FIELD_N	(		t,
			f )

Value:

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

serializes a field f tagged t

\macro FIELD_N(t,f)

Definition at line 233 of file hash.h.

// Copyrights(c) 2017-2021, The Electroneum Project
// Copyrights(c) 2014-2019, The Monero Project
// 
// All rights reserved.
// 
// Redistribution and use in source and binary forms, with or without modification, are
// permitted provided that the following conditions are met:
// 
// 1. Redistributions of source code must retain the above copyright notice, this list of
//    conditions and the following disclaimer.
// 
// 2. Redistributions in binary form must reproduce the above copyright notice, this list
//    of conditions and the following disclaimer in the documentation and/or other
//    materials provided with the distribution.
// 
// 3. Neither the name of the copyright holder nor the names of its contributors may be
//    used to endorse or promote products derived from this software without specific
//    prior written permission.
// 
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY
// EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
// MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL
// THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
// PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
// INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
// STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF
// THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
// 
// Parts of this file are originally copyright (c) 2012-2013 The Cryptonote developers
 
#pragma once
 
#include <stddef.h>
#include <iostream>
#include <boost/utility/value_init.hpp>
 
#include "common/pod-class.h"
#include "generic-ops.h"
#include "hex.h"
#include "span.h"
 
namespace crypto {
 
  extern "C" {
#include "hash-ops.h"
  }
 
#pragma pack(push, 1)
  POD_CLASS hash {
    char data[HASH_SIZE];
  };
  POD_CLASS hash8 {
    char data[8];
  };
  POD_CLASS hash64 {
    char data[64];
  };
#pragma pack(pop)
 
  static_assert(sizeof(hash) == HASH_SIZE, "Invalid structure size");
  static_assert(sizeof(hash8) == 8, "Invalid structure size");
  static_assert(sizeof(hash64) == 64, "Invalid structure size");
 
  /*
    Cryptonight hash functions
  */
 
  inline void cn_fast_hash(const void *data, std::size_t length, hash &hash) {
    cn_fast_hash(data, length, reinterpret_cast<char *>(&hash));
  }
 
  inline hash cn_fast_hash(const void *data, std::size_t length) {
    hash h;
    cn_fast_hash(data, length, reinterpret_cast<char *>(&h));
    return h;
  }
 
  inline void cn_slow_hash(const void *data, std::size_t length, hash &hash, int variant = 0, uint64_t height = 0) {
    cn_slow_hash(data, length, reinterpret_cast<char *>(&hash), variant, 0/*prehashed*/, height);
  }
 
  inline void cn_slow_hash_prehashed(const void *data, std::size_t length, hash &hash, int variant = 0, uint64_t height = 0) {
    cn_slow_hash(data, length, reinterpret_cast<char *>(&hash), variant, 1/*prehashed*/, height);
  }
 
  inline void tree_hash(const hash *hashes, std::size_t count, hash &root_hash) {
    tree_hash(reinterpret_cast<const char (*)[HASH_SIZE]>(hashes), count, reinterpret_cast<char *>(&root_hash));
  }
 
  inline std::ostream &operator <<(std::ostream &o, const crypto::hash &v) {
    epee::to_hex::formatted(o, epee::as_byte_span(v)); return o;
  }
  inline std::ostream &operator <<(std::ostream &o, const crypto::hash8 &v) {
    epee::to_hex::formatted(o, epee::as_byte_span(v)); return o;
  }
  inline std::ostream &operator <<(std::ostream &o, const crypto::hash64 &v) {
    epee::to_hex::formatted(o, epee::as_byte_span(v)); return o;
  }
 
  const static crypto::hash null_hash = boost::value_initialized<crypto::hash>();
  const static crypto::hash8 null_hash8 = boost::value_initialized<crypto::hash8>();
  const static crypto::hash64 null_hash64 = boost::value_initialized<crypto::hash64>();
}
 
CRYPTO_MAKE_HASHABLE(hash)
CRYPTO_MAKE_COMPARABLE(hash8)
CRYPTO_MAKE_COMPARABLE(hash64)

◆ FIELDS

#define FIELDS ( f )

Value:

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

does not add a tag to the serialized value

\macro FIELDS(f)

Definition at line 255 of file hash.h.

// Copyrights(c) 2017-2021, The Electroneum Project
// Copyrights(c) 2014-2019, The Monero Project
// 
// All rights reserved.
// 
// Redistribution and use in source and binary forms, with or without modification, are
// permitted provided that the following conditions are met:
// 
// 1. Redistributions of source code must retain the above copyright notice, this list of
//    conditions and the following disclaimer.
// 
// 2. Redistributions in binary form must reproduce the above copyright notice, this list
//    of conditions and the following disclaimer in the documentation and/or other
//    materials provided with the distribution.
// 
// 3. Neither the name of the copyright holder nor the names of its contributors may be
//    used to endorse or promote products derived from this software without specific
//    prior written permission.
// 
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY
// EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
// MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL
// THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
// PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
// INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
// STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF
// THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
// 
// Parts of this file are originally copyright (c) 2012-2013 The Cryptonote developers
 
#pragma once
 
#include <stddef.h>
#include <iostream>
#include <boost/utility/value_init.hpp>
 
#include "common/pod-class.h"
#include "generic-ops.h"
#include "hex.h"
#include "span.h"
 
namespace crypto {
 
  extern "C" {
#include "hash-ops.h"
  }
 
#pragma pack(push, 1)
  POD_CLASS hash {
    char data[HASH_SIZE];
  };
  POD_CLASS hash8 {
    char data[8];
  };
  POD_CLASS hash64 {
    char data[64];
  };
#pragma pack(pop)
 
  static_assert(sizeof(hash) == HASH_SIZE, "Invalid structure size");
  static_assert(sizeof(hash8) == 8, "Invalid structure size");
  static_assert(sizeof(hash64) == 64, "Invalid structure size");
 
  /*
    Cryptonight hash functions
  */
 
  inline void cn_fast_hash(const void *data, std::size_t length, hash &hash) {
    cn_fast_hash(data, length, reinterpret_cast<char *>(&hash));
  }
 
  inline hash cn_fast_hash(const void *data, std::size_t length) {
    hash h;
    cn_fast_hash(data, length, reinterpret_cast<char *>(&h));
    return h;
  }
 
  inline void cn_slow_hash(const void *data, std::size_t length, hash &hash, int variant = 0, uint64_t height = 0) {
    cn_slow_hash(data, length, reinterpret_cast<char *>(&hash), variant, 0/*prehashed*/, height);
  }
 
  inline void cn_slow_hash_prehashed(const void *data, std::size_t length, hash &hash, int variant = 0, uint64_t height = 0) {
    cn_slow_hash(data, length, reinterpret_cast<char *>(&hash), variant, 1/*prehashed*/, height);
  }
 
  inline void tree_hash(const hash *hashes, std::size_t count, hash &root_hash) {
    tree_hash(reinterpret_cast<const char (*)[HASH_SIZE]>(hashes), count, reinterpret_cast<char *>(&root_hash));
  }
 
  inline std::ostream &operator <<(std::ostream &o, const crypto::hash &v) {
    epee::to_hex::formatted(o, epee::as_byte_span(v)); return o;
  }
  inline std::ostream &operator <<(std::ostream &o, const crypto::hash8 &v) {
    epee::to_hex::formatted(o, epee::as_byte_span(v)); return o;
  }
  inline std::ostream &operator <<(std::ostream &o, const crypto::hash64 &v) {
    epee::to_hex::formatted(o, epee::as_byte_span(v)); return o;
  }
 
  const static crypto::hash null_hash = boost::value_initialized<crypto::hash>();
  const static crypto::hash8 null_hash8 = boost::value_initialized<crypto::hash8>();
  const static crypto::hash64 null_hash64 = boost::value_initialized<crypto::hash64>();
}
 
CRYPTO_MAKE_HASHABLE(hash)
CRYPTO_MAKE_COMPARABLE(hash8)
CRYPTO_MAKE_COMPARABLE(hash64)

◆ FREE_SERIALIZER

#define FREE_SERIALIZER ( T )

Value:

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

adds the has_free_serializer to the type

\macro FREE_SERIALIZER

Definition at line 158 of file hash.h.

// Copyrights(c) 2017-2021, The Electroneum Project
// Copyrights(c) 2014-2019, The Monero Project
// 
// All rights reserved.
// 
// Redistribution and use in source and binary forms, with or without modification, are
// permitted provided that the following conditions are met:
// 
// 1. Redistributions of source code must retain the above copyright notice, this list of
//    conditions and the following disclaimer.
// 
// 2. Redistributions in binary form must reproduce the above copyright notice, this list
//    of conditions and the following disclaimer in the documentation and/or other
//    materials provided with the distribution.
// 
// 3. Neither the name of the copyright holder nor the names of its contributors may be
//    used to endorse or promote products derived from this software without specific
//    prior written permission.
// 
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY
// EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
// MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL
// THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
// PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
// INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
// STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF
// THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
// 
// Parts of this file are originally copyright (c) 2012-2013 The Cryptonote developers
 
#pragma once
 
#include <stddef.h>
#include <iostream>
#include <boost/utility/value_init.hpp>
 
#include "common/pod-class.h"
#include "generic-ops.h"
#include "hex.h"
#include "span.h"
 
namespace crypto {
 
  extern "C" {
#include "hash-ops.h"
  }
 
#pragma pack(push, 1)
  POD_CLASS hash {
    char data[HASH_SIZE];
  };
  POD_CLASS hash8 {
    char data[8];
  };
  POD_CLASS hash64 {
    char data[64];
  };
#pragma pack(pop)
 
  static_assert(sizeof(hash) == HASH_SIZE, "Invalid structure size");
  static_assert(sizeof(hash8) == 8, "Invalid structure size");
  static_assert(sizeof(hash64) == 64, "Invalid structure size");
 
  /*
    Cryptonight hash functions
  */
 
  inline void cn_fast_hash(const void *data, std::size_t length, hash &hash) {
    cn_fast_hash(data, length, reinterpret_cast<char *>(&hash));
  }
 
  inline hash cn_fast_hash(const void *data, std::size_t length) {
    hash h;
    cn_fast_hash(data, length, reinterpret_cast<char *>(&h));
    return h;
  }
 
  inline void cn_slow_hash(const void *data, std::size_t length, hash &hash, int variant = 0, uint64_t height = 0) {
    cn_slow_hash(data, length, reinterpret_cast<char *>(&hash), variant, 0/*prehashed*/, height);
  }
 
  inline void cn_slow_hash_prehashed(const void *data, std::size_t length, hash &hash, int variant = 0, uint64_t height = 0) {
    cn_slow_hash(data, length, reinterpret_cast<char *>(&hash), variant, 1/*prehashed*/, height);
  }
 
  inline void tree_hash(const hash *hashes, std::size_t count, hash &root_hash) {
    tree_hash(reinterpret_cast<const char (*)[HASH_SIZE]>(hashes), count, reinterpret_cast<char *>(&root_hash));
  }
 
  inline std::ostream &operator <<(std::ostream &o, const crypto::hash &v) {
    epee::to_hex::formatted(o, epee::as_byte_span(v)); return o;
  }
  inline std::ostream &operator <<(std::ostream &o, const crypto::hash8 &v) {
    epee::to_hex::formatted(o, epee::as_byte_span(v)); return o;
  }
  inline std::ostream &operator <<(std::ostream &o, const crypto::hash64 &v) {
    epee::to_hex::formatted(o, epee::as_byte_span(v)); return o;
  }
 
  const static crypto::hash null_hash = boost::value_initialized<crypto::hash>();
  const static crypto::hash8 null_hash8 = boost::value_initialized<crypto::hash8>();
  const static crypto::hash64 null_hash64 = boost::value_initialized<crypto::hash64>();
}
 
CRYPTO_MAKE_HASHABLE(hash)
CRYPTO_MAKE_COMPARABLE(hash8)
CRYPTO_MAKE_COMPARABLE(hash64)

◆ PREPARE_CUSTOM_DEQUE_SERIALIZATION

#define PREPARE_CUSTOM_DEQUE_SERIALIZATION	(		size,
			vec )

Value:

::serialization::detail::prepare_custom_deque_serialization(size, vec, typename Archive<W>::is_saving())

serialization::detail::prepare_custom_deque_serialization

void prepare_custom_deque_serialization(size_t size, std::deque< T > &vec, const boost::mpl::bool_< true > &)

Definition serialization.h:306

\macro PREPARE_CUSTOM_DEQUE_SERIALIZATION

Definition at line 209 of file hash.h.

// Copyrights(c) 2017-2021, The Electroneum Project
// Copyrights(c) 2014-2019, The Monero Project
// 
// All rights reserved.
// 
// Redistribution and use in source and binary forms, with or without modification, are
// permitted provided that the following conditions are met:
// 
// 1. Redistributions of source code must retain the above copyright notice, this list of
//    conditions and the following disclaimer.
// 
// 2. Redistributions in binary form must reproduce the above copyright notice, this list
//    of conditions and the following disclaimer in the documentation and/or other
//    materials provided with the distribution.
// 
// 3. Neither the name of the copyright holder nor the names of its contributors may be
//    used to endorse or promote products derived from this software without specific
//    prior written permission.
// 
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY
// EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
// MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL
// THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
// PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
// INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
// STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF
// THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
// 
// Parts of this file are originally copyright (c) 2012-2013 The Cryptonote developers
 
#pragma once
 
#include <stddef.h>
#include <iostream>
#include <boost/utility/value_init.hpp>
 
#include "common/pod-class.h"
#include "generic-ops.h"
#include "hex.h"
#include "span.h"
 
namespace crypto {
 
  extern "C" {
#include "hash-ops.h"
  }
 
#pragma pack(push, 1)
  POD_CLASS hash {
    char data[HASH_SIZE];
  };
  POD_CLASS hash8 {
    char data[8];
  };
  POD_CLASS hash64 {
    char data[64];
  };
#pragma pack(pop)
 
  static_assert(sizeof(hash) == HASH_SIZE, "Invalid structure size");
  static_assert(sizeof(hash8) == 8, "Invalid structure size");
  static_assert(sizeof(hash64) == 64, "Invalid structure size");
 
  /*
    Cryptonight hash functions
  */
 
  inline void cn_fast_hash(const void *data, std::size_t length, hash &hash) {
    cn_fast_hash(data, length, reinterpret_cast<char *>(&hash));
  }
 
  inline hash cn_fast_hash(const void *data, std::size_t length) {
    hash h;
    cn_fast_hash(data, length, reinterpret_cast<char *>(&h));
    return h;
  }
 
  inline void cn_slow_hash(const void *data, std::size_t length, hash &hash, int variant = 0, uint64_t height = 0) {
    cn_slow_hash(data, length, reinterpret_cast<char *>(&hash), variant, 0/*prehashed*/, height);
  }
 
  inline void cn_slow_hash_prehashed(const void *data, std::size_t length, hash &hash, int variant = 0, uint64_t height = 0) {
    cn_slow_hash(data, length, reinterpret_cast<char *>(&hash), variant, 1/*prehashed*/, height);
  }
 
  inline void tree_hash(const hash *hashes, std::size_t count, hash &root_hash) {
    tree_hash(reinterpret_cast<const char (*)[HASH_SIZE]>(hashes), count, reinterpret_cast<char *>(&root_hash));
  }
 
  inline std::ostream &operator <<(std::ostream &o, const crypto::hash &v) {
    epee::to_hex::formatted(o, epee::as_byte_span(v)); return o;
  }
  inline std::ostream &operator <<(std::ostream &o, const crypto::hash8 &v) {
    epee::to_hex::formatted(o, epee::as_byte_span(v)); return o;
  }
  inline std::ostream &operator <<(std::ostream &o, const crypto::hash64 &v) {
    epee::to_hex::formatted(o, epee::as_byte_span(v)); return o;
  }
 
  const static crypto::hash null_hash = boost::value_initialized<crypto::hash>();
  const static crypto::hash8 null_hash8 = boost::value_initialized<crypto::hash8>();
  const static crypto::hash64 null_hash64 = boost::value_initialized<crypto::hash64>();
}
 
CRYPTO_MAKE_HASHABLE(hash)
CRYPTO_MAKE_COMPARABLE(hash8)
CRYPTO_MAKE_COMPARABLE(hash64)

◆ PREPARE_CUSTOM_VECTOR_SERIALIZATION

#define PREPARE_CUSTOM_VECTOR_SERIALIZATION	(		size,
			vec )

Value:

::serialization::detail::prepare_custom_vector_serialization(size, vec, typename Archive<W>::is_saving())

serialization::detail::prepare_custom_vector_serialization

void prepare_custom_vector_serialization(size_t size, std::vector< T > &vec, const boost::mpl::bool_< true > &)

Definition serialization.h:295

\macro PREPARE_CUSTOM_VECTOR_SERIALIZATION

Definition at line 204 of file hash.h.

// Copyrights(c) 2017-2021, The Electroneum Project
// Copyrights(c) 2014-2019, The Monero Project
// 
// All rights reserved.
// 
// Redistribution and use in source and binary forms, with or without modification, are
// permitted provided that the following conditions are met:
// 
// 1. Redistributions of source code must retain the above copyright notice, this list of
//    conditions and the following disclaimer.
// 
// 2. Redistributions in binary form must reproduce the above copyright notice, this list
//    of conditions and the following disclaimer in the documentation and/or other
//    materials provided with the distribution.
// 
// 3. Neither the name of the copyright holder nor the names of its contributors may be
//    used to endorse or promote products derived from this software without specific
//    prior written permission.
// 
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY
// EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
// MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL
// THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
// PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
// INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
// STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF
// THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
// 
// Parts of this file are originally copyright (c) 2012-2013 The Cryptonote developers
 
#pragma once
 
#include <stddef.h>
#include <iostream>
#include <boost/utility/value_init.hpp>
 
#include "common/pod-class.h"
#include "generic-ops.h"
#include "hex.h"
#include "span.h"
 
namespace crypto {
 
  extern "C" {
#include "hash-ops.h"
  }
 
#pragma pack(push, 1)
  POD_CLASS hash {
    char data[HASH_SIZE];
  };
  POD_CLASS hash8 {
    char data[8];
  };
  POD_CLASS hash64 {
    char data[64];
  };
#pragma pack(pop)
 
  static_assert(sizeof(hash) == HASH_SIZE, "Invalid structure size");
  static_assert(sizeof(hash8) == 8, "Invalid structure size");
  static_assert(sizeof(hash64) == 64, "Invalid structure size");
 
  /*
    Cryptonight hash functions
  */
 
  inline void cn_fast_hash(const void *data, std::size_t length, hash &hash) {
    cn_fast_hash(data, length, reinterpret_cast<char *>(&hash));
  }
 
  inline hash cn_fast_hash(const void *data, std::size_t length) {
    hash h;
    cn_fast_hash(data, length, reinterpret_cast<char *>(&h));
    return h;
  }
 
  inline void cn_slow_hash(const void *data, std::size_t length, hash &hash, int variant = 0, uint64_t height = 0) {
    cn_slow_hash(data, length, reinterpret_cast<char *>(&hash), variant, 0/*prehashed*/, height);
  }
 
  inline void cn_slow_hash_prehashed(const void *data, std::size_t length, hash &hash, int variant = 0, uint64_t height = 0) {
    cn_slow_hash(data, length, reinterpret_cast<char *>(&hash), variant, 1/*prehashed*/, height);
  }
 
  inline void tree_hash(const hash *hashes, std::size_t count, hash &root_hash) {
    tree_hash(reinterpret_cast<const char (*)[HASH_SIZE]>(hashes), count, reinterpret_cast<char *>(&root_hash));
  }
 
  inline std::ostream &operator <<(std::ostream &o, const crypto::hash &v) {
    epee::to_hex::formatted(o, epee::as_byte_span(v)); return o;
  }
  inline std::ostream &operator <<(std::ostream &o, const crypto::hash8 &v) {
    epee::to_hex::formatted(o, epee::as_byte_span(v)); return o;
  }
  inline std::ostream &operator <<(std::ostream &o, const crypto::hash64 &v) {
    epee::to_hex::formatted(o, epee::as_byte_span(v)); return o;
  }
 
  const static crypto::hash null_hash = boost::value_initialized<crypto::hash>();
  const static crypto::hash8 null_hash8 = boost::value_initialized<crypto::hash8>();
  const static crypto::hash64 null_hash64 = boost::value_initialized<crypto::hash64>();
}
 
CRYPTO_MAKE_HASHABLE(hash)
CRYPTO_MAKE_COMPARABLE(hash8)
CRYPTO_MAKE_COMPARABLE(hash64)

◆ VALUE

#define VALUE ( f )

Value:

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

the same as FIELD(f)

\macro VALUE(f)

Definition at line 222 of file hash.h.

// Copyrights(c) 2017-2021, The Electroneum Project
// Copyrights(c) 2014-2019, The Monero Project
// 
// All rights reserved.
// 
// Redistribution and use in source and binary forms, with or without modification, are
// permitted provided that the following conditions are met:
// 
// 1. Redistributions of source code must retain the above copyright notice, this list of
//    conditions and the following disclaimer.
// 
// 2. Redistributions in binary form must reproduce the above copyright notice, this list
//    of conditions and the following disclaimer in the documentation and/or other
//    materials provided with the distribution.
// 
// 3. Neither the name of the copyright holder nor the names of its contributors may be
//    used to endorse or promote products derived from this software without specific
//    prior written permission.
// 
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY
// EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
// MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL
// THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
// PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
// INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
// STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF
// THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
// 
// Parts of this file are originally copyright (c) 2012-2013 The Cryptonote developers
 
#pragma once
 
#include <stddef.h>
#include <iostream>
#include <boost/utility/value_init.hpp>
 
#include "common/pod-class.h"
#include "generic-ops.h"
#include "hex.h"
#include "span.h"
 
namespace crypto {
 
  extern "C" {
#include "hash-ops.h"
  }
 
#pragma pack(push, 1)
  POD_CLASS hash {
    char data[HASH_SIZE];
  };
  POD_CLASS hash8 {
    char data[8];
  };
  POD_CLASS hash64 {
    char data[64];
  };
#pragma pack(pop)
 
  static_assert(sizeof(hash) == HASH_SIZE, "Invalid structure size");
  static_assert(sizeof(hash8) == 8, "Invalid structure size");
  static_assert(sizeof(hash64) == 64, "Invalid structure size");
 
  /*
    Cryptonight hash functions
  */
 
  inline void cn_fast_hash(const void *data, std::size_t length, hash &hash) {
    cn_fast_hash(data, length, reinterpret_cast<char *>(&hash));
  }
 
  inline hash cn_fast_hash(const void *data, std::size_t length) {
    hash h;
    cn_fast_hash(data, length, reinterpret_cast<char *>(&h));
    return h;
  }
 
  inline void cn_slow_hash(const void *data, std::size_t length, hash &hash, int variant = 0, uint64_t height = 0) {
    cn_slow_hash(data, length, reinterpret_cast<char *>(&hash), variant, 0/*prehashed*/, height);
  }
 
  inline void cn_slow_hash_prehashed(const void *data, std::size_t length, hash &hash, int variant = 0, uint64_t height = 0) {
    cn_slow_hash(data, length, reinterpret_cast<char *>(&hash), variant, 1/*prehashed*/, height);
  }
 
  inline void tree_hash(const hash *hashes, std::size_t count, hash &root_hash) {
    tree_hash(reinterpret_cast<const char (*)[HASH_SIZE]>(hashes), count, reinterpret_cast<char *>(&root_hash));
  }
 
  inline std::ostream &operator <<(std::ostream &o, const crypto::hash &v) {
    epee::to_hex::formatted(o, epee::as_byte_span(v)); return o;
  }
  inline std::ostream &operator <<(std::ostream &o, const crypto::hash8 &v) {
    epee::to_hex::formatted(o, epee::as_byte_span(v)); return o;
  }
  inline std::ostream &operator <<(std::ostream &o, const crypto::hash64 &v) {
    epee::to_hex::formatted(o, epee::as_byte_span(v)); return o;
  }
 
  const static crypto::hash null_hash = boost::value_initialized<crypto::hash>();
  const static crypto::hash8 null_hash8 = boost::value_initialized<crypto::hash8>();
  const static crypto::hash64 null_hash64 = boost::value_initialized<crypto::hash64>();
}
 
CRYPTO_MAKE_HASHABLE(hash)
CRYPTO_MAKE_COMPARABLE(hash8)
CRYPTO_MAKE_COMPARABLE(hash64)

◆ 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;                           \
  }                                   \
}

Adds the tag \tag to the Archive of Type.

\macro VARIANT_TAG

Definition at line 168 of file hash.h.

// Copyrights(c) 2017-2021, The Electroneum Project
// Copyrights(c) 2014-2019, The Monero Project
// 
// All rights reserved.
// 
// Redistribution and use in source and binary forms, with or without modification, are
// permitted provided that the following conditions are met:
// 
// 1. Redistributions of source code must retain the above copyright notice, this list of
//    conditions and the following disclaimer.
// 
// 2. Redistributions in binary form must reproduce the above copyright notice, this list
//    of conditions and the following disclaimer in the documentation and/or other
//    materials provided with the distribution.
// 
// 3. Neither the name of the copyright holder nor the names of its contributors may be
//    used to endorse or promote products derived from this software without specific
//    prior written permission.
// 
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY
// EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
// MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL
// THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
// PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
// INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
// STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF
// THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
// 
// Parts of this file are originally copyright (c) 2012-2013 The Cryptonote developers
 
#pragma once
 
#include <stddef.h>
#include <iostream>
#include <boost/utility/value_init.hpp>
 
#include "common/pod-class.h"
#include "generic-ops.h"
#include "hex.h"
#include "span.h"
 
namespace crypto {
 
  extern "C" {
#include "hash-ops.h"
  }
 
#pragma pack(push, 1)
  POD_CLASS hash {
    char data[HASH_SIZE];
  };
  POD_CLASS hash8 {
    char data[8];
  };
  POD_CLASS hash64 {
    char data[64];
  };
#pragma pack(pop)
 
  static_assert(sizeof(hash) == HASH_SIZE, "Invalid structure size");
  static_assert(sizeof(hash8) == 8, "Invalid structure size");
  static_assert(sizeof(hash64) == 64, "Invalid structure size");
 
  /*
    Cryptonight hash functions
  */
 
  inline void cn_fast_hash(const void *data, std::size_t length, hash &hash) {
    cn_fast_hash(data, length, reinterpret_cast<char *>(&hash));
  }
 
  inline hash cn_fast_hash(const void *data, std::size_t length) {
    hash h;
    cn_fast_hash(data, length, reinterpret_cast<char *>(&h));
    return h;
  }
 
  inline void cn_slow_hash(const void *data, std::size_t length, hash &hash, int variant = 0, uint64_t height = 0) {
    cn_slow_hash(data, length, reinterpret_cast<char *>(&hash), variant, 0/*prehashed*/, height);
  }
 
  inline void cn_slow_hash_prehashed(const void *data, std::size_t length, hash &hash, int variant = 0, uint64_t height = 0) {
    cn_slow_hash(data, length, reinterpret_cast<char *>(&hash), variant, 1/*prehashed*/, height);
  }
 
  inline void tree_hash(const hash *hashes, std::size_t count, hash &root_hash) {
    tree_hash(reinterpret_cast<const char (*)[HASH_SIZE]>(hashes), count, reinterpret_cast<char *>(&root_hash));
  }
 
  inline std::ostream &operator <<(std::ostream &o, const crypto::hash &v) {
    epee::to_hex::formatted(o, epee::as_byte_span(v)); return o;
  }
  inline std::ostream &operator <<(std::ostream &o, const crypto::hash8 &v) {
    epee::to_hex::formatted(o, epee::as_byte_span(v)); return o;
  }
  inline std::ostream &operator <<(std::ostream &o, const crypto::hash64 &v) {
    epee::to_hex::formatted(o, epee::as_byte_span(v)); return o;
  }
 
  const static crypto::hash null_hash = boost::value_initialized<crypto::hash>();
  const static crypto::hash8 null_hash8 = boost::value_initialized<crypto::hash8>();
  const static crypto::hash64 null_hash64 = boost::value_initialized<crypto::hash64>();
}
 
CRYPTO_MAKE_HASHABLE(hash)
CRYPTO_MAKE_COMPARABLE(hash8)
CRYPTO_MAKE_COMPARABLE(hash64)

◆ VARINT_FIELD

#define VARINT_FIELD ( f )

Value:

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

tags and serializes the varint f

\macro VARINT_FIELD(f)

Definition at line 264 of file hash.h.

// Copyrights(c) 2017-2021, The Electroneum Project
// Copyrights(c) 2014-2019, The Monero Project
// 
// All rights reserved.
// 
// Redistribution and use in source and binary forms, with or without modification, are
// permitted provided that the following conditions are met:
// 
// 1. Redistributions of source code must retain the above copyright notice, this list of
//    conditions and the following disclaimer.
// 
// 2. Redistributions in binary form must reproduce the above copyright notice, this list
//    of conditions and the following disclaimer in the documentation and/or other
//    materials provided with the distribution.
// 
// 3. Neither the name of the copyright holder nor the names of its contributors may be
//    used to endorse or promote products derived from this software without specific
//    prior written permission.
// 
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY
// EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
// MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL
// THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
// PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
// INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
// STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF
// THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
// 
// Parts of this file are originally copyright (c) 2012-2013 The Cryptonote developers
 
#pragma once
 
#include <stddef.h>
#include <iostream>
#include <boost/utility/value_init.hpp>
 
#include "common/pod-class.h"
#include "generic-ops.h"
#include "hex.h"
#include "span.h"
 
namespace crypto {
 
  extern "C" {
#include "hash-ops.h"
  }
 
#pragma pack(push, 1)
  POD_CLASS hash {
    char data[HASH_SIZE];
  };
  POD_CLASS hash8 {
    char data[8];
  };
  POD_CLASS hash64 {
    char data[64];
  };
#pragma pack(pop)
 
  static_assert(sizeof(hash) == HASH_SIZE, "Invalid structure size");
  static_assert(sizeof(hash8) == 8, "Invalid structure size");
  static_assert(sizeof(hash64) == 64, "Invalid structure size");
 
  /*
    Cryptonight hash functions
  */
 
  inline void cn_fast_hash(const void *data, std::size_t length, hash &hash) {
    cn_fast_hash(data, length, reinterpret_cast<char *>(&hash));
  }
 
  inline hash cn_fast_hash(const void *data, std::size_t length) {
    hash h;
    cn_fast_hash(data, length, reinterpret_cast<char *>(&h));
    return h;
  }
 
  inline void cn_slow_hash(const void *data, std::size_t length, hash &hash, int variant = 0, uint64_t height = 0) {
    cn_slow_hash(data, length, reinterpret_cast<char *>(&hash), variant, 0/*prehashed*/, height);
  }
 
  inline void cn_slow_hash_prehashed(const void *data, std::size_t length, hash &hash, int variant = 0, uint64_t height = 0) {
    cn_slow_hash(data, length, reinterpret_cast<char *>(&hash), variant, 1/*prehashed*/, height);
  }
 
  inline void tree_hash(const hash *hashes, std::size_t count, hash &root_hash) {
    tree_hash(reinterpret_cast<const char (*)[HASH_SIZE]>(hashes), count, reinterpret_cast<char *>(&root_hash));
  }
 
  inline std::ostream &operator <<(std::ostream &o, const crypto::hash &v) {
    epee::to_hex::formatted(o, epee::as_byte_span(v)); return o;
  }
  inline std::ostream &operator <<(std::ostream &o, const crypto::hash8 &v) {
    epee::to_hex::formatted(o, epee::as_byte_span(v)); return o;
  }
  inline std::ostream &operator <<(std::ostream &o, const crypto::hash64 &v) {
    epee::to_hex::formatted(o, epee::as_byte_span(v)); return o;
  }
 
  const static crypto::hash null_hash = boost::value_initialized<crypto::hash>();
  const static crypto::hash8 null_hash8 = boost::value_initialized<crypto::hash8>();
  const static crypto::hash64 null_hash64 = boost::value_initialized<crypto::hash64>();
}
 
CRYPTO_MAKE_HASHABLE(hash)
CRYPTO_MAKE_COMPARABLE(hash8)
CRYPTO_MAKE_COMPARABLE(hash64)

◆ VARINT_FIELD_N

#define VARINT_FIELD_N	(		t,
			f )

Value:

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

tags (as t) and serializes the varint f

\macro VARINT_FIELD_N(t, f)

Definition at line 275 of file hash.h.

// Copyrights(c) 2017-2021, The Electroneum Project
// Copyrights(c) 2014-2019, The Monero Project
// 
// All rights reserved.
// 
// Redistribution and use in source and binary forms, with or without modification, are
// permitted provided that the following conditions are met:
// 
// 1. Redistributions of source code must retain the above copyright notice, this list of
//    conditions and the following disclaimer.
// 
// 2. Redistributions in binary form must reproduce the above copyright notice, this list
//    of conditions and the following disclaimer in the documentation and/or other
//    materials provided with the distribution.
// 
// 3. Neither the name of the copyright holder nor the names of its contributors may be
//    used to endorse or promote products derived from this software without specific
//    prior written permission.
// 
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY
// EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
// MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL
// THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
// PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
// INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
// STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF
// THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
// 
// Parts of this file are originally copyright (c) 2012-2013 The Cryptonote developers
 
#pragma once
 
#include <stddef.h>
#include <iostream>
#include <boost/utility/value_init.hpp>
 
#include "common/pod-class.h"
#include "generic-ops.h"
#include "hex.h"
#include "span.h"
 
namespace crypto {
 
  extern "C" {
#include "hash-ops.h"
  }
 
#pragma pack(push, 1)
  POD_CLASS hash {
    char data[HASH_SIZE];
  };
  POD_CLASS hash8 {
    char data[8];
  };
  POD_CLASS hash64 {
    char data[64];
  };
#pragma pack(pop)
 
  static_assert(sizeof(hash) == HASH_SIZE, "Invalid structure size");
  static_assert(sizeof(hash8) == 8, "Invalid structure size");
  static_assert(sizeof(hash64) == 64, "Invalid structure size");
 
  /*
    Cryptonight hash functions
  */
 
  inline void cn_fast_hash(const void *data, std::size_t length, hash &hash) {
    cn_fast_hash(data, length, reinterpret_cast<char *>(&hash));
  }
 
  inline hash cn_fast_hash(const void *data, std::size_t length) {
    hash h;
    cn_fast_hash(data, length, reinterpret_cast<char *>(&h));
    return h;
  }
 
  inline void cn_slow_hash(const void *data, std::size_t length, hash &hash, int variant = 0, uint64_t height = 0) {
    cn_slow_hash(data, length, reinterpret_cast<char *>(&hash), variant, 0/*prehashed*/, height);
  }
 
  inline void cn_slow_hash_prehashed(const void *data, std::size_t length, hash &hash, int variant = 0, uint64_t height = 0) {
    cn_slow_hash(data, length, reinterpret_cast<char *>(&hash), variant, 1/*prehashed*/, height);
  }
 
  inline void tree_hash(const hash *hashes, std::size_t count, hash &root_hash) {
    tree_hash(reinterpret_cast<const char (*)[HASH_SIZE]>(hashes), count, reinterpret_cast<char *>(&root_hash));
  }
 
  inline std::ostream &operator <<(std::ostream &o, const crypto::hash &v) {
    epee::to_hex::formatted(o, epee::as_byte_span(v)); return o;
  }
  inline std::ostream &operator <<(std::ostream &o, const crypto::hash8 &v) {
    epee::to_hex::formatted(o, epee::as_byte_span(v)); return o;
  }
  inline std::ostream &operator <<(std::ostream &o, const crypto::hash64 &v) {
    epee::to_hex::formatted(o, epee::as_byte_span(v)); return o;
  }
 
  const static crypto::hash null_hash = boost::value_initialized<crypto::hash>();
  const static crypto::hash8 null_hash8 = boost::value_initialized<crypto::hash8>();
  const static crypto::hash64 null_hash64 = boost::value_initialized<crypto::hash64>();
}
 
CRYPTO_MAKE_HASHABLE(hash)
CRYPTO_MAKE_COMPARABLE(hash8)
CRYPTO_MAKE_COMPARABLE(hash64)

Function Documentation

◆ do_serialize() [1/2]

template<class Archive>

bool do_serialize	(	Archive &	ar,
		bool &	v )

inline

Definition at line 128 of file serialization.h.

{
  ar.serialize_blob(&v, sizeof(v));
  return true;
}

◆ do_serialize() [2/2]

template<class Archive, class T>

bool do_serialize	(	Archive &	ar,
		T &	v )

inline

just calls the serialize function defined for ar and v...

Definition at line 123 of file serialization.h.

{
  return ::serializer<Archive, T>::serialize(ar, v);
}

Here is the caller graph for this function:

Classes

Namespaces

Macros

Functions

Detailed Description

Macro Definition Documentation

◆ BEGIN_SERIALIZE

◆ BEGIN_SERIALIZE_OBJECT

◆ BLOB_SERIALIZER

◆ END_SERIALIZE

◆ FIELD

◆ FIELD_N

◆ FIELDS

◆ FREE_SERIALIZER

◆ PREPARE_CUSTOM_DEQUE_SERIALIZATION

◆ PREPARE_CUSTOM_VECTOR_SERIALIZATION

◆ VALUE

◆ VARIANT_TAG

◆ VARINT_FIELD

◆ VARINT_FIELD_N

Function Documentation

◆ do_serialize() [1/2]

◆ do_serialize() [2/2]