Electroneum
Loading...
Searching...
No Matches
crypto::serialization::detail Namespace Reference

Functions

template<typename T>
void prepare_custom_vector_serialization (size_t size, std::vector< T > &vec, const boost::mpl::bool_< true > &)
template<typename T>
void prepare_custom_vector_serialization (size_t size, std::vector< T > &vec, const boost::mpl::bool_< false > &)
template<typename T>
void prepare_custom_deque_serialization (size_t size, std::deque< T > &vec, const boost::mpl::bool_< true > &)
template<typename T>
void prepare_custom_deque_serialization (size_t size, std::deque< T > &vec, const boost::mpl::bool_< false > &)
template<class Stream>
bool do_check_stream_state (Stream &s, boost::mpl::bool_< true >, bool noeof)
template<class Stream>
bool do_check_stream_state (Stream &s, boost::mpl::bool_< false >, bool noeof)

Function Documentation

◆ do_check_stream_state() [1/2]

template<class Stream>
bool crypto::serialization::detail::do_check_stream_state ( Stream & s,
boost::mpl::bool_< false > ,
bool noeof )

Definition at line 333 of file hash.h.

375 {
376
377 extern "C" {
378#include "hash-ops.h"
379 }
380
381#pragma pack(push, 1)
382 POD_CLASS hash {
383 char data[HASH_SIZE];
384 };
385 POD_CLASS hash8 {
386 char data[8];
387 };
388 POD_CLASS hash64 {
389 char data[64];
390 };
391#pragma pack(pop)
392
393 static_assert(sizeof(hash) == HASH_SIZE, "Invalid structure size");
394 static_assert(sizeof(hash8) == 8, "Invalid structure size");
395 static_assert(sizeof(hash64) == 64, "Invalid structure size");
396
397 /*
398 Cryptonight hash functions
399 */
400
401 inline void cn_fast_hash(const void *data, std::size_t length, hash &hash) {
402 cn_fast_hash(data, length, reinterpret_cast<char *>(&hash));
403 }
404
405 inline hash cn_fast_hash(const void *data, std::size_t length) {
406 hash h;
407 cn_fast_hash(data, length, reinterpret_cast<char *>(&h));
408 return h;
409 }
410
411 inline void cn_slow_hash(const void *data, std::size_t length, hash &hash, int variant = 0, uint64_t height = 0) {
412 cn_slow_hash(data, length, reinterpret_cast<char *>(&hash), variant, 0/*prehashed*/, height);
413 }
414
415 inline void cn_slow_hash_prehashed(const void *data, std::size_t length, hash &hash, int variant = 0, uint64_t height = 0) {
416 cn_slow_hash(data, length, reinterpret_cast<char *>(&hash), variant, 1/*prehashed*/, height);
417 }
418
419 inline void tree_hash(const hash *hashes, std::size_t count, hash &root_hash) {
420 tree_hash(reinterpret_cast<const char (*)[HASH_SIZE]>(hashes), count, reinterpret_cast<char *>(&root_hash));
421 }
422
423 inline std::ostream &operator <<(std::ostream &o, const crypto::hash &v) {
424 epee::to_hex::formatted(o, epee::as_byte_span(v)); return o;
425 }
426 inline std::ostream &operator <<(std::ostream &o, const crypto::hash8 &v) {
427 epee::to_hex::formatted(o, epee::as_byte_span(v)); return o;
428 }
429 inline std::ostream &operator <<(std::ostream &o, const crypto::hash64 &v) {
430 epee::to_hex::formatted(o, epee::as_byte_span(v)); return o;
431 }
432
433 const static crypto::hash null_hash = boost::value_initialized<crypto::hash>();
434 const static crypto::hash8 null_hash8 = boost::value_initialized<crypto::hash8>();
435 const static crypto::hash64 null_hash64 = boost::value_initialized<crypto::hash64>();
436}
437
438CRYPTO_MAKE_HASHABLE(hash)
439CRYPTO_MAKE_COMPARABLE(hash8)
440CRYPTO_MAKE_COMPARABLE(hash64)
height
uint64_t height
Definition blockchain.cpp:91
CRYPTO_MAKE_COMPARABLE
#define CRYPTO_MAKE_COMPARABLE(type)
Definition generic-ops.h:39
CRYPTO_MAKE_HASHABLE
#define CRYPTO_MAKE_HASHABLE(type)
Definition generic-ops.h:76
crypto::cn_slow_hash_prehashed
void cn_slow_hash_prehashed(const void *data, std::size_t length, hash &hash, int variant=0, uint64_t height=0)
Definition hash.h:83
crypto::cn_fast_hash
void cn_fast_hash(const void *data, size_t length, char *hash)
crypto::hash8
POD_CLASS hash8
Definition hash.h:53
crypto::cn_slow_hash
void cn_slow_hash(const void *data, size_t length, char *hash, int variant, int prehashed, uint64_t height)
crypto::uint64_t
unsigned __int64 uint64_t
Definition hash.h:137
crypto::tree_hash
void tree_hash(const char(*hashes)[HASH_SIZE], size_t count, char *root_hash)
crypto::operator<<
std::ostream & operator<<(std::ostream &o, const crypto::public_key &v)
Definition crypto.h:357
crypto::hash64
POD_CLASS hash64
Definition hash.h:56
crypto::hash
POD_CLASS hash
Definition hash.h:50
crypto::HASH_SIZE
@ HASH_SIZE
Definition hash.h:78
epee::as_byte_span
span< const std::uint8_t > as_byte_span(const T &src) noexcept
Definition span.h:153
POD_CLASS
#define POD_CLASS
Definition pod-class.h:44
epee::to_hex::formatted
static void formatted(std::ostream &out, const span< const std::uint8_t > src)
Append < + src + > as hex to out.
Definition hex.cpp:76
hashes
struct hash_func hashes[]

◆ do_check_stream_state() [2/2]

template<class Stream>
bool crypto::serialization::detail::do_check_stream_state ( Stream & s,
boost::mpl::bool_< true > ,
bool noeof )

Definition at line 322 of file hash.h.

364 {
365
366 extern "C" {
367#include "hash-ops.h"
368 }
369
370#pragma pack(push, 1)
371 POD_CLASS hash {
372 char data[HASH_SIZE];
373 };
374 POD_CLASS hash8 {
375 char data[8];
376 };
377 POD_CLASS hash64 {
378 char data[64];
379 };
380#pragma pack(pop)
381
382 static_assert(sizeof(hash) == HASH_SIZE, "Invalid structure size");
383 static_assert(sizeof(hash8) == 8, "Invalid structure size");
384 static_assert(sizeof(hash64) == 64, "Invalid structure size");
385
386 /*
387 Cryptonight hash functions
388 */
389
390 inline void cn_fast_hash(const void *data, std::size_t length, hash &hash) {
391 cn_fast_hash(data, length, reinterpret_cast<char *>(&hash));
392 }
393
394 inline hash cn_fast_hash(const void *data, std::size_t length) {
395 hash h;
396 cn_fast_hash(data, length, reinterpret_cast<char *>(&h));
397 return h;
398 }
399
400 inline void cn_slow_hash(const void *data, std::size_t length, hash &hash, int variant = 0, uint64_t height = 0) {
401 cn_slow_hash(data, length, reinterpret_cast<char *>(&hash), variant, 0/*prehashed*/, height);
402 }
403
404 inline void cn_slow_hash_prehashed(const void *data, std::size_t length, hash &hash, int variant = 0, uint64_t height = 0) {
405 cn_slow_hash(data, length, reinterpret_cast<char *>(&hash), variant, 1/*prehashed*/, height);
406 }
407
408 inline void tree_hash(const hash *hashes, std::size_t count, hash &root_hash) {
409 tree_hash(reinterpret_cast<const char (*)[HASH_SIZE]>(hashes), count, reinterpret_cast<char *>(&root_hash));
410 }
411
412 inline std::ostream &operator <<(std::ostream &o, const crypto::hash &v) {
413 epee::to_hex::formatted(o, epee::as_byte_span(v)); return o;
414 }
415 inline std::ostream &operator <<(std::ostream &o, const crypto::hash8 &v) {
416 epee::to_hex::formatted(o, epee::as_byte_span(v)); return o;
417 }
418 inline std::ostream &operator <<(std::ostream &o, const crypto::hash64 &v) {
419 epee::to_hex::formatted(o, epee::as_byte_span(v)); return o;
420 }
421
422 const static crypto::hash null_hash = boost::value_initialized<crypto::hash>();
423 const static crypto::hash8 null_hash8 = boost::value_initialized<crypto::hash8>();
424 const static crypto::hash64 null_hash64 = boost::value_initialized<crypto::hash64>();
425}
426
427CRYPTO_MAKE_HASHABLE(hash)
428CRYPTO_MAKE_COMPARABLE(hash8)
429CRYPTO_MAKE_COMPARABLE(hash64)

◆ prepare_custom_deque_serialization() [1/2]

template<typename T>
void crypto::serialization::detail::prepare_custom_deque_serialization ( size_t size,
std::deque< T > & vec,
const boost::mpl::bool_< false > &  )

Definition at line 312 of file hash.h.

354 {
355
356 extern "C" {
357#include "hash-ops.h"
358 }
359
360#pragma pack(push, 1)
361 POD_CLASS hash {
362 char data[HASH_SIZE];
363 };
364 POD_CLASS hash8 {
365 char data[8];
366 };
367 POD_CLASS hash64 {
368 char data[64];
369 };
370#pragma pack(pop)
371
372 static_assert(sizeof(hash) == HASH_SIZE, "Invalid structure size");
373 static_assert(sizeof(hash8) == 8, "Invalid structure size");
374 static_assert(sizeof(hash64) == 64, "Invalid structure size");
375
376 /*
377 Cryptonight hash functions
378 */
379
380 inline void cn_fast_hash(const void *data, std::size_t length, hash &hash) {
381 cn_fast_hash(data, length, reinterpret_cast<char *>(&hash));
382 }
383
384 inline hash cn_fast_hash(const void *data, std::size_t length) {
385 hash h;
386 cn_fast_hash(data, length, reinterpret_cast<char *>(&h));
387 return h;
388 }
389
390 inline void cn_slow_hash(const void *data, std::size_t length, hash &hash, int variant = 0, uint64_t height = 0) {
391 cn_slow_hash(data, length, reinterpret_cast<char *>(&hash), variant, 0/*prehashed*/, height);
392 }
393
394 inline void cn_slow_hash_prehashed(const void *data, std::size_t length, hash &hash, int variant = 0, uint64_t height = 0) {
395 cn_slow_hash(data, length, reinterpret_cast<char *>(&hash), variant, 1/*prehashed*/, height);
396 }
397
398 inline void tree_hash(const hash *hashes, std::size_t count, hash &root_hash) {
399 tree_hash(reinterpret_cast<const char (*)[HASH_SIZE]>(hashes), count, reinterpret_cast<char *>(&root_hash));
400 }
401
402 inline std::ostream &operator <<(std::ostream &o, const crypto::hash &v) {
403 epee::to_hex::formatted(o, epee::as_byte_span(v)); return o;
404 }
405 inline std::ostream &operator <<(std::ostream &o, const crypto::hash8 &v) {
406 epee::to_hex::formatted(o, epee::as_byte_span(v)); return o;
407 }
408 inline std::ostream &operator <<(std::ostream &o, const crypto::hash64 &v) {
409 epee::to_hex::formatted(o, epee::as_byte_span(v)); return o;
410 }
411
412 const static crypto::hash null_hash = boost::value_initialized<crypto::hash>();
413 const static crypto::hash8 null_hash8 = boost::value_initialized<crypto::hash8>();
414 const static crypto::hash64 null_hash64 = boost::value_initialized<crypto::hash64>();
415}
416
417CRYPTO_MAKE_HASHABLE(hash)
418CRYPTO_MAKE_COMPARABLE(hash8)
419CRYPTO_MAKE_COMPARABLE(hash64)

◆ prepare_custom_deque_serialization() [2/2]

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

Definition at line 307 of file hash.h.

349 {
350
351 extern "C" {
352#include "hash-ops.h"
353 }
354
355#pragma pack(push, 1)
356 POD_CLASS hash {
357 char data[HASH_SIZE];
358 };
359 POD_CLASS hash8 {
360 char data[8];
361 };
362 POD_CLASS hash64 {
363 char data[64];
364 };
365#pragma pack(pop)
366
367 static_assert(sizeof(hash) == HASH_SIZE, "Invalid structure size");
368 static_assert(sizeof(hash8) == 8, "Invalid structure size");
369 static_assert(sizeof(hash64) == 64, "Invalid structure size");
370
371 /*
372 Cryptonight hash functions
373 */
374
375 inline void cn_fast_hash(const void *data, std::size_t length, hash &hash) {
376 cn_fast_hash(data, length, reinterpret_cast<char *>(&hash));
377 }
378
379 inline hash cn_fast_hash(const void *data, std::size_t length) {
380 hash h;
381 cn_fast_hash(data, length, reinterpret_cast<char *>(&h));
382 return h;
383 }
384
385 inline void cn_slow_hash(const void *data, std::size_t length, hash &hash, int variant = 0, uint64_t height = 0) {
386 cn_slow_hash(data, length, reinterpret_cast<char *>(&hash), variant, 0/*prehashed*/, height);
387 }
388
389 inline void cn_slow_hash_prehashed(const void *data, std::size_t length, hash &hash, int variant = 0, uint64_t height = 0) {
390 cn_slow_hash(data, length, reinterpret_cast<char *>(&hash), variant, 1/*prehashed*/, height);
391 }
392
393 inline void tree_hash(const hash *hashes, std::size_t count, hash &root_hash) {
394 tree_hash(reinterpret_cast<const char (*)[HASH_SIZE]>(hashes), count, reinterpret_cast<char *>(&root_hash));
395 }
396
397 inline std::ostream &operator <<(std::ostream &o, const crypto::hash &v) {
398 epee::to_hex::formatted(o, epee::as_byte_span(v)); return o;
399 }
400 inline std::ostream &operator <<(std::ostream &o, const crypto::hash8 &v) {
401 epee::to_hex::formatted(o, epee::as_byte_span(v)); return o;
402 }
403 inline std::ostream &operator <<(std::ostream &o, const crypto::hash64 &v) {
404 epee::to_hex::formatted(o, epee::as_byte_span(v)); return o;
405 }
406
407 const static crypto::hash null_hash = boost::value_initialized<crypto::hash>();
408 const static crypto::hash8 null_hash8 = boost::value_initialized<crypto::hash8>();
409 const static crypto::hash64 null_hash64 = boost::value_initialized<crypto::hash64>();
410}
411
412CRYPTO_MAKE_HASHABLE(hash)
413CRYPTO_MAKE_COMPARABLE(hash8)
414CRYPTO_MAKE_COMPARABLE(hash64)

◆ prepare_custom_vector_serialization() [1/2]

template<typename T>
void crypto::serialization::detail::prepare_custom_vector_serialization ( size_t size,
std::vector< T > & vec,
const boost::mpl::bool_< false > &  )

Definition at line 301 of file hash.h.

343 {
344
345 extern "C" {
346#include "hash-ops.h"
347 }
348
349#pragma pack(push, 1)
350 POD_CLASS hash {
351 char data[HASH_SIZE];
352 };
353 POD_CLASS hash8 {
354 char data[8];
355 };
356 POD_CLASS hash64 {
357 char data[64];
358 };
359#pragma pack(pop)
360
361 static_assert(sizeof(hash) == HASH_SIZE, "Invalid structure size");
362 static_assert(sizeof(hash8) == 8, "Invalid structure size");
363 static_assert(sizeof(hash64) == 64, "Invalid structure size");
364
365 /*
366 Cryptonight hash functions
367 */
368
369 inline void cn_fast_hash(const void *data, std::size_t length, hash &hash) {
370 cn_fast_hash(data, length, reinterpret_cast<char *>(&hash));
371 }
372
373 inline hash cn_fast_hash(const void *data, std::size_t length) {
374 hash h;
375 cn_fast_hash(data, length, reinterpret_cast<char *>(&h));
376 return h;
377 }
378
379 inline void cn_slow_hash(const void *data, std::size_t length, hash &hash, int variant = 0, uint64_t height = 0) {
380 cn_slow_hash(data, length, reinterpret_cast<char *>(&hash), variant, 0/*prehashed*/, height);
381 }
382
383 inline void cn_slow_hash_prehashed(const void *data, std::size_t length, hash &hash, int variant = 0, uint64_t height = 0) {
384 cn_slow_hash(data, length, reinterpret_cast<char *>(&hash), variant, 1/*prehashed*/, height);
385 }
386
387 inline void tree_hash(const hash *hashes, std::size_t count, hash &root_hash) {
388 tree_hash(reinterpret_cast<const char (*)[HASH_SIZE]>(hashes), count, reinterpret_cast<char *>(&root_hash));
389 }
390
391 inline std::ostream &operator <<(std::ostream &o, const crypto::hash &v) {
392 epee::to_hex::formatted(o, epee::as_byte_span(v)); return o;
393 }
394 inline std::ostream &operator <<(std::ostream &o, const crypto::hash8 &v) {
395 epee::to_hex::formatted(o, epee::as_byte_span(v)); return o;
396 }
397 inline std::ostream &operator <<(std::ostream &o, const crypto::hash64 &v) {
398 epee::to_hex::formatted(o, epee::as_byte_span(v)); return o;
399 }
400
401 const static crypto::hash null_hash = boost::value_initialized<crypto::hash>();
402 const static crypto::hash8 null_hash8 = boost::value_initialized<crypto::hash8>();
403 const static crypto::hash64 null_hash64 = boost::value_initialized<crypto::hash64>();
404}
405
406CRYPTO_MAKE_HASHABLE(hash)
407CRYPTO_MAKE_COMPARABLE(hash8)
408CRYPTO_MAKE_COMPARABLE(hash64)

◆ prepare_custom_vector_serialization() [2/2]

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

Definition at line 296 of file hash.h.

338 {
339
340 extern "C" {
341#include "hash-ops.h"
342 }
343
344#pragma pack(push, 1)
345 POD_CLASS hash {
346 char data[HASH_SIZE];
347 };
348 POD_CLASS hash8 {
349 char data[8];
350 };
351 POD_CLASS hash64 {
352 char data[64];
353 };
354#pragma pack(pop)
355
356 static_assert(sizeof(hash) == HASH_SIZE, "Invalid structure size");
357 static_assert(sizeof(hash8) == 8, "Invalid structure size");
358 static_assert(sizeof(hash64) == 64, "Invalid structure size");
359
360 /*
361 Cryptonight hash functions
362 */
363
364 inline void cn_fast_hash(const void *data, std::size_t length, hash &hash) {
365 cn_fast_hash(data, length, reinterpret_cast<char *>(&hash));
366 }
367
368 inline hash cn_fast_hash(const void *data, std::size_t length) {
369 hash h;
370 cn_fast_hash(data, length, reinterpret_cast<char *>(&h));
371 return h;
372 }
373
374 inline void cn_slow_hash(const void *data, std::size_t length, hash &hash, int variant = 0, uint64_t height = 0) {
375 cn_slow_hash(data, length, reinterpret_cast<char *>(&hash), variant, 0/*prehashed*/, height);
376 }
377
378 inline void cn_slow_hash_prehashed(const void *data, std::size_t length, hash &hash, int variant = 0, uint64_t height = 0) {
379 cn_slow_hash(data, length, reinterpret_cast<char *>(&hash), variant, 1/*prehashed*/, height);
380 }
381
382 inline void tree_hash(const hash *hashes, std::size_t count, hash &root_hash) {
383 tree_hash(reinterpret_cast<const char (*)[HASH_SIZE]>(hashes), count, reinterpret_cast<char *>(&root_hash));
384 }
385
386 inline std::ostream &operator <<(std::ostream &o, const crypto::hash &v) {
387 epee::to_hex::formatted(o, epee::as_byte_span(v)); return o;
388 }
389 inline std::ostream &operator <<(std::ostream &o, const crypto::hash8 &v) {
390 epee::to_hex::formatted(o, epee::as_byte_span(v)); return o;
391 }
392 inline std::ostream &operator <<(std::ostream &o, const crypto::hash64 &v) {
393 epee::to_hex::formatted(o, epee::as_byte_span(v)); return o;
394 }
395
396 const static crypto::hash null_hash = boost::value_initialized<crypto::hash>();
397 const static crypto::hash8 null_hash8 = boost::value_initialized<crypto::hash8>();
398 const static crypto::hash64 null_hash64 = boost::value_initialized<crypto::hash64>();
399}
400
401CRYPTO_MAKE_HASHABLE(hash)
402CRYPTO_MAKE_COMPARABLE(hash8)
403CRYPTO_MAKE_COMPARABLE(hash64)