fc Namespace Reference

namespace sysio::chain More...

Namespaces
namespace	crypto
namespace	detail
namespace	ecc
namespace	em
namespace	equihash
namespace	ip
namespace	json_relaxed
namespace	persistence_util
namespace	raw
namespace	rpc
namespace	tracked

Classes
class	actor
class	aes_decoder
class	aes_encoder
struct	aligned
class	api
class	api_base
class	api_connection
class	appender
struct	appender_config
class	appender_factory
class	array
class	array< char, N >
class	array< unsigned char, N >
class	bigint
class	binary_api_connection
struct	blake2b_state
class	blake2b_wrapper
struct	blob
class	bloom_filter
class	bloom_parameters
class	blowfish
class	buffered_istream
	Reads data from an unbuffered stream and enables peek functionality. More...
class	buffered_ostream
class	cfile
class	cfile_datastream
class	comma_numpunct
class	console_appender
class	datastream
class	datastream< Container, typename std::enable_if_t<(std::is_same_v< std::vector< char >, Container >||std::is_same_v< std::deque< char >, Container >)> >
class	datastream< fc::cfile, void >
class	datastream< size_t, void >
class	datastream< Streambuf, typename std::enable_if_t< std::is_base_of_v< std::streambuf, Streambuf > > >
class	datastream< T, std::enable_if_t< std::is_same_v< T, char * >||std::is_same_v< T, const char * >||std::is_same_v< T, const unsigned char * > > >
struct	deduce
struct	deduce< const T & >
struct	deduce< const T && >
struct	deduce< T & >
struct	deduce< T && >
struct	device_adaptor
struct	diffie_hellman
class	directory_iterator
class	dmlog_appender
class	enum_type
class	exception
	Used to generate a useful error report when an exception is thrown. More...
class	exception_factory
struct	false_type
class	file_mapping
class	fixed_string
struct	from_static_variant
class	from_variant_visitor
class	fwd
	Used to forward declare value types. More...
class	gelf_appender
class	generic_api
struct	get_typename
struct	get_typename< __int128 >
struct	get_typename< bool >
struct	get_typename< char >
struct	get_typename< double >
struct	get_typename< fc::array< T, N > >
struct	get_typename< fc::exception >
struct	get_typename< flat_set< T > >
struct	get_typename< float >
struct	get_typename< int16_t >
struct	get_typename< int32_t >
struct	get_typename< int64_t >
struct	get_typename< int8_t >
struct	get_typename< path >
struct	get_typename< signed_int >
struct	get_typename< std::deque< T > >
struct	get_typename< std::map< K, V > >
struct	get_typename< std::optional< T > >
struct	get_typename< std::vector< char > >
struct	get_typename< std::vector< T > >
struct	get_typename< string >
struct	get_typename< uint160_t >
struct	get_typename< uint16_t >
struct	get_typename< uint32_t >
struct	get_typename< uint64_t >
struct	get_typename< uint8_t >
struct	get_typename< unsigned __int128 >
struct	get_typename< unsigned_int >
struct	get_typename< value >
struct	get_typename< void >
struct	has_reflector_init
class	hmac
class	http_client
class	http_client_impl
struct	identity_member
struct	if_enum
struct	if_enum< fc::true_type >
class	iobuffer
class	iprocess
	abstract interface for interacting with external processes More...
struct	is_class
struct	is_tuple
class	json
class	local_api_connection
class	local_binary_api_connection
struct	log_config
class	log_context
	provides information about where and when a log message was generated. More...
class	log_level
class	log_message
	aggregates a message along with the context and associated meta-information. More...
class	logger
struct	logger_config
struct	logging_config
class	mapped_region
class	mb_datastream
class	mb_peek_datastream
class	message_buffer
	abstraction for a message buffer that spans a chain of physical buffers More...
class	microseconds
class	mmap_struct
	A struct that has been mapped from a file. More...
class	mock_time_traits
	mock out fc::time_point::now() and provide a mock deadline timer More...
class	mutable_variant_object
	An order-preserving dictionary of variants. More...
class	noncopyable
class	optional_delegate
class	optional_delegate< R(Args...)>
struct	optional_trace
struct	overloaded
class	path
	wraps boost::filesystem::path to provide platform independent path manipulation. More...
class	private_key
class	process
	start and manage an local process More...
class	public_key
class	real128
class	recursive_directory_iterator
struct	reflect_init
struct	reflector
	defines visit functions for T Unless this is specialized, visit() will not be defined for T. More...
struct	reflector_init_visitor
struct	remove_reference
struct	remove_reference< T & >
struct	remove_reference< T && >
class	ripemd160
struct	safe
struct	sblock
class	scoped_exit
class	sha1
class	sha224
class	sha256
class	sha3
struct	sha3_impl
class	sha512
struct	signed_int
	serializes a 32 bit signed interger in as few bytes as possible More...
class	simple_lock_file
class	size_stream
struct	ssl_bignum
struct	ssl_wrapper
class	std_exception_wrapper
	wrapper for std::exception More...
class	temp_directory
class	temp_file
class	temp_file_base
class	time_point
class	time_point_sec
struct	to_static_variant
class	to_variant_visitor
class	tracked_storage
	tracks the size of storage allocated to its underlying multi_index More...
struct	true_type
struct	tuple
struct	tuple<>
class	udp_socket
class	udt_epoll_service
class	uint128
	an implementation of 128 bit unsigned integer More...
class	unhandled_exception
	re-thrown whenever an unhandled exception is caught.Any exceptions thrown by 3rd party libraries that are not caught get wrapped in an unhandled_exception exception. More...
class	unique_ptr
struct	unsigned_int
class	url
class	variant
	stores null, int64, uint64, double, bool, string, std::vector<variant>, and variant_object's. More...
class	variant_object
	An order-preserving dictionary of variants. More...
class	variant_stream
class	vector
struct	visitor
struct	vtable
struct	vtable_copy_visitor
class	zipkin
class	zipkin_config
struct	zipkin_span
struct	zipkin_trace

Typedefs
typedef boost::any	any
typedef uint32_t	api_id_type
typedef std::shared_ptr< api_base >	api_ptr
using	bytes = std::vector<char>
typedef hmac< fc::sha224 >	hmac_sha224
typedef hmac< fc::sha256 >	hmac_sha256
typedef hmac< fc::sha512 >	hmac_sha512
typedef bytes	signature
typedef ripemd160	uint160_t
typedef ripemd160	uint160
typedef sha256	uint256
typedef fc::sha512	uint512
typedef std::shared_ptr< exception >	exception_ptr
typedef std::optional< exception >	oexception
typedef std::shared_ptr< iprocess >	iprocess_ptr
typedef std::shared_ptr< process >	process_ptr
typedef std::shared_ptr< buffered_istream >	buffered_istream_ptr
typedef std::shared_ptr< buffered_ostream >	buffered_ostream_ptr
typedef std::vector< log_message >	log_messages
typedef boost::asio::basic_deadline_timer< boost::posix_time::ptime, mock_time_traits >	mock_deadline_timer
typedef std::optional< fc::string >	ostring
typedef std::optional< fc::path >	opath
typedef std::optional< fc::variant_object >	ovariant_object
typedef std::string	string
typedef std::optional< time_point >	otime_point
typedef decltype(nullptr)	nullptr_t
using	yield_function_t = optional_delegate<void()>
template<size_t Size>
using	UInt
template<size_t Size>
using	Int
typedef std::vector< fc::variant >	variants
typedef std::optional< variant >	ovariant
typedef const char *	const_char_ptr
using	Scalar = libff::bigint<libff::alt_bn128_q_limbs>
typedef boost::multiprecision::uint128_t	m128
typedef const variant_object *	const_variant_object_ptr
typedef const variants *	const_variants_ptr
typedef const blob *	const_blob_ptr
typedef const string *	const_string_ptr
using	params = sysio::chain_apis::account_query_db::get_accounts_by_authorizers_params

Enumerations
enum class	alt_bn128_error : int32_t {   operand_component_invalid , operand_not_in_curve , pairing_list_size_error , operand_outside_g2 ,   input_len_error , invalid_scalar_size }
enum class	blake2b_error : int32_t { input_len_error }
enum class	k1_recover_error : int32_t { init_error , input_error , invalid_signature , recover_error }
enum class	modular_arithmetic_error : int32_t { modulus_len_zero }
enum	exception_code {   unspecified_exception_code = 0 , unhandled_exception_code = 1 , timeout_exception_code = 2 , file_not_found_exception_code = 3 ,   parse_error_exception_code = 4 , invalid_arg_exception_code = 5 , key_not_found_exception_code = 6 , bad_cast_exception_code = 7 ,   out_of_range_exception_code = 8 , canceled_exception_code = 9 , assert_exception_code = 10 , eof_exception_code = 11 ,   std_exception_code = 13 , invalid_operation_exception_code = 14 , unknown_host_exception_code = 15 , null_optional_code = 16 ,   udt_error_code = 17 , aes_error_code = 18 , overflow_code = 19 , underflow_code = 20 ,   divide_by_zero_code = 21 }
enum	mode_t { read_only , write_only , read_write }

Functions
void	to_variant (const sysio::chain::shared_public_key &var, fc::variant &vo)
void	to_variant (const sysio::chain::chain_id_type &cid, fc::variant &v)
void	from_variant (const fc::variant &v, sysio::chain::chain_id_type &cid)
template<typename ST , typename T >
datastream< ST > &	operator<< (datastream< ST > &s, const sysio::chain::may_not_exist< T > &v)
template<typename ST , typename T >
datastream< ST > &	operator>> (datastream< ST > &s, sysio::chain::may_not_exist< T > &v)
template<typename T >
void	to_variant (const sysio::chain::may_not_exist< T > &e, fc::variant &v)
template<typename T >
void	from_variant (const fc::variant &v, sysio::chain::may_not_exist< T > &e)
void	to_variant (const sysio::chain::asset &var, fc::variant &vo)
void	from_variant (const fc::variant &var, sysio::chain::asset &vo)
void	from_variant (const fc::variant &var, sysio::chain::extended_asset &vo)
template<uint16_t IntervalMs, uint64_t EpochMs>
void	to_variant (const sysio::chain::block_timestamp< IntervalMs, EpochMs > &t, fc::variant &v)
template<uint16_t IntervalMs, uint64_t EpochMs>
void	from_variant (const fc::variant &v, sysio::chain::block_timestamp< IntervalMs, EpochMs > &t)
template<typename OidType >
void	to_variant (const chainbase::oid< OidType > &oid, variant &v)
template<typename OidType >
void	from_variant (const variant &v, chainbase::oid< OidType > &oid)
void	float64_to_double (const float64_t &f, double &d)
void	double_to_float64 (const double &d, float64_t &f)
void	float128_to_uint128 (const float128_t &f, sysio::chain::uint128_t &u)
void	uint128_to_float128 (const sysio::chain::uint128_t &u, float128_t &f)
void	to_variant (const float64_t &f, variant &v)
void	from_variant (const variant &v, float64_t &f)
void	to_variant (const float128_t &f, variant &v)
void	from_variant (const variant &v, float128_t &f)
void	to_variant (const sysio::chain::shared_string &s, variant &v)
void	from_variant (const variant &v, sysio::chain::shared_string &s)
void	to_variant (const sysio::chain::shared_blob &b, variant &v)
void	from_variant (const variant &v, sysio::chain::shared_blob &b)
void	to_variant (const blob &b, variant &v)
void	from_variant (const variant &v, blob &b)
template<typename T >
void	to_variant (const sysio::chain::shared_vector< T > &sv, variant &v)
template<typename T >
void	from_variant (const variant &v, sysio::chain::shared_vector< T > &sv)
void	to_variant (const sysio::chain::name &c, fc::variant &v)
void	from_variant (const fc::variant &v, sysio::chain::name &check)
void	to_variant (const sysio::chain::symbol &var, fc::variant &vo)
void	from_variant (const fc::variant &var, sysio::chain::symbol &vo)
void	to_variant (const sysio::chain::symbol_code &var, fc::variant &vo)
void	from_variant (const fc::variant &var, sysio::chain::symbol_code &vo)
std::size_t	hash_value (const fc::sha256 &v)
template<typename T , size_t N>
bool	operator== (const array< T, N > &a, const array< T, N > &b)
template<typename T , size_t N>
bool	operator< (const array< T, N > &a, const array< T, N > &b)
template<typename T , size_t N>
bool	operator> (const array< T, N > &a, const array< T, N > &b)
template<typename T , size_t N>
bool	operator!= (const array< T, N > &a, const array< T, N > &b)
template<typename T , size_t N>
void	to_variant (const array< T, N > &bi, variant &v)
template<typename T , size_t N>
void	from_variant (const variant &v, array< T, N > &bi)
uint64_t	endian_reverse_u64 (uint64_t x)
uint32_t	endian_reverse_u32 (uint32_t x)
bloom_filter	operator& (const bloom_filter &a, const bloom_filter &b)
bloom_filter	operator| (const bloom_filter &a, const bloom_filter &b)
bloom_filter	operator^ (const bloom_filter &a, const bloom_filter &b)
std::string	smaz_compress (const std::string &in)
std::string	smaz_decompress (const std::string &compressed)
string	zlib_compress (const string &in)
template<typename T , typename... U>
void	to_variant (const boost::container::vector< T, U... > &vec, fc::variant &vo)
template<typename T , typename... U>
void	from_variant (const fc::variant &v, boost::container::vector< T, U... > &vec)
template<typename... U>
void	to_variant (const boost::container::vector< char, U... > &vec, fc::variant &vo)
template<typename... U>
void	from_variant (const fc::variant &v, boost::container::vector< char, U... > &vec)
template<typename T , typename... U>
void	to_variant (const flat_set< T, U... > &s, fc::variant &vo)
template<typename T , typename... U>
void	from_variant (const fc::variant &v, flat_set< T, U... > &s)
template<typename T , typename... U>
void	to_variant (const flat_multiset< T, U... > &s, fc::variant &vo)
template<typename T , typename... U>
void	from_variant (const fc::variant &v, flat_multiset< T, U... > &s)
template<typename K , typename V , typename... U>
void	to_variant (const flat_map< K, V, U... > &m, fc::variant &vo)
template<typename K , typename V , typename... U>
void	from_variant (const variant &v, flat_map< K, V, U... > &m)
template<typename K , typename V , typename... U>
void	to_variant (const flat_multimap< K, V, U... > &m, fc::variant &vo)
template<typename K , typename V , typename... U>
void	from_variant (const variant &v, flat_multimap< K, V, U... > &m)
unsigned	aes_encrypt (unsigned char *plaintext, int plaintext_len, unsigned char *key, unsigned char *iv, unsigned char *ciphertext)
unsigned	aes_decrypt (unsigned char *ciphertext, int ciphertext_len, unsigned char *key, unsigned char *iv, unsigned char *plaintext)
unsigned	aes_cfb_decrypt (unsigned char *ciphertext, int ciphertext_len, unsigned char *key, unsigned char *iv, unsigned char *plaintext)
std::vector< char >	aes_encrypt (const fc::sha512 &key, const std::vector< char > &plain_text)
std::vector< char >	aes_decrypt (const fc::sha512 &key, const std::vector< char > &cipher_text)
void	aes_save (const fc::path &file, const fc::sha512 &key, std::vector< char > plain_text)
std::vector< char >	aes_load (const fc::path &file, const fc::sha512 &key)
std::variant< alt_bn128_error, bytes >	alt_bn128_add (const bytes &op1, const bytes &op2)
std::variant< alt_bn128_error, bytes >	alt_bn128_mul (const bytes &g1_point, const bytes &scalar)
std::variant< alt_bn128_error, bool >	alt_bn128_pair (const bytes &g1_g2_pairs, const yield_function_t &yield)
std::vector< char >	from_base32 (const fc::string &b32)
fc::string	to_base32 (const std::vector< char > &vec)
fc::string	to_base32 (const char *data, size_t len)
std::vector< char >	from_base36 (const fc::string &b36)
fc::string	to_base36 (const std::vector< char > &vec)
fc::string	to_base36 (const char *data, size_t len)
std::string	to_base58 (const char *d, size_t s, const fc::yield_function_t &yield)
std::string	to_base58 (const std::vector< char > &data, const fc::yield_function_t &yield)
std::vector< char >	from_base58 (const std::string &base58_str)
size_t	from_base58 (const std::string &base58_str, char *out_data, size_t out_data_len)
std::string	base64_encode (unsigned char const *bytes_to_encode, unsigned int in_len)
std::string	base64_encode (char const *bytes_to_encode, unsigned int in_len)
std::string	base64_encode (const std::string &enc)
std::string	base64_decode (const std::string &encoded_string)
std::string	base64url_encode (unsigned char const *bytes_to_encode, unsigned int in_len)
std::string	base64url_encode (char const *bytes_to_encode, unsigned int in_len)
std::string	base64url_encode (const std::string &enc)
std::string	base64url_decode (const std::string &encoded_string)
void	to_variant (const bigint &bi, variant &v)
void	from_variant (const variant &v, bigint &bi)
std::variant< blake2b_error, bytes >	blake2b (uint32_t _rounds, const bytes &_h, const bytes &_m, const bytes &_t0_offset, const bytes &_t1_offset, bool _f, const yield_function_t &yield)
uint64_t	city_hash64 (const char *buf, size_t len)
uint32_t	city_hash32 (const char *buf, size_t len)
size_t	city_hash_size_t (const char *buf, size_t len)
uint128	city_hash128 (const char *s, size_t len)
uint64_t	city_hash_crc_64 (const char *buf, size_t len)
uint128	city_hash_crc_128 (const char *s, size_t len)
array< uint64_t, 4 >	city_hash_crc_256 (const char *s, size_t len)
template<typename T >
fc::sha256	digest (const T &value)
void	to_variant (const ecc::private_key &var, variant &vo)
void	from_variant (const variant &var, ecc::private_key &vo)
void	to_variant (const ecc::public_key &var, variant &vo)
void	from_variant (const variant &var, ecc::public_key &vo)
void	to_variant (const em::private_key &var, variant &vo)
void	from_variant (const variant &var, em::private_key &vo)
void	to_variant (const em::public_key &var, variant &vo)
void	from_variant (const variant &var, em::public_key &vo)
void	to_variant (const crypto::r1::private_key &var, variant &vo)
void	from_variant (const variant &var, crypto::r1::private_key &vo)
void	to_variant (const crypto::r1::public_key &var, variant &vo)
void	from_variant (const variant &var, crypto::r1::public_key &vo)
uint8_t	from_hex (char c)
fc::string	to_hex (const char *d, uint32_t s)
std::string	to_hex (const std::vector< char > &data)
size_t	from_hex (const fc::string &hex_str, char *out_data, size_t out_data_len)
std::variant< k1_recover_error, bytes >	k1_recover (const bytes &signature, const bytes &digest)
std::variant< modular_arithmetic_error, bytes >	modexp (const bytes &_base, const bytes &_exponent, const bytes &_modulus)
void	generate_key_pair (public_key &pub, private_key &priv)
bool	operator== (const private_key &a, const private_key &b)
void	to_variant (const public_key &bi, variant &v)
void	from_variant (const variant &v, public_key &bi)
void	to_variant (const private_key &bi, variant &v)
void	from_variant (const variant &v, private_key &bi)
void	to_variant (const crypto::private_key &var, variant &vo, const fc::yield_function_t &yield=fc::yield_function_t())
void	from_variant (const variant &var, crypto::private_key &vo)
void	to_variant (const crypto::public_key &var, variant &vo, const fc::yield_function_t &yield=fc::yield_function_t())
void	from_variant (const variant &var, crypto::public_key &vo)
void	rand_bytes (char *buf, int count)
void	rand_pseudo_bytes (char *buf, int count)
void	to_variant (const ripemd160 &bi, variant &v)
void	from_variant (const variant &v, ripemd160 &bi)
void	to_variant (const sha1 &bi, variant &v)
void	from_variant (const variant &v, sha1 &bi)
void	to_variant (const sha224 &bi, variant &v)
void	from_variant (const variant &v, sha224 &bi)
void	to_variant (const sha256 &bi, variant &v)
void	from_variant (const variant &v, sha256 &bi)
uint64_t	hash64 (const char *buf, size_t len)
void	to_variant (const sha3 &bi, variant &v)
void	from_variant (const variant &v, sha3 &bi)
void	to_variant (const sha512 &bi, variant &v)
void	from_variant (const variant &v, sha512 &bi)
void	to_variant (const crypto::signature &var, variant &vo, const fc::yield_function_t &yield=fc::yield_function_t())
void	from_variant (const variant &var, crypto::signature &vo)
void	to_variant (const exception &e, variant &v)
void	from_variant (const variant &e, exception &ll)
template<typename T >
fc::exception_ptr	copy_exception (T &&e)
	FC_DECLARE_EXCEPTION (timeout_exception, timeout_exception_code, "Timeout")
	FC_DECLARE_EXCEPTION (file_not_found_exception, file_not_found_exception_code, "File Not Found")
	FC_DECLARE_EXCEPTION (parse_error_exception, parse_error_exception_code, "Parse Error")
	report's parse errors
	FC_DECLARE_EXCEPTION (invalid_arg_exception, invalid_arg_exception_code, "Invalid Argument")
	FC_DECLARE_EXCEPTION (key_not_found_exception, key_not_found_exception_code, "Key Not Found")
	reports when a key, guid, or other item is not found.
	FC_DECLARE_EXCEPTION (bad_cast_exception, bad_cast_exception_code, "Bad Cast")
	FC_DECLARE_EXCEPTION (out_of_range_exception, out_of_range_exception_code, "Out of Range")
	FC_DECLARE_EXCEPTION (invalid_operation_exception, invalid_operation_exception_code, "Invalid Operation")
	if an operation is unsupported or not valid this may be thrown
	FC_DECLARE_EXCEPTION (unknown_host_exception, unknown_host_exception_code, "Unknown Host")
	if an host name can not be resolved this may be thrown
	FC_DECLARE_EXCEPTION (canceled_exception, canceled_exception_code, "Canceled")
	used to report a canceled Operation
	FC_DECLARE_EXCEPTION (assert_exception, assert_exception_code, "Assert Exception")
	used inplace of assert() to report violations of pre conditions.
	FC_DECLARE_EXCEPTION (eof_exception, eof_exception_code, "End Of File")
	FC_DECLARE_EXCEPTION (null_optional, null_optional_code, "null optional")
	FC_DECLARE_EXCEPTION (udt_exception, udt_error_code, "UDT error")
	FC_DECLARE_EXCEPTION (aes_exception, aes_error_code, "AES error")
	FC_DECLARE_EXCEPTION (overflow_exception, overflow_code, "Integer Overflow")
	FC_DECLARE_EXCEPTION (underflow_exception, underflow_code, "Integer Underflow")
	FC_DECLARE_EXCEPTION (divide_by_zero_exception, divide_by_zero_code, "Integer Divide By Zero")
std::string	except_str ()
void	record_assert_trip (const char *filename, uint32_t lineno, const char *expr)
bool	exists (const path &p)
bool	is_directory (const path &p)
bool	is_regular_file (const path &p)
void	create_directories (const path &p)
void	remove_all (const path &p)
path	absolute (const path &p)
path	make_relative (const path &from, const path &to)
path	canonical (const path &p)
uint64_t	file_size (const path &p)
uint64_t	directory_size (const path &p)
bool	remove (const path &p)
void	copy (const path &from, const path &to)
void	rename (const path &from, const path &to)
void	resize_file (const path &file, size_t s)
void	chmod (const path &p, int perm)
void	create_hard_link (const path &from, const path &to)
path	unique_path ()
path	temp_directory_path ()
const path &	home_path ()
const path &	app_path ()
const fc::path &	current_path ()
void	to_variant (const fc::path &, fc::variant &)
void	from_variant (const fc::variant &, fc::path &)
template<typename Storage >
void	to_variant (const fixed_string< Storage > &s, variant &v)
template<typename Storage >
void	from_variant (const variant &v, fixed_string< Storage > &s)
template<typename T , unsigned int S, typename U , typename A >
auto	operator+ (const fwd< T, S, A > &x, U &&u) -> typename detail::add< T, U >::type
template<typename T , unsigned int S, typename U , typename A >
auto	operator- (const fwd< T, S, A > &x, U &&u) -> typename detail::sub< T, U >::type
template<typename T , unsigned int S, typename U , typename A >
auto	operator<< (U &u, const fwd< T, S, A > &f) -> typename detail::insert_op< U, T >::type
template<typename T , unsigned int S, typename U , typename A >
auto	operator>> (U &u, fwd< T, S, A > &f) -> typename detail::extract_op< U, T >::type
template<uint64_t RequiredSize, uint64_t ProvidedSize>
void	check_size ()
template<typename T , typename... U>
void	to_variant (const bip::set< T, U... > &s, fc::variant &vo)
template<typename T , typename... U>
void	from_variant (const fc::variant &v, bip::set< T, U... > &s)
template<typename T , typename... U>
void	to_variant (const bip::multiset< T, U... > &s, fc::variant &vo)
template<typename T , typename... U>
void	from_variant (const fc::variant &v, bip::multiset< T, U... > &s)
template<typename K , typename V , typename... U>
void	to_variant (const bip::map< K, V, U... > &m, fc::variant &vo)
template<typename K , typename V , typename... U>
void	from_variant (const variant &v, bip::map< K, V, U... > &m)
template<typename K , typename V , typename... U>
void	to_variant (const bip::multimap< K, V, U... > &m, fc::variant &vo)
template<typename K , typename V , typename... U>
void	from_variant (const variant &v, bip::multimap< K, V, U... > &m)
fc::path	find_executable_in_path (const fc::string name)
template<typename STREAM >
device_adaptor< STREAM, bio::sink_tag >	to_sink (STREAM &strm)
template<typename STREAM >
device_adaptor< STREAM, bio::source_tag >	to_source (STREAM &strm)
template<typename STREAM >
device_adaptor< STREAM, bio::source_tag >	to_seekable (STREAM &strm)
void	set_console_echo (bool enable_echo)
template<typename ST >
datastream< ST > &	operator<< (datastream< ST > &ds, const __int128 &d)
template<typename ST , typename DATA >
datastream< ST > &	operator>> (datastream< ST > &ds, __int128 &d)
template<typename ST >
datastream< ST > &	operator<< (datastream< ST > &ds, const unsigned __int128 &d)
template<typename ST , typename DATA >
datastream< ST > &	operator>> (datastream< ST > &ds, unsigned __int128 &d)
template<typename ST >
datastream< ST > &	operator<< (datastream< ST > &ds, const int64_t &d)
template<typename ST , typename DATA >
datastream< ST > &	operator>> (datastream< ST > &ds, int64_t &d)
template<typename ST >
datastream< ST > &	operator<< (datastream< ST > &ds, const uint64_t &d)
template<typename ST , typename DATA >
datastream< ST > &	operator>> (datastream< ST > &ds, uint64_t &d)
template<typename ST >
datastream< ST > &	operator<< (datastream< ST > &ds, const int32_t &d)
template<typename ST , typename DATA >
datastream< ST > &	operator>> (datastream< ST > &ds, int32_t &d)
template<typename ST >
datastream< ST > &	operator<< (datastream< ST > &ds, const uint32_t &d)
template<typename ST , typename DATA >
datastream< ST > &	operator>> (datastream< ST > &ds, uint32_t &d)
template<typename ST >
datastream< ST > &	operator<< (datastream< ST > &ds, const int16_t &d)
template<typename ST , typename DATA >
datastream< ST > &	operator>> (datastream< ST > &ds, int16_t &d)
template<typename ST >
datastream< ST > &	operator<< (datastream< ST > &ds, const uint16_t &d)
template<typename ST , typename DATA >
datastream< ST > &	operator>> (datastream< ST > &ds, uint16_t &d)
template<typename ST >
datastream< ST > &	operator<< (datastream< ST > &ds, const int8_t &d)
template<typename ST , typename DATA >
datastream< ST > &	operator>> (datastream< ST > &ds, int8_t &d)
template<typename ST >
datastream< ST > &	operator<< (datastream< ST > &ds, const uint8_t &d)
template<typename ST , typename DATA >
datastream< ST > &	operator>> (datastream< ST > &ds, uint8_t &d)
template<typename IntType , typename EnumType >
void	to_variant (const enum_type< IntType, EnumType > &var, variant &vo)
template<typename IntType , typename EnumType >
void	from_variant (const variant &var, enum_type< IntType, EnumType > &vo)
void	read_file_contents (const fc::path &filename, std::string &result)
std::string	escape_string (const std::string_view &str, const json::yield_function_t &yield, bool escape_control_chars=true)
void	to_variant (const signed_int &var, variant &vo)
void	from_variant (const variant &var, signed_int &vo)
void	to_variant (const unsigned_int &var, variant &vo)
void	from_variant (const variant &var, unsigned_int &vo)
void	to_variant (log_level e, variant &v)
void	from_variant (const variant &e, log_level &ll)
void	to_variant (const log_context &l, variant &v)
void	from_variant (const variant &l, log_context &c)
void	to_variant (const log_message &l, variant &v)
void	from_variant (const variant &l, log_message &c)
void	configure_logging (const fc::path &log_config)
bool	configure_logging (const logging_config &l)
void	set_os_thread_name (const string &name)
void	set_thread_name (const string &name)
const string &	get_thread_name ()
template<typename R >
std::function< R, fc::tuple<> >	make_fused (const std::function< R > &f)
template<typename R , typename A >
std::function< R(fc::tuple< A >) >	make_fused (const std::function< R(A)> &f)
template<typename R , typename A , typename B >
std::function< R(fc::tuple< A, B >) >	make_fused (const std::function< R(A, B)> &f)
template<typename R , typename A , typename B , typename C >
std::function< R(fc::tuple< A, B, C >) >	make_fused (const std::function< R(A, B, C)> &f)
template<typename R , typename A , typename B , typename C , typename D >
std::function< R(fc::tuple< A, B, C, D >) >	make_fused (const std::function< R(A, B, C, D)> &f)
void	to_variant (const ip::endpoint &var, variant &vo)
void	from_variant (const variant &var, ip::endpoint &vo)
void	to_variant (const ip::address &var, variant &vo)
void	from_variant (const variant &var, ip::address &vo)
void	add_platform_root_cas_to_context (boost::asio::ssl::context &ctx)
std::vector< boost::asio::ip::udp::endpoint >	resolve (boost::asio::io_service &io_service, const std::string &host, uint16_t port)
void	to_variant (const url &u, fc::variant &v)
void	from_variant (const fc::variant &v, url &u)
void	to_variant (const real128 &var, variant &vo)
void	from_variant (const variant &var, real128 &vo)
void	throw_bad_enum_cast (int64_t i, const char *e)
void	throw_bad_enum_cast (const char *k, const char *e)
template<typename T >
void	to_variant (const T &o, variant &v)
template<typename T >
void	from_variant (const variant &v, T &o)
template<typename Callback >
scoped_exit< Callback >	make_scoped_exit (Callback &&c)
template<typename variant , int32_t i = 0>
void	from_index (variant &v, int index)
template<typename VariantType , typename T , std::size_t index = 0>
constexpr std::size_t	get_index ()
template<typename... T>
void	to_variant (const std::variant< T... > &s, fc::variant &v)
template<typename... T>
void	from_variant (const fc::variant &v, std::variant< T... > &s)
int64_t	to_int64 (const fc::string &)
uint64_t	to_uint64 (const fc::string &)
double	to_double (const fc::string &)
fc::string	to_string (double)
fc::string	to_string (uint64_t)
fc::string	to_string (int64_t)
fc::string	to_string (uint16_t)
std::string	to_pretty_string (int64_t)
fc::string	to_string (int32_t v)
fc::string	to_string (uint32_t v)
fc::string	format_string (const fc::string &, const variant_object &, bool minimize=false)
fc::string	trim (const fc::string &)
fc::string	to_lower (const fc::string &)
string	trim_and_normalize_spaces (const string &s)
constexpr microseconds	seconds (int64_t s)
constexpr microseconds	milliseconds (int64_t s)
constexpr microseconds	minutes (int64_t m)
constexpr microseconds	hours (int64_t h)
constexpr microseconds	days (int64_t d)
void	to_variant (const fc::microseconds &, fc::variant &)
void	from_variant (const fc::variant &, fc::microseconds &)
string	get_approximate_relative_time_string (const time_point_sec &event_time, const time_point_sec &relative_to_time=fc::time_point::now(), const std::string &ago=" ago")
string	get_approximate_relative_time_string (const time_point &event_time, const time_point &relative_to_time=fc::time_point::now(), const std::string &ago=" ago")
template<typename Functor >
auto	call_fused (Functor f, const tuple<> &t) -> decltype(f())
tuple	make_tuple ()
void	to_variant (const uint128 &var, variant &vo)
void	from_variant (const variant &var, uint128 &vo)
bool	is_valid_utf8 (const std::string_view &str)
std::string	prune_invalid_utf8 (const std::string_view &str)
bool	is_utf8 (const std::string &str)
void	decodeUtf8 (const std::string &input, std::wstring *storage)
void	encodeUtf8 (const std::wstring &input, std::string *storage)
template<typename T >
const T &	min (const T &a, const T &b)
constexpr size_t	const_strlen (const char *str)
template<typename Container >
void	move_append (Container &dest, Container &&src)
template<typename Container >
void	copy_append (Container &dest, const Container &src)
template<typename Container >
void	deduplicate (Container &entries)
template<typename T , typename... Args>
void	to_variant (const boost::multi_index_container< T, Args... > &s, fc::variant &v)
template<typename T , typename... Args>
void	from_variant (const fc::variant &v, boost::multi_index_container< T, Args... > &s)
void	to_variant (const UInt< 8 > &n, fc::variant &v)
void	from_variant (const fc::variant &v, UInt< 8 > &n)
void	to_variant (const UInt< 16 > &n, fc::variant &v)
void	from_variant (const fc::variant &v, UInt< 16 > &n)
void	to_variant (const UInt< 32 > &n, fc::variant &v)
void	from_variant (const fc::variant &v, UInt< 32 > &n)
void	to_variant (const UInt< 64 > &n, fc::variant &v)
void	from_variant (const fc::variant &v, UInt< 64 > &n)
template<typename T >
void	to_variant (const boost::multiprecision::number< T > &n, fc::variant &v)
template<typename T >
void	from_variant (const fc::variant &v, boost::multiprecision::number< T > &n)
template<typename T >
void	to_variant (const safe< T > &s, fc::variant &v)
template<typename T >
void	from_variant (const fc::variant &v, safe< T > &s)
template<typename T >
void	to_variant (const std::unique_ptr< T > &s, fc::variant &v)
template<typename T >
void	from_variant (const fc::variant &v, std::unique_ptr< T > &s)
void	to_variant (const uint8_t &var, fc::variant &vo)
void	from_variant (const fc::variant &var, uint8_t &vo)
void	to_variant (const int8_t &var, fc::variant &vo)
void	from_variant (const fc::variant &var, int8_t &vo)
void	to_variant (const uint16_t &var, fc::variant &vo)
void	from_variant (const fc::variant &var, uint16_t &vo)
void	to_variant (const int16_t &var, fc::variant &vo)
void	from_variant (const fc::variant &var, int16_t &vo)
void	to_variant (const uint32_t &var, fc::variant &vo)
void	from_variant (const fc::variant &var, uint32_t &vo)
void	to_variant (const int32_t &var, fc::variant &vo)
void	from_variant (const fc::variant &var, int32_t &vo)
void	to_variant (const unsigned __int128 &var, fc::variant &vo)
void	from_variant (const fc::variant &var, unsigned __int128 &vo)
void	to_variant (const __int128 &var, fc::variant &vo)
void	from_variant (const fc::variant &var, __int128 &vo)
void	to_variant (const variant_object &var, fc::variant &vo)
void	from_variant (const fc::variant &var, variant_object &vo)
void	to_variant (const mutable_variant_object &var, fc::variant &vo)
void	from_variant (const fc::variant &var, mutable_variant_object &vo)
void	to_variant (const std::vector< char > &var, fc::variant &vo)
void	from_variant (const fc::variant &var, std::vector< char > &vo)
template<typename K , typename T >
void	to_variant (const std::unordered_map< K, T > &var, fc::variant &vo)
template<typename K , typename T >
void	from_variant (const fc::variant &var, std::unordered_map< K, T > &vo)
template<typename K , typename T >
void	to_variant (const std::map< K, T > &var, fc::variant &vo)
template<typename K , typename T >
void	from_variant (const fc::variant &var, std::map< K, T > &vo)
template<typename K , typename T >
void	to_variant (const std::multimap< K, T > &var, fc::variant &vo)
template<typename K , typename T >
void	from_variant (const fc::variant &var, std::multimap< K, T > &vo)
template<typename T >
void	to_variant (const std::unordered_set< T > &var, fc::variant &vo)
template<typename T >
void	from_variant (const fc::variant &var, std::unordered_set< T > &vo)
template<typename T >
void	to_variant (const std::deque< T > &var, fc::variant &vo)
template<typename T >
void	from_variant (const fc::variant &var, std::deque< T > &vo)
template<typename T , typename... U>
void	to_variant (const boost::container::deque< T, U... > &d, fc::variant &vo)
template<typename T , typename... U>
void	from_variant (const fc::variant &v, boost::container::deque< T, U... > &d)
template<typename T >
void	to_variant (const std::set< T > &var, fc::variant &vo)
template<typename T >
void	from_variant (const fc::variant &var, std::set< T > &vo)
template<typename T , std::size_t S>
void	to_variant (const std::array< T, S > &var, fc::variant &vo)
template<typename T , std::size_t S>
void	from_variant (const fc::variant &var, std::array< T, S > &vo)
void	to_variant (const time_point &var, fc::variant &vo)
void	from_variant (const fc::variant &var, time_point &vo)
void	to_variant (const time_point_sec &var, fc::variant &vo)
void	from_variant (const fc::variant &var, time_point_sec &vo)
void	to_variant (long long int s, fc::variant &v)
void	to_variant (unsigned long long int s, fc::variant &v)
void	to_variant (const std::string &s, fc::variant &v)
template<typename T >
void	to_variant (const std::shared_ptr< T > &var, fc::variant &vo)
template<typename T >
void	from_variant (const fc::variant &var, std::shared_ptr< T > &vo)
template<typename A , typename B >
void	to_variant (const std::pair< A, B > &t, fc::variant &v)
template<typename A , typename B >
void	from_variant (const fc::variant &v, std::pair< A, B > &p)
void	from_variant (const fc::variant &var, string &vo)
void	from_variant (const fc::variant &var, fc::variants &vo)
void	from_variant (const fc::variant &var, fc::variant &vo)
void	from_variant (const fc::variant &var, int64_t &vo)
void	from_variant (const fc::variant &var, uint64_t &vo)
void	from_variant (const fc::variant &var, bool &vo)
void	from_variant (const fc::variant &var, double &vo)
void	from_variant (const fc::variant &var, float &vo)
template<typename T >
void	from_variant (const variant &var, std::optional< T > &vo)
template<typename T >
void	from_variant (const fc::variant &var, std::vector< T > &tmp)
template<typename T >
void	to_variant (const std::vector< T > &t, fc::variant &v)
fc::variant	operator+ (const fc::variant &a, const fc::variant &b)
fc::variant	operator- (const fc::variant &a, const fc::variant &b)
fc::variant	operator* (const fc::variant &a, const fc::variant &b)
fc::variant	operator/ (const fc::variant &a, const fc::variant &b)
bool	operator== (const fc::variant &a, const fc::variant &b)
bool	operator!= (const fc::variant &a, const fc::variant &b)
bool	operator< (const fc::variant &a, const fc::variant &b)
bool	operator> (const fc::variant &a, const fc::variant &b)
bool	operator! (const fc::variant &a)
uint32_t	smaz_compress (const char *in, int inlen, char *out, int outlen)
void	smaz_decompress (const char *in, uint32_t inlen, std::stringstream &ss)
void	initLibSnark () noexcept
Scalar	to_scalar (const bytes &be) noexcept
std::variant< alt_bn128_error, libff::alt_bn128_G1 >	decode_g1_element (const bytes &bytes64_be) noexcept
std::variant< alt_bn128_error, libff::alt_bn128_Fq2 >	decode_fp2_element (const bytes &bytes64_be) noexcept
std::variant< alt_bn128_error, libff::alt_bn128_G2 >	decode_g2_element (const bytes &bytes128_be) noexcept
bytes	encode_g1_element (libff::alt_bn128_G1 p) noexcept
std::string	base64_encode_impl (unsigned char const *bytes_to_encode, unsigned int in_len, const char *const b64_chars)
std::string	base64_decode_impl (std::string const &encoded_string, const char *const b64_chars)
unsigned char	Byte (unsigned int ui)
void	BytesToBlock (unsigned char const *p, sblock &b)
void	BlockToBytes (sblock const &b, unsigned char *p)
uint64_t	Uint128Low64 (const uint128 &x)
uint64_t	Uint128High64 (const uint128 &x)
uint64_t	Hash128to64 (const uint128 &x)
uint64_t	CityHash64WithSeeds (const char *s, size_t len, uint64_t seed0, uint64_t seed1)
uint64_t	CityHash64WithSeed (const char *s, size_t len, uint64_t seed)
uint128	CityHash128WithSeed (const char *s, size_t len, uint128 seed)
void	CityHashCrc256 (const char *s, size_t len, uint64_t *result)
uint128	CityHashCrc128WithSeed (const char *s, size_t len, uint128 seed)
const secp256k1_context *	k1_recover_context ()
ripemd160	operator<< (const ripemd160 &h1, uint32_t i)
ripemd160	operator^ (const ripemd160 &h1, const ripemd160 &h2)
bool	operator>= (const ripemd160 &h1, const ripemd160 &h2)
bool	operator> (const ripemd160 &h1, const ripemd160 &h2)
bool	operator< (const ripemd160 &h1, const ripemd160 &h2)
bool	operator!= (const ripemd160 &h1, const ripemd160 &h2)
bool	operator== (const ripemd160 &h1, const ripemd160 &h2)
sha1	operator<< (const sha1 &h1, uint32_t i)
sha1	operator^ (const sha1 &h1, const sha1 &h2)
bool	operator>= (const sha1 &h1, const sha1 &h2)
bool	operator> (const sha1 &h1, const sha1 &h2)
bool	operator< (const sha1 &h1, const sha1 &h2)
bool	operator!= (const sha1 &h1, const sha1 &h2)
bool	operator== (const sha1 &h1, const sha1 &h2)
sha224	operator<< (const sha224 &h1, uint32_t i)
sha224	operator^ (const sha224 &h1, const sha224 &h2)
bool	operator>= (const sha224 &h1, const sha224 &h2)
bool	operator> (const sha224 &h1, const sha224 &h2)
bool	operator< (const sha224 &h1, const sha224 &h2)
bool	operator!= (const sha224 &h1, const sha224 &h2)
bool	operator== (const sha224 &h1, const sha224 &h2)
sha256	operator<< (const sha256 &h1, uint32_t i)
sha256	operator>> (const sha256 &h1, uint32_t i)
sha256	operator^ (const sha256 &h1, const sha256 &h2)
bool	operator>= (const sha256 &h1, const sha256 &h2)
bool	operator> (const sha256 &h1, const sha256 &h2)
bool	operator< (const sha256 &h1, const sha256 &h2)
bool	operator!= (const sha256 &h1, const sha256 &h2)
bool	operator== (const sha256 &h1, const sha256 &h2)
template<class... Ts>
	overloaded (Ts...) -> overloaded< Ts... >
	__attribute__ ((always_inline)) inline uint64_t rotl64(uint64_t x
sha3	operator<< (const sha3 &h1, uint32_t i)
sha3	operator>> (const sha3 &h1, uint32_t i)
sha3	operator^ (const sha3 &h1, const sha3 &h2)
bool	operator>= (const sha3 &h1, const sha3 &h2)
bool	operator> (const sha3 &h1, const sha3 &h2)
bool	operator< (const sha3 &h1, const sha3 &h2)
bool	operator!= (const sha3 &h1, const sha3 &h2)
bool	operator== (const sha3 &h1, const sha3 &h2)
sha512	operator<< (const sha512 &h1, uint32_t i)
sha512	operator^ (const sha512 &h1, const sha512 &h2)
bool	operator>= (const sha512 &h1, const sha512 &h2)
bool	operator> (const sha512 &h1, const sha512 &h2)
bool	operator< (const sha512 &h1, const sha512 &h2)
bool	operator!= (const sha512 &h1, const sha512 &h2)
bool	operator== (const sha512 &h1, const sha512 &h2)
file_not_found_exception parse_error_exception invalid_arg_exception invalid_operation_exception key_not_found_exception bad_cast_exception out_of_range_exception canceled_exception assert_exception eof_exception unknown_host_exception null_optional udt_exception aes_exception overflow_exception	underflow_exception (divide_by_zero_exception)) namespace detail
bool	assert_optional (bool is_valid)
bool	operator< (const fc::path &l, const fc::path &r)
bool	operator== (const fc::path &l, const fc::path &r)
bool	operator!= (const fc::path &l, const fc::path &r)
path	operator/ (const fc::path &p, const fc::path &o)
bool	operator== (const directory_iterator &r, const directory_iterator &l)
bool	operator!= (const directory_iterator &r, const directory_iterator &l)
bool	operator== (const recursive_directory_iterator &r, const recursive_directory_iterator &l)
bool	operator!= (const recursive_directory_iterator &r, const recursive_directory_iterator &l)
template<typename T , json::parse_type parser_type>
variant	variant_from_stream (T &in, uint32_t max_depth)
template<typename T >
char	parseEscape (T &in)
template<typename T >
std::string	stringFromStream (T &in)
template<typename T >
bool	skip_white_space (T &in)
template<typename T >
std::string	stringFromToken (T &in)
template<typename T , json::parse_type parser_type>
variant_object	objectFromStream (T &in, uint32_t max_depth)
template<typename T , json::parse_type parser_type>
variants	arrayFromStream (T &in, uint32_t max_depth)
template<typename T , json::parse_type parser_type>
variant	number_from_stream (T &in)
template<typename T >
variant	token_from_stream (T &in)
template<typename T >
void	to_stream (T &os, const variants &a, const json::yield_function_t &yield, json::output_formatting format)
template<typename T >
void	to_stream (T &os, const variant_object &o, const json::yield_function_t &yield, json::output_formatting format)
template<typename T >
void	to_stream (T &os, const variant &v, const json::yield_function_t &yield, json::output_formatting format)
std::string	pretty_print (const std::string &v, uint8_t indent)
string	fixed_size (size_t s, const string &str)
bool	operator== (const logger &l, std::nullptr_t)
bool	operator!= (const logger &l, std::nullptr_t)
fc::variant	create_zipkin_variant (zipkin_span::span_data &&span, const std::string &service_name)
void	check_udt_errors ()
udt_epoll_service &	default_epool_service ()
std::shared_ptr< detail::url_impl >	get_null_url ()
template<typename octet_iterator >
std::pair< octet_iterator, uint32_t >	find_invalid (octet_iterator start, octet_iterator end, const std::pair< uint32_t, uint32_t > &invalid_range)
void	set_variant_type (variant *v, variant::type_id t)
void	clean_append (string &app, const std::string_view &s, size_t pos=0, size_t len=string::npos)
bool	operator<= (const variant &a, const variant &b)
template<typename T >
const T &	as_type (const T &x)
template<typename ST , typename T >
datastream< ST > &	history_serialize_container (datastream< ST > &ds, const chainbase::database &db, const T &v)
template<typename ST , typename T >
datastream< ST > &	history_serialize_container (datastream< ST > &ds, const chainbase::database &db, const std::vector< std::shared_ptr< T > > &v)
template<typename ST , typename P , typename T >
datastream< ST > &	history_context_serialize_container (datastream< ST > &ds, const chainbase::database &db, const P &context, const std::vector< T > &v)
template<typename ST , typename T >
datastream< ST > &	operator<< (datastream< ST > &ds, const sysio::state_history::big_vector_wrapper< T > &obj)
template<typename ST >
void	history_pack_varuint64 (datastream< ST > &ds, uint64_t val)
template<typename ST >
void	history_pack_big_bytes (datastream< ST > &ds, const sysio::chain::bytes &v)
template<typename ST >
void	history_pack_big_bytes (datastream< ST > &ds, const std::optional< sysio::chain::bytes > &v)
template<typename ST , typename T >
datastream< ST > &	operator<< (datastream< ST > &ds, const history_serial_wrapper< std::vector< T > > &obj)
template<typename ST , typename P , typename T >
datastream< ST > &	operator<< (datastream< ST > &ds, const history_context_wrapper< P, std::vector< T > > &obj)
template<typename ST , typename First , typename Second >
datastream< ST > &	operator<< (datastream< ST > &ds, const history_serial_wrapper< std::pair< First, Second > > &obj)
template<typename ST >
datastream< ST > &	operator<< (datastream< ST > &ds, const history_serial_wrapper< sysio::chain::account_object > &obj)
template<typename ST >
datastream< ST > &	operator<< (datastream< ST > &ds, const history_serial_wrapper< sysio::chain::account_metadata_object > &obj)
template<typename ST >
datastream< ST > &	operator<< (datastream< ST > &ds, const history_serial_wrapper< sysio::chain::code_object > &obj)
template<typename ST >
datastream< ST > &	operator<< (datastream< ST > &ds, const history_serial_wrapper< sysio::chain::table_id_object > &obj)
template<typename ST >
datastream< ST > &	operator<< (datastream< ST > &ds, const history_context_wrapper< sysio::chain::table_id_object, sysio::chain::key_value_object > &obj)
template<typename ST , typename T >
void	serialize_secondary_index_data (datastream< ST > &ds, const T &obj)
template<typename ST >
void	serialize_secondary_index_data (datastream< ST > &ds, const float64_t &obj)
template<typename ST >
void	serialize_secondary_index_data (datastream< ST > &ds, const float128_t &obj)
template<typename ST >
void	serialize_secondary_index_data (datastream< ST > &ds, const sysio::chain::key256_t &obj)
template<typename ST , typename T >
datastream< ST > &	serialize_secondary_index (datastream< ST > &ds, const sysio::chain::table_id_object &context, const T &obj)
template<typename ST >
datastream< ST > &	operator<< (datastream< ST > &ds, const history_context_wrapper< sysio::chain::table_id_object, sysio::chain::index64_object > &obj)
template<typename ST >
datastream< ST > &	operator<< (datastream< ST > &ds, const history_serial_wrapper< sysio::chain::shared_block_signing_authority_v0 > &obj)
template<typename ST >
datastream< ST > &	operator<< (datastream< ST > &ds, const history_serial_wrapper< sysio::chain::shared_producer_authority > &obj)
template<typename ST >
datastream< ST > &	operator<< (datastream< ST > &ds, const history_serial_wrapper< sysio::chain::shared_producer_authority_schedule > &obj)
template<typename ST >
datastream< ST > &	operator<< (datastream< ST > &ds, const history_serial_wrapper< sysio::chain::chain_config > &obj)
template<typename ST >
datastream< ST > &	operator<< (datastream< ST > &ds, const history_serial_wrapper< sysio::chain::wasm_config > &obj)
template<typename ST >
datastream< ST > &	operator<< (datastream< ST > &ds, const history_serial_wrapper< sysio::chain::global_property_object > &obj)
template<typename ST >
datastream< ST > &	operator<< (datastream< ST > &ds, const history_serial_wrapper< sysio::chain::generated_transaction_object > &obj)
template<typename ST >
datastream< ST > &	operator<< (datastream< ST > &ds, const history_serial_wrapper< sysio::chain::protocol_state_object::activated_protocol_feature > &obj)
template<typename ST >
datastream< ST > &	operator<< (datastream< ST > &ds, const history_serial_wrapper< sysio::chain::protocol_state_object > &obj)
template<typename ST >
datastream< ST > &	operator<< (datastream< ST > &ds, const history_serial_wrapper< sysio::chain::shared_key_weight > &obj)
template<typename ST >
datastream< ST > &	operator<< (datastream< ST > &ds, const history_serial_wrapper< sysio::chain::permission_level > &obj)
template<typename ST >
datastream< ST > &	operator<< (datastream< ST > &ds, const history_serial_wrapper< sysio::chain::permission_level_weight > &obj)
template<typename ST >
datastream< ST > &	operator<< (datastream< ST > &ds, const history_serial_wrapper< sysio::chain::wait_weight > &obj)
template<typename ST >
datastream< ST > &	operator<< (datastream< ST > &ds, const history_serial_wrapper< sysio::chain::shared_authority > &obj)
template<typename ST >
datastream< ST > &	operator<< (datastream< ST > &ds, const history_serial_wrapper< sysio::chain::permission_object > &obj)
template<typename ST >
datastream< ST > &	operator<< (datastream< ST > &ds, const history_serial_wrapper< sysio::chain::permission_link_object > &obj)
template<typename ST >
datastream< ST > &	operator<< (datastream< ST > &ds, const history_serial_wrapper< sysio::chain::resource_limits::resource_limits_object > &obj)
template<typename ST >
datastream< ST > &	operator<< (datastream< ST > &ds, const history_serial_wrapper< sysio::chain::resource_limits::usage_accumulator > &obj)
template<typename ST >
datastream< ST > &	operator<< (datastream< ST > &ds, const history_serial_wrapper< sysio::chain::resource_limits::resource_usage_object > &obj)
template<typename ST >
datastream< ST > &	operator<< (datastream< ST > &ds, const history_serial_wrapper< sysio::chain::resource_limits::resource_limits_state_object > &obj)
template<typename ST >
datastream< ST > &	operator<< (datastream< ST > &ds, const history_serial_wrapper< sysio::chain::resource_limits::ratio > &obj)
template<typename ST >
datastream< ST > &	operator<< (datastream< ST > &ds, const history_serial_wrapper< sysio::chain::resource_limits::elastic_limit_parameters > &obj)
template<typename ST >
datastream< ST > &	operator<< (datastream< ST > &ds, const history_serial_wrapper< sysio::chain::resource_limits::resource_limits_config_object > &obj)
template<typename ST >
datastream< ST > &	operator<< (datastream< ST > &ds, const history_serial_wrapper< sysio::chain::action > &obj)
template<typename ST >
datastream< ST > &	operator<< (datastream< ST > &ds, const history_serial_wrapper< sysio::chain::action_receipt > &obj)
template<typename ST >
datastream< ST > &	operator<< (datastream< ST > &ds, const history_serial_wrapper< sysio::chain::account_delta > &obj)
std::optional< uint64_t >	cap_error_code (const std::optional< uint64_t > &error_code)
template<typename ST >
datastream< ST > &	operator<< (datastream< ST > &ds, const history_context_wrapper< bool, sysio::chain::action_trace > &obj)
template<typename ST >
datastream< ST > &	operator<< (datastream< ST > &ds, const history_context_wrapper< std::pair< uint8_t, bool >, sysio::state_history::augmented_transaction_trace > &obj)
template<typename ST >
datastream< ST > &	operator<< (datastream< ST > &ds, const history_context_wrapper< bool, sysio::state_history::augmented_transaction_trace > &obj)
template<typename ST >
datastream< ST > &	operator<< (datastream< ST > &ds, const sysio::state_history::get_blocks_result_v0 &obj)
void	to_variant (const params::permission_level &a, fc::variant &v)
void	from_variant (const fc::variant &v, params::permission_level &a)
template<typename ... Ts>
std::ostream &	operator<< (std::ostream &os, const std::variant< Ts... > &v)
std::ostream &	operator<< (std::ostream &os, const fc::microseconds &t)

Variables
bool	enable_record_assert_trip = false
const char *const	git_revision_sha
const uint32_t	git_revision_unix_timestamp
uint64_t	y { return (x << y) | (x >> (64-y))
bool	do_default_config = configure_logging( logging_config::default_config() )
constexpr char	hex_digits [] = "0123456789abcdef"
constexpr size_t	minimize_max_size = 1024

Detailed Description

This file contains general purpose utilities related to UTF-8 <-> Unicode conversions.

sysio::chain

Implemented with std::string for now.

Typedef Documentation

any

typedef boost::any fc::any

Definition at line 6 of file any.hpp.

api_id_type

typedef uint32_t fc::api_id_type

Definition at line 46 of file api.hpp.

api_ptr

typedef std::shared_ptr< api_base > fc::api_ptr

Definition at line 62 of file api.hpp.

buffered_istream_ptr

typedef std::shared_ptr<buffered_istream> fc::buffered_istream_ptr

Definition at line 46 of file buffered_iostream.hpp.

buffered_ostream_ptr

typedef std::shared_ptr<buffered_ostream> fc::buffered_ostream_ptr

Definition at line 72 of file buffered_iostream.hpp.

bytes

typedef std::vector< char > fc::bytes = std::vector<char>

Definition at line 10 of file alt_bn128.hpp.

const_blob_ptr

typedef const blob* fc::const_blob_ptr

Definition at line 165 of file variant.cpp.

const_char_ptr

typedef const char* fc::const_char_ptr

Definition at line 7 of file smaz.cpp.

const_string_ptr

typedef const string* fc::const_string_ptr

Definition at line 166 of file variant.cpp.

const_variant_object_ptr

typedef const variant_object* fc::const_variant_object_ptr

Definition at line 163 of file variant.cpp.

const_variants_ptr

typedef const variants* fc::const_variants_ptr

Definition at line 164 of file variant.cpp.

exception_ptr

typedef std::shared_ptr<exception> fc::exception_ptr

Definition at line 139 of file exception.hpp.

hmac_sha224

typedef hmac<fc::sha224> fc::hmac_sha224

Definition at line 57 of file hmac.hpp.

hmac_sha256

typedef hmac<fc::sha256> fc::hmac_sha256

Definition at line 58 of file hmac.hpp.

hmac_sha512

typedef hmac<fc::sha512> fc::hmac_sha512

Definition at line 59 of file hmac.hpp.

Int

template<size_t Size>

using fc::Int

Initial value:

 boost::multiprecision::number<
         boost::multiprecision::cpp_int_backend<Size, Size, boost::multiprecision::signed_magnitude, boost::multiprecision::unchecked, void> >

Definition at line 57 of file variant.hpp.

iprocess_ptr

typedef std::shared_ptr<iprocess> fc::iprocess_ptr

Definition at line 64 of file iprocess.hpp.

log_messages

typedef std::vector<log_message> fc::log_messages

Definition at line 136 of file log_message.hpp.

m128

typedef boost::multiprecision::uint128_t fc::m128

Definition at line 11 of file uint128.cpp.

mock_deadline_timer

typedef boost::asio::basic_deadline_timer<boost::posix_time::ptime, mock_time_traits> fc::mock_deadline_timer

Definition at line 45 of file mock_time.hpp.

nullptr_t

typedef decltype(nullptr) fc::nullptr_t

Definition at line 28 of file utility.hpp.

oexception

typedef std::optional<exception> fc::oexception

Definition at line 141 of file exception.hpp.

opath

typedef std::optional<fc::path> fc::opath

Definition at line 11 of file url.hpp.

ostring

typedef std::optional< fc::string > fc::ostring

Definition at line 10 of file url.hpp.

otime_point

typedef std::optional<time_point> fc::otime_point

Definition at line 123 of file time.hpp.

ovariant

typedef std::optional<variant> fc::ovariant

Definition at line 369 of file variant.hpp.

ovariant_object

typedef std::optional<fc::variant_object> fc::ovariant_object

Definition at line 12 of file url.hpp.

params

using fc::params = sysio::chain_apis::account_query_db::get_accounts_by_authorizers_params

Definition at line 91 of file account_query_db.hpp.

process_ptr

typedef std::shared_ptr<process> fc::process_ptr

Definition at line 35 of file process.hpp.

Scalar

using fc::Scalar = libff::bigint<libff::alt_bn128_q_limbs>

Definition at line 15 of file alt_bn128.cpp.

signature

typedef bytes fc::signature

Definition at line 17 of file pke.hpp.

string

typedef std::string fc::string

Definition at line 10 of file string.hpp.

UInt

template<size_t Size>

using fc::UInt

Initial value:

 boost::multiprecision::number<
         boost::multiprecision::cpp_int_backend<Size, Size, boost::multiprecision::unsigned_magnitude, boost::multiprecision::unchecked, void> >

Definition at line 54 of file variant.hpp.

uint160

typedef ripemd160 fc::uint160

Definition at line 79 of file ripemd160.hpp.

uint160_t

typedef ripemd160 fc::uint160_t

Definition at line 78 of file ripemd160.hpp.

uint256

typedef sha256 fc::uint256

Definition at line 103 of file sha256.hpp.

uint512

typedef fc::sha512 fc::uint512

Definition at line 70 of file sha512.hpp.

variants

typedef std::vector<fc::variant> fc::variants

Definition at line 173 of file variant.hpp.

yield_function_t

using fc::yield_function_t = optional_delegate<void()>

Definition at line 205 of file utility.hpp.

Enumeration Type Documentation

alt_bn128_error

enum class fc::alt_bn128_error : int32_t

strong

Enumerator
operand_component_invalid
operand_not_in_curve
pairing_list_size_error
operand_outside_g2
input_len_error
invalid_scalar_size

Definition at line 12 of file alt_bn128.hpp.

                               : int32_t {
        operand_component_invalid,
        operand_not_in_curve,
        pairing_list_size_error,
        operand_outside_g2,
        input_len_error,
        invalid_scalar_size
    };

blake2b_error

enum class fc::blake2b_error : int32_t

strong

Enumerator
input_len_error

Definition at line 14 of file blake2.hpp.

                             : int32_t {
        input_len_error
    };

exception_code

enum fc::exception_code

Enumerator
unspecified_exception_code	for exceptions we threw that don't have an assigned code
unhandled_exception_code	for unhandled 3rd party exceptions
timeout_exception_code	timeout exceptions
file_not_found_exception_code
parse_error_exception_code
invalid_arg_exception_code
key_not_found_exception_code
bad_cast_exception_code
out_of_range_exception_code
canceled_exception_code
assert_exception_code
eof_exception_code
std_exception_code
invalid_operation_exception_code
unknown_host_exception_code
null_optional_code
udt_error_code
aes_error_code
overflow_code
underflow_code
divide_by_zero_code

Definition at line 17 of file exception.hpp.

   {
       unspecified_exception_code        = 0,
       unhandled_exception_code          = 1, 
       timeout_exception_code            = 2, 
       file_not_found_exception_code     = 3,
       parse_error_exception_code        = 4,
       invalid_arg_exception_code        = 5,
       key_not_found_exception_code      = 6,
       bad_cast_exception_code           = 7,
       out_of_range_exception_code       = 8,
       canceled_exception_code           = 9,
       assert_exception_code             = 10,
       eof_exception_code                = 11,
       std_exception_code                = 13,
       invalid_operation_exception_code  = 14,
       unknown_host_exception_code       = 15,
       null_optional_code                = 16,
       udt_error_code                    = 17,
       aes_error_code                    = 18,
       overflow_code                     = 19,
       underflow_code                    = 20,
       divide_by_zero_code               = 21
   };

k1_recover_error

enum class fc::k1_recover_error : int32_t

strong

Enumerator
init_error
input_error
invalid_signature
recover_error

Definition at line 12 of file k1_recover.hpp.

                                : int32_t {
        init_error,
        input_error,
        invalid_signature,
        recover_error,
    };

mode_t

enum fc::mode_t

Enumerator
read_only
write_only
read_write

Definition at line 12 of file file_mapping.hpp.

              {
    read_only, 
    write_only,
    read_write
  };

modular_arithmetic_error

enum class fc::modular_arithmetic_error : int32_t

strong

Enumerator
modulus_len_zero

Definition at line 10 of file modular_arithmetic.hpp.

                                        : int32_t {
        modulus_len_zero,
    };

Function Documentation

__attribute__()

fc::__attribute__

(

(always_inline)

)

absolute()

fc::path fc::absolute

(

const path &

p

)

Definition at line 364 of file filesystem.cpp.

{ return boost::filesystem::absolute(p); }

Here is the caller graph for this function:

add_platform_root_cas_to_context()

void fc::add_platform_root_cas_to_context

(

boost::asio::ssl::context &

ctx

)

Definition at line 117 of file platform_root_ca.cpp.

                                                                {
#if defined( __APPLE__ )
      add_macos_root_cas(ctx);
#elif defined( _WIN32 )
      FC_THROW("HTTPS on Windows not supported");
#else
      ctx.set_default_verify_paths();
#endif
}

Here is the caller graph for this function:

aes_cfb_decrypt()

unsigned fc::aes_cfb_decrypt	(	unsigned char *	ciphertext,
		int	ciphertext_len,
		unsigned char *	key,
		unsigned char *	iv,
		unsigned char *	plaintext )

Definition at line 257 of file aes.cpp.

{
    evp_cipher_ctx ctx( EVP_CIPHER_CTX_new() );
    int len = 0;
    unsigned plaintext_len = 0;
 
    /* Create and initialise the context */
    if(!ctx)
    {
        FC_THROW_EXCEPTION( aes_exception, "error allocating evp cipher context",
                           ("s", ERR_error_string( ERR_get_error(), nullptr) ) );
    }
 
    /* Initialise the decryption operation. IMPORTANT - ensure you use a key
    *    * and IV size appropriate for your cipher
    *       * In this example we are using 256 bit AES (i.e. a 256 bit key). The
    *          * IV size for *most* modes is the same as the block size. For AES this
    *             * is 128 bits */
    if(1 != EVP_DecryptInit_ex(ctx, EVP_aes_256_cfb128(), NULL, key, iv))
    {
        FC_THROW_EXCEPTION( aes_exception, "error during aes 256 cbc decrypt init",
                           ("s", ERR_error_string( ERR_get_error(), nullptr) ) );
    }
 
    /* Provide the message to be decrypted, and obtain the plaintext output.
    *    * EVP_DecryptUpdate can be called multiple times if necessary
    *       */
    if(1 != EVP_DecryptUpdate(ctx, plaintext, &len, ciphertext, ciphertext_len))
    {
        FC_THROW_EXCEPTION( aes_exception, "error during aes 256 cbc decrypt update",
                           ("s", ERR_error_string( ERR_get_error(), nullptr) ) );
    }
 
    plaintext_len = len;
 
    /* Finalise the decryption. Further plaintext bytes may be written at
    *    * this stage.
    *       */
    if(1 != EVP_DecryptFinal_ex(ctx, plaintext + len, &len))
    {
        FC_THROW_EXCEPTION( aes_exception, "error during aes 256 cbc decrypt final",
                           ("s", ERR_error_string( ERR_get_error(), nullptr) ) );
    }
    plaintext_len += len;
 
    return plaintext_len;
}

aes_decrypt() [1/2]

std::vector< char > fc::aes_decrypt	(	const fc::sha512 &	key,
		const std::vector< char > &	cipher_text )

Definition at line 317 of file aes.cpp.

{
    std::vector<char> plain_text( cipher_text.size() );
    auto plain_len = aes_decrypt( (unsigned char*)cipher_text.data(), (int)cipher_text.size(),  
                                 (unsigned char*)&key, ((unsigned char*)&key)+32,
                                 (unsigned char*)plain_text.data() );
    plain_text.resize(plain_len);
    return plain_text;
}

Here is the call graph for this function:

aes_decrypt() [2/2]

unsigned fc::aes_decrypt	(	unsigned char *	ciphertext,
		int	ciphertext_len,
		unsigned char *	key,
		unsigned char *	iv,
		unsigned char *	plaintext )

Definition at line 208 of file aes.cpp.

{
    evp_cipher_ctx ctx( EVP_CIPHER_CTX_new() );
    int len = 0;
    unsigned plaintext_len = 0;
 
    /* Create and initialise the context */
    if(!ctx) 
    {
        FC_THROW_EXCEPTION( aes_exception, "error allocating evp cipher context", 
                           ("s", ERR_error_string( ERR_get_error(), nullptr) ) );
    }
 
    /* Initialise the decryption operation. IMPORTANT - ensure you use a key
    *    * and IV size appropriate for your cipher
    *       * In this example we are using 256 bit AES (i.e. a 256 bit key). The
    *          * IV size for *most* modes is the same as the block size. For AES this
    *             * is 128 bits */
    if(1 != EVP_DecryptInit_ex(ctx, EVP_aes_256_cbc(), NULL, key, iv))
    {
        FC_THROW_EXCEPTION( aes_exception, "error during aes 256 cbc decrypt init", 
                           ("s", ERR_error_string( ERR_get_error(), nullptr) ) );
    }
 
    /* Provide the message to be decrypted, and obtain the plaintext output.
    *    * EVP_DecryptUpdate can be called multiple times if necessary
    *       */
    if(1 != EVP_DecryptUpdate(ctx, plaintext, &len, ciphertext, ciphertext_len))
    {
        FC_THROW_EXCEPTION( aes_exception, "error during aes 256 cbc decrypt update", 
                           ("s", ERR_error_string( ERR_get_error(), nullptr) ) );
    }
 
    plaintext_len = len;
 
    /* Finalise the decryption. Further plaintext bytes may be written at
    *    * this stage.
    *       */
    if(1 != EVP_DecryptFinal_ex(ctx, plaintext + len, &len)) 
    {
        FC_THROW_EXCEPTION( aes_exception, "error during aes 256 cbc decrypt final", 
                           ("s", ERR_error_string( ERR_get_error(), nullptr) ) );
    }
    plaintext_len += len;
 
    return plaintext_len;
}

Here is the caller graph for this function:

aes_encrypt() [1/2]

std::vector< char > fc::aes_encrypt	(	const fc::sha512 &	key,
		const std::vector< char > &	plain_text )

Definition at line 306 of file aes.cpp.

{
    std::vector<char> cipher_text(plain_text.size()+16);
    auto cipher_len = aes_encrypt( (unsigned char*)plain_text.data(), (int)plain_text.size(),  
                                   (unsigned char*)&key, ((unsigned char*)&key)+32,
                                   (unsigned char*)cipher_text.data() );
    FC_ASSERT( cipher_len <= cipher_text.size() );
    cipher_text.resize(cipher_len);
    return cipher_text;
 
}

Here is the call graph for this function:

aes_encrypt() [2/2]

unsigned fc::aes_encrypt	(	unsigned char *	plaintext,
		int	plaintext_len,
		unsigned char *	key,
		unsigned char *	iv,
		unsigned char *	ciphertext )

example method from wiki.opensslfoundation.com

Definition at line 159 of file aes.cpp.

{
    evp_cipher_ctx ctx( EVP_CIPHER_CTX_new() );
 
    int len = 0;
    unsigned ciphertext_len = 0;
 
    /* Create and initialise the context */
    if(!ctx)
    {
        FC_THROW_EXCEPTION( aes_exception, "error allocating evp cipher context", 
                           ("s", ERR_error_string( ERR_get_error(), nullptr) ) );
    }
 
    /* Initialise the encryption operation. IMPORTANT - ensure you use a key
    *    and IV size appropriate for your cipher
    *    In this example we are using 256 bit AES (i.e. a 256 bit key). The
    *    IV size for *most* modes is the same as the block size. For AES this
    *    is 128 bits */
    if(1 != EVP_EncryptInit_ex(ctx, EVP_aes_256_cbc(), NULL, key, iv))
    {
        FC_THROW_EXCEPTION( aes_exception, "error during aes 256 cbc encryption init", 
                           ("s", ERR_error_string( ERR_get_error(), nullptr) ) );
    }
 
    /* Provide the message to be encrypted, and obtain the encrypted output.
    *    * EVP_EncryptUpdate can be called multiple times if necessary
    *       */
    if(1 != EVP_EncryptUpdate(ctx, ciphertext, &len, plaintext, plaintext_len))
    {
        FC_THROW_EXCEPTION( aes_exception, "error during aes 256 cbc encryption update", 
                           ("s", ERR_error_string( ERR_get_error(), nullptr) ) );
    }
    ciphertext_len = len;
 
    /* Finalise the encryption. Further ciphertext bytes may be written at
    *    * this stage.
    *       */
    if(1 != EVP_EncryptFinal_ex(ctx, ciphertext + len, &len)) 
    {
        FC_THROW_EXCEPTION( aes_exception, "error during aes 256 cbc encryption final", 
                           ("s", ERR_error_string( ERR_get_error(), nullptr) ) );
    }
    ciphertext_len += len;
 
    return ciphertext_len;
}

Here is the caller graph for this function:

aes_load()

std::vector< char > fc::aes_load	(	const fc::path &	file,
		const fc::sha512 &	key )

recovers the plain_text saved via aes_save()

Definition at line 347 of file aes.cpp.

{ try {
   FC_ASSERT( fc::exists( file ) );
 
   std::ifstream in( file.generic_string().c_str(), std::ifstream::binary );
   fc::sha512 check;
   std::vector<char> cipher;
 
   fc::raw::unpack( in, check );
   fc::raw::unpack( in, cipher );
 
   fc::sha512::encoder check_enc;
   fc::raw::pack( check_enc, key );
   fc::raw::pack( check_enc, cipher );
 
   FC_ASSERT( check_enc.result() == check );
 
   return aes_decrypt( key, cipher );
} FC_RETHROW_EXCEPTIONS( warn, "", ("file",file) ) }

Here is the call graph for this function:

aes_save()

void fc::aes_save	(	const fc::path &	file,
		const fc::sha512 &	key,
		std::vector< char >	plain_text )

encrypts plain_text and then includes a checksum that enables us to verify the integrety of the file / key prior to decryption.

Definition at line 331 of file aes.cpp.

{ try {
   auto cipher = aes_encrypt( key, plain_text );
   fc::sha512::encoder check_enc;
   fc::raw::pack( check_enc, key );
   fc::raw::pack( check_enc, cipher );
   auto check = check_enc.result();
 
   std::ofstream out(file.generic_string().c_str());
   fc::raw::pack( out, check );
   fc::raw::pack( out, cipher );
} FC_RETHROW_EXCEPTIONS( warn, "", ("file",file) ) }

Here is the call graph for this function:

alt_bn128_add()

std::variant< alt_bn128_error, bytes > fc::alt_bn128_add	(	const bytes &	op1,
		const bytes &	op2 )

Definition at line 142 of file alt_bn128.cpp.

                                                                                         {
        fc::initLibSnark();
 
        auto maybe_x = decode_g1_element(op1);
        if (std::holds_alternative<alt_bn128_error>(maybe_x)) {
            return std::get<alt_bn128_error>(maybe_x);
        }
 
        auto maybe_y = decode_g1_element(op2);
        if (std::holds_alternative<alt_bn128_error>(maybe_y)) {
            return std::get<alt_bn128_error>(maybe_y);
        }
 
        const auto& x = std::get<libff::alt_bn128_G1>(maybe_x);
        const auto& y = std::get<libff::alt_bn128_G1>(maybe_y);
 
        libff::alt_bn128_G1 g1Sum = x + y;
        return encode_g1_element(g1Sum);
    }

Here is the call graph for this function:

Here is the caller graph for this function:

alt_bn128_mul()

std::variant< alt_bn128_error, bytes > fc::alt_bn128_mul	(	const bytes &	g1_point,
		const bytes &	scalar )

Definition at line 162 of file alt_bn128.cpp.

                                                                                                 {
        initLibSnark();
 
        auto maybe_x = decode_g1_element(g1_point);
        if (std::holds_alternative<alt_bn128_error>(maybe_x)) {
            return std::get<alt_bn128_error>(maybe_x);
        }
 
        auto& x = std::get<libff::alt_bn128_G1>(maybe_x);
 
        if(scalar.size() != 32) {
            return alt_bn128_error::invalid_scalar_size;
        }
 
        Scalar n{to_scalar(scalar)};
 
        libff::alt_bn128_G1 g1Product = n * x;
        return encode_g1_element(g1Product);
    }

Here is the call graph for this function:

Here is the caller graph for this function:

alt_bn128_pair()

std::variant< alt_bn128_error, bool > fc::alt_bn128_pair	(	const bytes &	g1_g2_pairs,
		const yield_function_t &	yield )

Definition at line 184 of file alt_bn128.cpp.

                                                                                                               {
        if (g1_g2_pairs.size() % kSnarkvStride != 0) {
            return alt_bn128_error::pairing_list_size_error;
        }
 
        size_t k{g1_g2_pairs.size() / kSnarkvStride};
 
        initLibSnark();
        using namespace libff;
 
        static const auto one{alt_bn128_Fq12::one()};
        auto accumulator{one};
 
        for (size_t i{0}; i < k; ++i) {
            auto offset = i * kSnarkvStride;
 
            bytes sub1(g1_g2_pairs.begin()+offset, g1_g2_pairs.begin()+offset+64);        
            auto maybe_a = decode_g1_element(sub1);
            if (std::holds_alternative<alt_bn128_error>(maybe_a)) {
                return std::get<alt_bn128_error>(maybe_a);
            }
 
            bytes sub2(g1_g2_pairs.begin()+offset+64, g1_g2_pairs.begin()+offset+64+128);        
            auto maybe_b = decode_g2_element(sub2);
            if (std::holds_alternative<alt_bn128_error>(maybe_b)) {
                return std::get<alt_bn128_error>(maybe_b);
            }
           
            const auto& a = std::get<libff::alt_bn128_G1>(maybe_a);
            const auto& b = std::get<libff::alt_bn128_G2>(maybe_b);
 
            if (a.is_zero() || b.is_zero()) {
                continue;
            }
 
            accumulator = accumulator * alt_bn128_miller_loop(alt_bn128_precompute_G1(a), alt_bn128_precompute_G2(b));
            yield();
        }
 
        bool pair_result = false;
        if (alt_bn128_final_exponentiation(accumulator) == one) {
            pair_result = true;
        }
 
        return pair_result;
    }

Here is the call graph for this function:

Here is the caller graph for this function:

app_path()

const fc::path & fc::app_path

(

)

Returns

the home_path() on Linux, home_path()/Library/Application Support/ on OS X, and APPDATA on windows

Definition at line 503 of file filesystem.cpp.

   {
#ifdef __APPLE__
         static fc::path appdir = [](){  return home_path() / "Library" / "Application Support"; }();
#elif defined( WIN32 )
         static fc::path appdir = [](){
           wchar_t app_data_dir[MAX_PATH];
 
           if (!SUCCEEDED(SHGetFolderPathW(NULL, CSIDL_APPDATA | CSIDL_FLAG_CREATE, NULL, 0, app_data_dir)))
             FC_ASSERT(false, "Unable to get the current AppData directory");
           return fc::path(std::wstring(app_data_dir));
         }();
#else
        static fc::path appdir = home_path() / ".local/share";
#endif
      return appdir;
   }

Here is the call graph for this function:

Here is the caller graph for this function:

arrayFromStream()

template<typename T , json::parse_type parser_type>

variants fc::arrayFromStream	(	T &	in,
		uint32_t	max_depth )

Definition at line 221 of file json.cpp.

   {
      variants ar;
      try
      {
        if( in.peek() != '[' )
           FC_THROW_EXCEPTION( parse_error_exception, "Expected '['" );
        in.get();
        skip_white_space(in);
 
        while( in.peek() != ']' )
        {
           if( in.peek() == ',' )
           {
              in.get();
              continue;
           }
           if( skip_white_space(in) ) continue;
           ar.push_back( variant_from_stream<T, parser_type>( in, max_depth - 1) );
           skip_white_space(in);
        }
        if( in.peek() != ']' )
           FC_THROW_EXCEPTION( parse_error_exception, "Expected ']' after parsing ${variant}",
                                    ("variant", ar) );
 
        in.get();
      } FC_RETHROW_EXCEPTIONS( warn, "Attempting to parse array ${array}",
                                         ("array", ar ) );
      return ar;
   }

Here is the call graph for this function:

Here is the caller graph for this function:

as_type()

template<typename T >

const T & fc::as_type

(

const T &

x

)

Definition at line 46 of file serialization.hpp.

                             {
   return x;
}

Here is the caller graph for this function:

assert_optional()

bool fc::assert_optional

(

bool

is_valid

)

Definition at line 287 of file exception.cpp.

   {
      if( !is_valid )
         throw null_optional();
      return true;
   }

base64_decode()

std::string fc::base64_decode

(

const std::string &

encoded_string

)

Definition at line 152 of file base64.cpp.

                                                         {
   return base64_decode_impl(encoded_string, base64_chars);
}

Here is the call graph for this function:

Here is the caller graph for this function:

base64_decode_impl()

std::string fc::base64_decode_impl	(	std::string const &	encoded_string,
		const char *const	b64_chars )

Definition at line 110 of file base64.cpp.

                                                                                           {
  int in_len = encoded_string.size();
  int i = 0;
  int j = 0;
  int in_ = 0;
  unsigned char char_array_4[4], char_array_3[3];
  std::string ret;
 
  while (in_len-- && encoded_string[in_] != '=') {
    throw_on_nonbase64(encoded_string[in_], b64_chars);
    char_array_4[i++] = encoded_string[in_]; in_++;
    if (i ==4) {
      for (i = 0; i <4; i++)
        char_array_4[i] = strchr(b64_chars, char_array_4[i]) - b64_chars;
 
      char_array_3[0] = (char_array_4[0] << 2) + ((char_array_4[1] & 0x30) >> 4);
      char_array_3[1] = ((char_array_4[1] & 0xf) << 4) + ((char_array_4[2] & 0x3c) >> 2);
      char_array_3[2] = ((char_array_4[2] & 0x3) << 6) + char_array_4[3];
 
      for (i = 0; (i < 3); i++)
        ret += char_array_3[i];
      i = 0;
    }
  }
 
  if (i) {
    for (j = i; j <4; j++)
      char_array_4[j] = 0;
 
    for (j = 0; j <4; j++)
      char_array_4[j] = strchr(b64_chars, char_array_4[j]) - b64_chars;
 
    char_array_3[0] = (char_array_4[0] << 2) + ((char_array_4[1] & 0x30) >> 4);
    char_array_3[1] = ((char_array_4[1] & 0xf) << 4) + ((char_array_4[2] & 0x3c) >> 2);
    char_array_3[2] = ((char_array_4[2] & 0x3) << 6) + char_array_4[3];
 
    for (j = 0; (j < i - 1); j++) ret += char_array_3[j];
  }
 
  return ret;
}

Here is the caller graph for this function:

base64_encode() [1/3]

std::string fc::base64_encode ( char const * bytes_to_encode, unsigned int in_len )

inline

Definition at line 6 of file base64.hpp.

{ return base64_encode( (unsigned char const*)bytes_to_encode, in_len); }

Here is the call graph for this function:

base64_encode() [2/3]

std::string fc::base64_encode

(

const std::string &

enc

)

Definition at line 96 of file base64.cpp.

                                                {
  char const* s = enc.c_str();
  return base64_encode( (unsigned char const*)s, enc.size() );
}

Here is the call graph for this function:

base64_encode() [3/3]

std::string fc::base64_encode	(	unsigned char const *	bytes_to_encode,
		unsigned int	in_len )

Definition at line 92 of file base64.cpp.

                                                                                   {
   return base64_encode_impl(bytes_to_encode, in_len, base64_chars);
}

Here is the call graph for this function:

Here is the caller graph for this function:

base64_encode_impl()

std::string fc::base64_encode_impl	(	unsigned char const *	bytes_to_encode,
		unsigned int	in_len,
		const char *const	b64_chars )

Definition at line 48 of file base64.cpp.

                                                                                                                     {
 
  std::string ret;
  int i = 0;
  int j = 0;
  unsigned char char_array_3[3];
  unsigned char char_array_4[4];
 
  while (in_len--) {
    char_array_3[i++] = *(bytes_to_encode++);
    if (i == 3) {
      char_array_4[0] = (char_array_3[0] & 0xfc) >> 2;
      char_array_4[1] = ((char_array_3[0] & 0x03) << 4) + ((char_array_3[1] & 0xf0) >> 4);
      char_array_4[2] = ((char_array_3[1] & 0x0f) << 2) + ((char_array_3[2] & 0xc0) >> 6);
      char_array_4[3] = char_array_3[2] & 0x3f;
 
      for(i = 0; (i <4) ; i++)
        ret += b64_chars[char_array_4[i]];
      i = 0;
    }
  }
 
  if (i)
  {
    for(j = i; j < 3; j++)
      char_array_3[j] = '\0';
 
    char_array_4[0] = (char_array_3[0] & 0xfc) >> 2;
    char_array_4[1] = ((char_array_3[0] & 0x03) << 4) + ((char_array_3[1] & 0xf0) >> 4);
    char_array_4[2] = ((char_array_3[1] & 0x0f) << 2) + ((char_array_3[2] & 0xc0) >> 6);
    char_array_4[3] = char_array_3[2] & 0x3f;
 
    for (j = 0; (j < i + 1); j++)
      ret += b64_chars[char_array_4[j]];
 
    while((i++ < 3))
      ret += '=';
 
  }
 
  return ret;
 
}

Here is the caller graph for this function:

base64url_decode()

std::string fc::base64url_decode

(

const std::string &

encoded_string

)

Definition at line 156 of file base64.cpp.

                                                            {
   return base64_decode_impl(encoded_string, base64url_chars);
}

Here is the call graph for this function:

Here is the caller graph for this function:

base64url_encode() [1/3]

std::string fc::base64url_encode ( char const * bytes_to_encode, unsigned int in_len )

inline

Definition at line 11 of file base64.hpp.

{ return base64url_encode( (unsigned char const*)bytes_to_encode, in_len); }

Here is the call graph for this function:

base64url_encode() [2/3]

std::string fc::base64url_encode

(

const std::string &

enc

)

Definition at line 105 of file base64.cpp.

                                                   {
  char const* s = enc.c_str();
  return base64url_encode( (unsigned char const*)s, enc.size() );
}

Here is the call graph for this function:

base64url_encode() [3/3]

std::string fc::base64url_encode	(	unsigned char const *	bytes_to_encode,
		unsigned int	in_len )

Definition at line 101 of file base64.cpp.

                                                                                      {
   return base64_encode_impl(bytes_to_encode, in_len, base64url_chars);
}

Here is the call graph for this function:

Here is the caller graph for this function:

blake2b()

std::variant< blake2b_error, bytes > fc::blake2b	(	uint32_t	_rounds,
		const bytes &	_h,
		const bytes &	_m,
		const bytes &	_t0_offset,
		const bytes &	_t1_offset,
		bool	_f,
		const yield_function_t &	yield )

Definition at line 105 of file blake2.cpp.

                                                                                                                                                                                       {
 
    //  EIP-152 [4 bytes for rounds][64 bytes for h][128 bytes for m][8 bytes for t_0][8 bytes for t_1][1 byte for f] : 213
    //          [------------------][64 bytes for h][128 bytes for m][8 bytes for t_0][8 bytes for t_1][------------] : 208
    //  * rounds and final indicator flag are not serialized
    if (_h.size() != 64 || _m.size() != blake2b_wrapper::BLAKE2B_BLOCKBYTES || _t0_offset.size() != 8 || _t1_offset.size() != 8) {
        return blake2b_error::input_len_error;
    }
    
    blake2b_wrapper b2wrapper;
    blake2b_state state{};
    
    memcpy(state.h, _h.data(), 64);
 
    // final indicator flag set words to 1's if true
    state.f[0] = _f ? std::numeric_limits<uint64_t>::max() : 0;
 
    memcpy(&state.t[0], _t0_offset.data(), 8);
    memcpy(&state.t[1], _t1_offset.data(), 8);
 
    uint8_t block[blake2b_wrapper::BLAKE2B_BLOCKBYTES];
    memcpy(block, _m.data(), blake2b_wrapper::BLAKE2B_BLOCKBYTES);
    
    b2wrapper.blake2b_compress(&state, block, _rounds, yield);
 
    bytes out(sizeof(state.h), 0);
    memcpy(&out[0], &state.h[0], out.size());
    return out;
}

Here is the call graph for this function:

Here is the caller graph for this function:

BlockToBytes()

void fc::BlockToBytes ( sblock const & b, unsigned char * p )

inline

Definition at line 425 of file blowfish.cpp.

{
    unsigned int y;
    //Right
    y = b.m_uir;
    *--p = Byte(y);
    y = b.m_uir >> 8;
    *--p = Byte(y);
    y = b.m_uir >> 16;
    *--p = Byte(y);
    y = b.m_uir >> 24;
    *--p = Byte(y);
    //Left
    y = b.m_uil;
    *--p = Byte(y);
    y = b.m_uil >> 8;
    *--p = Byte(y);
    y = b.m_uil >> 16;
    *--p = Byte(y);
    y = b.m_uil >> 24;
    *--p = Byte(y);
}

Here is the call graph for this function:

Here is the caller graph for this function:

Byte()

unsigned char fc::Byte ( unsigned int ui )

inline

Definition at line 14 of file blowfish.cpp.

{
    return (unsigned char)(ui & 0xff);
}

Here is the caller graph for this function:

BytesToBlock()

void fc::BytesToBlock ( unsigned char const * p, sblock & b )

inline

Definition at line 394 of file blowfish.cpp.

{
    unsigned int y;
    //Left
    b.m_uil = 0;
    y = *p++;
    y <<= 24;
    b.m_uil |= y;
    y = *p++;
    y <<= 16;
    b.m_uil |= y;
    y = *p++;
    y <<= 8;
    b.m_uil |= y;
    y = *p++;
    b.m_uil |= y;
    //Right
    b.m_uir = 0;
    y = *p++;
    y <<= 24;
    b.m_uir |= y;
    y = *p++;
    y <<= 16;
    b.m_uir |= y;
    y = *p++;
    y <<= 8;
    b.m_uir |= y;
    y = *p++;
    b.m_uir |= y;
}

Here is the caller graph for this function:

call_fused()

template<typename Functor >

auto fc::call_fused	(	Functor	f,
		const tuple<> &	t ) -> decltype( f( ) )

Definition at line 64 of file tuple.hpp.

                                                                            {
          return f();
        } 

canonical()

fc::path fc::canonical

(

const path &

p

)

Definition at line 357 of file filesystem.cpp.

                                      {
     try {
        return boost::filesystem::canonical(p);
     } catch ( ... ) {
         FC_THROW( "Unable to resolve path '${path}'", ( "path", p )("exception", fc::except_str() ) );
     }
  }

Here is the call graph for this function:

Here is the caller graph for this function:

cap_error_code()

std::optional< uint64_t > fc::cap_error_code ( const std::optional< uint64_t > & error_code )

inline

Definition at line 572 of file serialization.hpp.

                                                                                     {
   std::optional<uint64_t> result;
 
   if (!error_code)
      return result;
 
   const uint64_t upper_limit = static_cast<uint64_t>(sysio::chain::system_error_code::generic_system_error);
 
   if (*error_code >= upper_limit) {
      result = upper_limit;
      return result;
   }
 
   result = error_code;
   return result;
}

check_size()

template<uint64_t RequiredSize, uint64_t ProvidedSize>

void fc::check_size

(

)

Definition at line 58 of file fwd_impl.hpp.

{ static_assert( (ProvidedSize >= RequiredSize), "Failed to reserve enough space in fc::fwd<T,S>" ); }

Here is the caller graph for this function:

check_udt_errors()

void fc::check_udt_errors

(

)

Definition at line 14 of file udt_socket.cpp.

   {
      UDT::ERRORINFO& error_info = UDT::getlasterror();
      if( error_info.getErrorCode() )
      {
         std::string  error_message = error_info.getErrorMessage();
         error_info.clear();
         FC_CAPTURE_AND_THROW( udt_exception, (error_message) );
      }
   }

Here is the caller graph for this function:

chmod()

void fc::chmod	(	const path &	p,
		int	perm )

Definition at line 302 of file filesystem.cpp.

  {
#ifndef WIN32
    mode_t actual_perm =
      ((perm & 0400) ? S_IRUSR : 0)
    | ((perm & 0200) ? S_IWUSR : 0)
    | ((perm & 0100) ? S_IXUSR : 0)
 
    | ((perm & 0040) ? S_IRGRP : 0)
    | ((perm & 0020) ? S_IWGRP : 0)
    | ((perm & 0010) ? S_IXGRP : 0)
 
    | ((perm & 0004) ? S_IROTH : 0)
    | ((perm & 0002) ? S_IWOTH : 0)
    | ((perm & 0001) ? S_IXOTH : 0)
    ;
 
    int result = ::chmod( p.string().c_str(), actual_perm );
    if( result != 0 )
        FC_THROW( "chmod operation failed on ${p}", ("p",p) );
#endif
    return;
  }

Here is the call graph for this function:

Here is the caller graph for this function:

city_hash128()

uint128 fc::city_hash128	(	const char *	s,
		size_t	len )

Definition at line 536 of file city.cpp.

                                                {
  return len >= 16 ?
      CityHash128WithSeed(s + 16, len - 16,
                          uint128(Fetch64(s), Fetch64(s + 8) + k0)) :
      CityHash128WithSeed(s, len, uint128(k0, k1));
}

Here is the call graph for this function:

Here is the caller graph for this function:

city_hash32()

uint32_t fc::city_hash32	(	const char *	buf,
		size_t	len )

Definition at line 217 of file city.cpp.

                                                {
  if (len <= 24) {
    return len <= 12 ?
        (len <= 4 ? Hash32Len0to4(s, len) : Hash32Len5to12(s, len)) :
        Hash32Len13to24(s, len);
  }
 
  // len > 24
  uint32_t h = len, g = c1 * len, f = g;
  uint32_t a0 = Rotate32(Fetch32(s + len - 4) * c1, 17) * c2;
  uint32_t a1 = Rotate32(Fetch32(s + len - 8) * c1, 17) * c2;
  uint32_t a2 = Rotate32(Fetch32(s + len - 16) * c1, 17) * c2;
  uint32_t a3 = Rotate32(Fetch32(s + len - 12) * c1, 17) * c2;
  uint32_t a4 = Rotate32(Fetch32(s + len - 20) * c1, 17) * c2;
  h ^= a0;
  h = Rotate32(h, 19);
  h = h * 5 + 0xe6546b64;
  h ^= a2;
  h = Rotate32(h, 19);
  h = h * 5 + 0xe6546b64;
  g ^= a1;
  g = Rotate32(g, 19);
  g = g * 5 + 0xe6546b64;
  g ^= a3;
  g = Rotate32(g, 19);
  g = g * 5 + 0xe6546b64;
  f += a4;
  f = Rotate32(f, 19);
  f = f * 5 + 0xe6546b64;
  size_t iters = (len - 1) / 20;
  do {
    uint32_t a0 = Rotate32(Fetch32(s) * c1, 17) * c2;
    uint32_t a1 = Fetch32(s + 4);
    uint32_t a2 = Rotate32(Fetch32(s + 8) * c1, 17) * c2;
    uint32_t a3 = Rotate32(Fetch32(s + 12) * c1, 17) * c2;
    uint32_t a4 = Fetch32(s + 16);
    h ^= a0;
    h = Rotate32(h, 18);
    h = h * 5 + 0xe6546b64;
    f += a1;
    f = Rotate32(f, 19);
    f = f * c1;
    g += a2;
    g = Rotate32(g, 18);
    g = g * 5 + 0xe6546b64;
    h ^= a3 + a1;
    h = Rotate32(h, 19);
    h = h * 5 + 0xe6546b64;
    g ^= a4;
    g = bswap_32(g) * 5;
    h += a4 * 5;
    h = bswap_32(h);
    f += a0;
    PERMUTE3(f, h, g);
    s += 20;
  } while (--iters != 0);
  g = Rotate32(g, 11) * c1;
  g = Rotate32(g, 17) * c1;
  f = Rotate32(f, 11) * c1;
  f = Rotate32(f, 17) * c1;
  h = Rotate32(h + g, 19);
  h = h * 5 + 0xe6546b64;
  h = Rotate32(h, 17) * c1;
  h = Rotate32(h + f, 19);
  h = h * 5 + 0xe6546b64;
  h = Rotate32(h, 17) * c1;
  return h;
}

Here is the caller graph for this function:

city_hash64()

uint64_t fc::city_hash64	(	const char *	buf,
		size_t	len )

Definition at line 394 of file city.cpp.

                                                {
  if (len <= 32) {
    if (len <= 16) {
      return HashLen0to16(s, len);
    } else {
      return HashLen17to32(s, len);
    }
  } else if (len <= 64) {
    return HashLen33to64(s, len);
  }
 
  // For strings over 64 bytes we hash the end first, and then as we
  // loop we keep 56 bytes of state: v, w, x, y, and z.
  uint64_t x = Fetch64(s + len - 40);
  uint64_t y = Fetch64(s + len - 16) + Fetch64(s + len - 56);
  uint64_t z = HashLen16(Fetch64(s + len - 48) + len, Fetch64(s + len - 24));
  pair<uint64_t, uint64_t> v = WeakHashLen32WithSeeds(s + len - 64, len, z);
  pair<uint64_t, uint64_t> w = WeakHashLen32WithSeeds(s + len - 32, y + k1, x);
  x = x * k1 + Fetch64(s);
 
  // Decrease len to the nearest multiple of 64, and operate on 64-byte chunks.
  len = (len - 1) & ~static_cast<size_t>(63);
  do {
    x = Rotate(x + y + v.first + Fetch64(s + 8), 37) * k1;
    y = Rotate(y + v.second + Fetch64(s + 48), 42) * k1;
    x ^= w.second;
    y += v.first + Fetch64(s + 40);
    z = Rotate(z + w.first, 33) * k1;
    v = WeakHashLen32WithSeeds(s, v.second * k1, x + w.first);
    w = WeakHashLen32WithSeeds(s + 32, z + w.second, y + Fetch64(s + 16));
    std::swap(z, x);
    s += 64;
    len -= 64;
  } while (len != 0);
  return HashLen16(HashLen16(v.first, w.first) + ShiftMix(y) * k1 + z,
                   HashLen16(v.second, w.second) + x);
}

Here is the call graph for this function:

Here is the caller graph for this function:

city_hash_crc_128()

uint128 fc::city_hash_crc_128	(	const char *	s,
		size_t	len )

Definition at line 671 of file city.cpp.

                                                     {
  if (len <= 900) {
    return city_hash128(s, len);
  } else {
    uint64_t result[4];
    CityHashCrc256(s, len, result);
    return uint128(result[2], result[3]);
  }
}

Here is the call graph for this function:

city_hash_crc_256()

array< uint64_t, 4 > fc::city_hash_crc_256	(	const char *	s,
		size_t	len )

Definition at line 651 of file city.cpp.

{
   array<uint64_t,4> buf;
   CityHashCrc256( s, len, (uint64_t*)&buf );
   return buf;
}

Here is the call graph for this function:

city_hash_crc_64()

uint64_t fc::city_hash_crc_64	(	const char *	buf,
		size_t	len )

city_hash_size_t()

size_t fc::city_hash_size_t ( const char * buf, size_t len )

inline

Definition at line 62 of file city.hpp.

{ return city_hash32(buf, len); }

Here is the call graph for this function:

Here is the caller graph for this function:

CityHash128WithSeed()

uint128 fc::CityHash128WithSeed	(	const char *	s,
		size_t	len,
		uint128	seed )

Definition at line 473 of file city.cpp.

                                                                     {
  if (len < 128) {
    return CityMurmur(s, len, seed);
  }
 
  // We expect len >= 128 to be the common case.  Keep 56 bytes of state:
  // v, w, x, y, and z.
  pair<uint64_t, uint64_t> v, w;
  uint64_t x = Uint128Low64(seed);
  uint64_t y = Uint128High64(seed);
  uint64_t z = len * k1;
  v.first = Rotate(y ^ k1, 49) * k1 + Fetch64(s);
  v.second = Rotate(v.first, 42) * k1 + Fetch64(s + 8);
  w.first = Rotate(y + z, 35) * k1 + x;
  w.second = Rotate(x + Fetch64(s + 88), 53) * k1;
 
  // This is the same inner loop as CityHash64(), manually unrolled.
  do {
    x = Rotate(x + y + v.first + Fetch64(s + 8), 37) * k1;
    y = Rotate(y + v.second + Fetch64(s + 48), 42) * k1;
    x ^= w.second;
    y += v.first + Fetch64(s + 40);
    z = Rotate(z + w.first, 33) * k1;
    v = WeakHashLen32WithSeeds(s, v.second * k1, x + w.first);
    w = WeakHashLen32WithSeeds(s + 32, z + w.second, y + Fetch64(s + 16));
    std::swap(z, x);
    s += 64;
    x = Rotate(x + y + v.first + Fetch64(s + 8), 37) * k1;
    y = Rotate(y + v.second + Fetch64(s + 48), 42) * k1;
    x ^= w.second;
    y += v.first + Fetch64(s + 40);
    z = Rotate(z + w.first, 33) * k1;
    v = WeakHashLen32WithSeeds(s, v.second * k1, x + w.first);
    w = WeakHashLen32WithSeeds(s + 32, z + w.second, y + Fetch64(s + 16));
    std::swap(z, x);
    s += 64;
    len -= 128;
  } while (LIKELY(len >= 128));
  x += Rotate(v.first + z, 49) * k0;
  y = y * k0 + Rotate(w.second, 37);
  z = z * k0 + Rotate(w.first, 27);
  w.first *= 9;
  v.first *= k0;
  // If 0 < len < 128, hash up to 4 chunks of 32 bytes each from the end of s.
  for (size_t tail_done = 0; tail_done < len; ) {
    tail_done += 32;
    y = Rotate(x + y, 42) * k0 + v.second;
    w.first += Fetch64(s + len - tail_done + 16);
    x = x * k0 + w.first;
    z += w.second + Fetch64(s + len - tail_done);
    w.second += v.first;
    v = WeakHashLen32WithSeeds(s + len - tail_done, v.first + z, v.second);
    v.first *= k0;
  }
  // At this point our 56 bytes of state should contain more than
  // enough information for a strong 128-bit hash.  We use two
  // different 56-byte-to-8-byte hashes to get a 16-byte final result.
  x = HashLen16(x, v.first);
  y = HashLen16(y + z, w.first);
  return uint128(HashLen16(x + v.second, w.second) + y,
                 HashLen16(x + w.second, y + v.second));
}

Here is the call graph for this function:

Here is the caller graph for this function:

CityHash64WithSeed()

uint64_t fc::CityHash64WithSeed	(	const char *	s,
		size_t	len,
		uint64_t	seed )

Definition at line 437 of file city.cpp.

                                                                      {
  return CityHash64WithSeeds(s, len, k2, seed);
}

Here is the call graph for this function:

CityHash64WithSeeds()

uint64_t fc::CityHash64WithSeeds	(	const char *	s,
		size_t	len,
		uint64_t	seed0,
		uint64_t	seed1 )

Definition at line 432 of file city.cpp.

                                                           {
  return HashLen16(city_hash64(s, len) - seed0, seed1);
}

Here is the call graph for this function:

Here is the caller graph for this function:

CityHashCrc128WithSeed()

uint128 fc::CityHashCrc128WithSeed	(	const char *	s,
		size_t	len,
		uint128	seed )

Definition at line 658 of file city.cpp.

                                                                        {
  if (len <= 900) {
    return CityHash128WithSeed(s, len, seed);
  } else {
    uint64_t result[4];
    CityHashCrc256(s, len, result);
    uint64_t u = Uint128High64(seed) + result[0];
    uint64_t v = Uint128Low64(seed) + result[1];
    return uint128(HashLen16(u, v + result[2]),
                   HashLen16(Rotate(v, 32), u * k0 + result[3]));
  }
}

Here is the call graph for this function:

CityHashCrc256()

void fc::CityHashCrc256	(	const char *	s,
		size_t	len,
		uint64_t *	result )

Definition at line 643 of file city.cpp.

                                                                 {
  if (LIKELY(len >= 240)) {
    CityHashCrc256Long(s, len, 0, result);
  } else {
    CityHashCrc256Short(s, len, result);
  }
}

Here is the caller graph for this function:

clean_append()

void fc::clean_append	(	string &	app,
		const std::string_view &	s,
		size_t	pos = 0,
		size_t	len = string::npos )

Definition at line 766 of file variant.cpp.

                                                                                                   {
   std::string_view sub = s.substr( pos, len );
   app.reserve( app.size() + sub.size() );
   const bool escape_control_chars = false;
   app += escape_string( sub, nullptr, escape_control_chars );
}

Here is the call graph for this function:

Here is the caller graph for this function:

configure_logging() [1/2]

void fc::configure_logging

(

const fc::path &

log_config

)

Definition at line 52 of file logger_config.cpp.

                                              {
      configure_logging( fc::json::from_file<logging_config>(lc) );
   }

Here is the call graph for this function:

Here is the caller graph for this function:

configure_logging() [2/2]

bool fc::configure_logging

(

const logging_config &

l

)

Definition at line 55 of file logger_config.cpp.

                                                       {
      return log_config::configure_logging( cfg );
   }

Here is the call graph for this function:

const_strlen()

size_t fc::const_strlen ( const char * str )

constexpr

Definition at line 142 of file utility.hpp.

                                                 {
     int i = 0;
     while(*(str+i) != '\0')
        i++;
     return i;
  }

Here is the caller graph for this function:

copy()

void fc::copy	(	const path &	from,
		const path &	to )

Definition at line 249 of file filesystem.cpp.

                                            {
     boost::system::error_code ec;
     try {
        #if BOOST_VERSION > 107300
          if (exists(t)){
            throw boost::system::system_error(boost::system::errc::make_error_code(boost::system::errc::errc_t::file_exists));
          }
          if ( boost::filesystem::is_directory( f ) ) {
            boost::filesystem::copy(boost::filesystem::path(f), 
                                    boost::filesystem::path(t), 
                                    boost::filesystem::copy_options::directories_only, 
                                    ec );
          } else {
            boost::filesystem::copy(boost::filesystem::path(f), 
                                    boost::filesystem::path(t), 
                                    boost::filesystem::copy_options::none, 
                                    ec );
          }
        #else
          boost::filesystem::copy( boost::filesystem::path(f), boost::filesystem::path(t), ec );
        #endif
     } catch ( boost::system::system_error& e ) {
        FC_THROW( "Copy from ${srcfile} to ${dstfile} failed because ${reason}",
             ("srcfile",f)("dstfile",t)("reason",e.what() ) );
     } catch ( ... ) {
        FC_THROW( "Copy from ${srcfile} to ${dstfile} failed",
             ("srcfile",f)("dstfile",t)("inner", fc::except_str() ) );
     }
     if( ec ) {
        FC_THROW( "Copy from ${srcfile} to ${dstfile} failed because ${reason}, category: ${cat}",
              ("srcfile",f)("dstfile",t)("reason", ec.message())("cat", ec.category().name()) );
     }
  }

Here is the call graph for this function:

Here is the caller graph for this function:

copy_append()

template<typename Container >

void fc::copy_append	(	Container &	dest,
		const Container &	src )

Definition at line 162 of file utility.hpp.

                                                           {
    if (src.empty()) {
      return;
    } else {
      dest.insert(std::end(dest), std::begin(src), std::end(src));
    }
  }

copy_exception()

template<typename T >

fc::exception_ptr fc::copy_exception

(

T &&

e

)

Definition at line 198 of file exception.hpp.

   {
#if defined(_MSC_VER) && (_MSC_VER < 1700)
     return std::make_shared<unhandled_exception>( log_message(),
                                                   std::copy_exception(fc::forward<T>(e)) );
#else
     return std::make_shared<unhandled_exception>( log_message(),
                                                   std::make_exception_ptr(fc::forward<T>(e)) );
#endif
   }

Here is the caller graph for this function:

create_directories()

void fc::create_directories

(

const path &

p

)

Definition at line 218 of file filesystem.cpp.

                                           {
    try {
      boost::filesystem::create_directories(p);
    } catch ( ... ) {
      FC_THROW( "Unable to create directories ${path}", ("path", p )("inner", fc::except_str() ) );
    }
  }

Here is the call graph for this function:

Here is the caller graph for this function:

create_hard_link()

void fc::create_hard_link	(	const path &	from,
		const path &	to )

Definition at line 342 of file filesystem.cpp.

                                                        {
     try {
        boost::filesystem::create_hard_link( f, t );
     } catch ( ... ) {
         FC_THROW( "Unable to create hard link from '${from}' to '${to}'",
                          ( "from", f )("to",t)("exception", fc::except_str() ) );
     }
  }

Here is the call graph for this function:

create_zipkin_variant()

fc::variant fc::create_zipkin_variant	(	zipkin_span::span_data &&	span,
		const std::string &	service_name )

Definition at line 121 of file zipkin.cpp.

                                                                                              {
   // https://zipkin.io/zipkin-api/
   //   std::string traceId;  // [a-f0-9]{16,32} unique id for trace, all children spans shared same id
   //   std::string name;     // logical operation, should have low cardinality
   //   std::string parentId; // The parent span id, or absent if root span
   //   std::string id        // a-f0-9]{16}
   //   int64_t     timestamp // epoch microseconds of start of span
   //   int64_t     duration  // microseconds of span
 
   uint64_t trace_id;
   if( span.parent_id != 0 ) {
      trace_id = span.parent_id;
   } else {
      trace_id = span.id;
   }
 
   fc::mutable_variant_object mvo;
   mvo( "id", fc::to_hex( reinterpret_cast<const char*>(&span.id), sizeof( span.id ) ) );
   mvo( "traceId", fc::to_hex( reinterpret_cast<const char*>(&trace_id), sizeof( trace_id ) ) );
   if( span.parent_id != 0 ) {
      mvo( "parentId", fc::to_hex( reinterpret_cast<const char*>(&span.parent_id), sizeof( span.parent_id ) ) );
   }
   mvo( "name", std::move( span.name ) );
   mvo( "timestamp", span.start.time_since_epoch().count() );
   mvo( "duration", (span.stop - span.start).count() );
   mvo( "localEndpoint", fc::variant_object( "serviceName", service_name ) );
 
   mvo( "tags", std::move( span.tags ) );
   span.id = 0; // stop destructor of span from calling log again
 
   // /api/v2/spans takes an array of spans
   fc::variants result;
   result.emplace_back( std::move( mvo ) );
 
   return result;
}

Here is the call graph for this function:

Here is the caller graph for this function:

current_path()

const fc::path & fc::current_path

(

)

Returns

application executable path

Definition at line 521 of file filesystem.cpp.

   {
     static fc::path appCurrentPath = boost::filesystem::current_path();
     return appCurrentPath;
   }

days()

microseconds fc::days ( int64_t d )

inlineconstexpr

Definition at line 36 of file time.hpp.

{ return hours(24*d); }

Here is the call graph for this function:

Here is the caller graph for this function:

decode_fp2_element()

std::variant< alt_bn128_error, libff::alt_bn128_Fq2 > fc::decode_fp2_element ( const bytes & bytes64_be )

noexcept

Definition at line 68 of file alt_bn128.cpp.

                                                                                                         {
        if(bytes64_be.size() != 64) {
            return alt_bn128_error::input_len_error;
        }
 
        // big-endian encoding
        bytes sub1(bytes64_be.begin()+32, bytes64_be.begin()+64);
        bytes sub2(bytes64_be.begin(), bytes64_be.begin()+32);        
 
        Scalar c0{to_scalar(sub1)};
        Scalar c1{to_scalar(sub2)};
 
        if (!valid_element_of_fp(c0) || !valid_element_of_fp(c1)) {
            return alt_bn128_error::operand_component_invalid;
        }
 
        return libff::alt_bn128_Fq2{c0, c1};
    }

Here is the call graph for this function:

Here is the caller graph for this function:

decode_g1_element()

std::variant< alt_bn128_error, libff::alt_bn128_G1 > fc::decode_g1_element ( const bytes & bytes64_be )

noexcept

Definition at line 42 of file alt_bn128.cpp.

                                                                                                       {
        if(bytes64_be.size() != 64) {
            return alt_bn128_error::input_len_error;
        }
    
        bytes sub1(bytes64_be.begin(), bytes64_be.begin()+32);
        bytes sub2(bytes64_be.begin()+32, bytes64_be.begin()+64);
 
        Scalar x{to_scalar(sub1)};
        Scalar y{to_scalar(sub2)};
 
        if (!valid_element_of_fp(x) || !valid_element_of_fp(y)) {
            return alt_bn128_error::operand_component_invalid;
        }
 
        if (x.is_zero() && y.is_zero()) {
            return libff::alt_bn128_G1::zero();
        }
 
        libff::alt_bn128_G1 point{x, y, libff::alt_bn128_Fq::one()};
        if (!point.is_well_formed()) {
            return alt_bn128_error::operand_not_in_curve;
        }
        return point;
    }

Here is the call graph for this function:

Here is the caller graph for this function:

decode_g2_element()

std::variant< alt_bn128_error, libff::alt_bn128_G2 > fc::decode_g2_element ( const bytes & bytes128_be )

noexcept

Definition at line 87 of file alt_bn128.cpp.

                                                                                                        {
        if(bytes128_be.size() != 128) {
            return alt_bn128_error::input_len_error;
        }
 
        bytes sub1(bytes128_be.begin(), bytes128_be.begin()+64);        
        auto maybe_x = decode_fp2_element(sub1);
        if (std::holds_alternative<alt_bn128_error>(maybe_x)) {
            return std::get<alt_bn128_error>(maybe_x);
        }
 
        bytes sub2(bytes128_be.begin()+64, bytes128_be.begin()+128);        
        auto maybe_y = decode_fp2_element(sub2);
        if (std::holds_alternative<alt_bn128_error>(maybe_y)) {
            return std::get<alt_bn128_error>(maybe_y);
        }
 
        const auto& x = std::get<libff::alt_bn128_Fq2>(maybe_x);
        const auto& y = std::get<libff::alt_bn128_Fq2>(maybe_y);
 
        if (x.is_zero() && y.is_zero()) {
            return libff::alt_bn128_G2::zero();
        }
 
        libff::alt_bn128_G2 point{x, y, libff::alt_bn128_Fq2::one()};
        if (!point.is_well_formed()) {
            return alt_bn128_error::operand_not_in_curve;
        }
 
        if (!(libff::alt_bn128_G2::order() * point).is_zero()) {
            // wrong order, doesn't belong to the subgroup G2
            return alt_bn128_error::operand_outside_g2;
        }
 
        return point;
    }

Here is the call graph for this function:

Here is the caller graph for this function:

decodeUtf8()

void fc::decodeUtf8	(	const std::string &	input,
		std::wstring *	storage )

Decodes utf 8 std::string into unicode string.

Parameters

input	- input string to be decoded and stored in 'storage'
storage	- buffer for converted text. Cannot be nullptr.

Definition at line 71 of file utf8.cpp.

   {
     FC_ASSERT(storage != nullptr);
 
     utf8::utf8to32(input.begin(), input.end(), std::back_inserter(*storage));
   }

Here is the call graph for this function:

Here is the caller graph for this function:

deduplicate()

template<typename Container >

void fc::deduplicate

(

Container &

entries

)

Definition at line 171 of file utility.hpp.

                                         {
    if (entries.size() > 1) {
      std::sort( entries.begin(), entries.end() );
      auto itr = std::unique( entries.begin(), entries.end() );
      entries.erase( itr, entries.end() );
    }
  }

default_epool_service()

udt_epoll_service & fc::default_epool_service

(

)

Definition at line 145 of file udt_socket.cpp.

   {
      static udt_epoll_service* default_service = new udt_epoll_service();
      return *default_service;
   }

digest()

template<typename T >

fc::sha256 fc::digest

(

const T &

value

)

Definition at line 9 of file digest.hpp.

   {
      fc::sha256::encoder enc;
      fc::raw::pack( enc, value );
      return enc.result();
   }

Here is the call graph for this function:

Here is the caller graph for this function:

directory_size()

uint64_t fc::directory_size

(

const path &

p

)

Definition at line 229 of file filesystem.cpp.

  {
    try {
      FC_ASSERT( is_directory( p ) );
 
      recursive_directory_iterator end;
      uint64_t size = 0;
      for( recursive_directory_iterator itr( p ); itr != end; ++itr )
      {
        if( is_regular_file( *itr ) )
          size += file_size( *itr );
      }
 
      return size;
    } catch ( ... ) {
      FC_THROW( "Unable to calculate size of directory ${path}", ("path", p )("inner", fc::except_str() ) );
    }
  }

Here is the call graph for this function:

double_to_float64()

void fc::double_to_float64 ( const double & d, float64_t & f )

inline

Definition at line 115 of file database_utils.hpp.

                                                          {
      memcpy(&f, &d, sizeof(f));
   }

Here is the call graph for this function:

Here is the caller graph for this function:

encode_g1_element()

bytes fc::encode_g1_element ( libff::alt_bn128_G1 p )

noexcept

Definition at line 124 of file alt_bn128.cpp.

                                                          {
        bytes out(64, '\0');
        if (p.is_zero()) {
            return out;
        }
 
        p.to_affine_coordinates();
 
        auto x{p.X.as_bigint()};
        auto y{p.Y.as_bigint()};
 
        std::memcpy(&out[0], y.data, 32);
        std::memcpy(&out[32], x.data, 32);
 
        std::reverse(out.begin(), out.end());
        return out;
    }

Here is the caller graph for this function:

encodeUtf8()

void fc::encodeUtf8	(	const std::wstring &	input,
		std::string *	storage )

Encodes given wide (unicode) string into UTF-8 representation.

Parameters

input	- input string to be encoded and stored in 'storage'
storage	- buffer for converted text. Cannot be nullptr.

Definition at line 78 of file utf8.cpp.

   {
     FC_ASSERT(storage != nullptr);
 
     utf8::utf32to8(input.begin(), input.end(), std::back_inserter(*storage));
   }

Here is the call graph for this function:

Here is the caller graph for this function:

endian_reverse_u32()

uint32_t fc::endian_reverse_u32 ( uint32_t x )

inline

Definition at line 19 of file bitutil.hpp.

{
   return (((x >> 0x18) & 0xFF)        )
        | (((x >> 0x10) & 0xFF) << 0x08)
        | (((x >> 0x08) & 0xFF) << 0x10)
        | (((x        ) & 0xFF) << 0x18)
        ;
}

Here is the caller graph for this function:

endian_reverse_u64()

uint64_t fc::endian_reverse_u64 ( uint64_t x )

inline

Definition at line 6 of file bitutil.hpp.

{
   return (((x >> 0x38) & 0xFF)        )
        | (((x >> 0x30) & 0xFF) << 0x08)
        | (((x >> 0x28) & 0xFF) << 0x10)
        | (((x >> 0x20) & 0xFF) << 0x18)
        | (((x >> 0x18) & 0xFF) << 0x20)
        | (((x >> 0x10) & 0xFF) << 0x28)
        | (((x >> 0x08) & 0xFF) << 0x30)
        | (((x        ) & 0xFF) << 0x38)
        ;
}

escape_string()

std::string fc::escape_string	(	const std::string_view &	str,
		const json::yield_function_t &	yield,
		bool	escape_control_chars )

Convert '\t', '\r', '
', '\' and '"' to "\t\r\n\\\"" if escape_control_chars == true Convert all other < 32 & 127 ascii to escaped unicode "\u00xx" Removes invalid utf8 characters Escapes Control sequence Introducer 0x9b to \u009b All other characters unmolested.

Definition at line 495 of file json.cpp.

   {
      string r;
      const auto init_size = str.size();
      r.reserve( init_size + 13 ); // allow for a few escapes
      size_t i = 0;
      for( auto itr = str.begin(); itr != str.end(); ++i,++itr )
      {
         if( i % json::escape_string_yield_check_count == 0 ) yield( init_size + r.size() );
         switch( *itr )
         {
            case '\x00': r += "\\u0000"; break;
            case '\x01': r += "\\u0001"; break;
            case '\x02': r += "\\u0002"; break;
            case '\x03': r += "\\u0003"; break;
            case '\x04': r += "\\u0004"; break;
            case '\x05': r += "\\u0005"; break;
            case '\x06': r += "\\u0006"; break;
            case '\x07': r += "\\u0007"; break; // \a is not valid JSON
            case '\x08': r += "\\u0008"; break; // \b
         // case '\x09': r += "\\u0009"; break; // \t
         // case '\x0a': r += "\\u000a"; break; // \n
            case '\x0b': r += "\\u000b"; break;
            case '\x0c': r += "\\u000c"; break; // \f
         // case '\x0d': r += "\\u000d"; break; // \r
            case '\x0e': r += "\\u000e"; break;
            case '\x0f': r += "\\u000f"; break;
            case '\x10': r += "\\u0010"; break;
            case '\x11': r += "\\u0011"; break;
            case '\x12': r += "\\u0012"; break;
            case '\x13': r += "\\u0013"; break;
            case '\x14': r += "\\u0014"; break;
            case '\x15': r += "\\u0015"; break;
            case '\x16': r += "\\u0016"; break;
            case '\x17': r += "\\u0017"; break;
            case '\x18': r += "\\u0018"; break;
            case '\x19': r += "\\u0019"; break;
            case '\x1a': r += "\\u001a"; break;
            case '\x1b': r += "\\u001b"; break;
            case '\x1c': r += "\\u001c"; break;
            case '\x1d': r += "\\u001d"; break;
            case '\x1e': r += "\\u001e"; break;
            case '\x1f': r += "\\u001f"; break;
 
            case '\x7f': r += "\\u007f"; break;
 
            // if escape_control_chars=true these fall-through to default
            case '\t':        // \x09
               if( escape_control_chars ) {
                  r += "\\t";
                  break;
               }
            case '\n':        // \x0a
               if( escape_control_chars ) {
                  r += "\\n";
                  break;
               }
            case '\r':        // \x0d
               if( escape_control_chars ) {
                  r += "\\r";
                  break;
               }
            case '\\':
               if( escape_control_chars ) {
                  r += "\\\\";
                  break;
               }
            case '\"':
               if( escape_control_chars ) {
                  r += "\\\"";
                  break;
               }
            default:
               r += *itr;
         }
      }
 
      return is_valid_utf8( r ) ? r : prune_invalid_utf8( r );
   }

Here is the call graph for this function:

Here is the caller graph for this function:

except_str()

fc::string fc::except_str

(

)

Definition at line 269 of file exception.cpp.

   {
       return boost::current_exception_diagnostic_information();
   }

Here is the caller graph for this function:

exists()

bool fc::exists

(

const path &

p

)

Definition at line 217 of file filesystem.cpp.

{ return boost::filesystem::exists(p); }

Here is the caller graph for this function:

FC_DECLARE_EXCEPTION() [1/18]

fc::FC_DECLARE_EXCEPTION	(	aes_exception	,
		aes_error_code	,
		"AES error"	)

FC_DECLARE_EXCEPTION() [2/18]

fc::FC_DECLARE_EXCEPTION	(	assert_exception	,
		assert_exception_code	,
		"Assert Exception"	)

FC_DECLARE_EXCEPTION() [3/18]

fc::FC_DECLARE_EXCEPTION	(	bad_cast_exception	,
		bad_cast_exception_code	,
		"Bad Cast"	)

FC_DECLARE_EXCEPTION() [4/18]

fc::FC_DECLARE_EXCEPTION	(	canceled_exception	,
		canceled_exception_code	,
		"Canceled"	)

FC_DECLARE_EXCEPTION() [5/18]

fc::FC_DECLARE_EXCEPTION	(	divide_by_zero_exception	,
		divide_by_zero_code	,
		"Integer Divide By Zero"	)

FC_DECLARE_EXCEPTION() [6/18]

fc::FC_DECLARE_EXCEPTION	(	eof_exception	,
		eof_exception_code	,
		"End Of File"	)

FC_DECLARE_EXCEPTION() [7/18]

fc::FC_DECLARE_EXCEPTION	(	file_not_found_exception	,
		file_not_found_exception_code	,
		"File Not Found"	)

FC_DECLARE_EXCEPTION() [8/18]

fc::FC_DECLARE_EXCEPTION	(	invalid_arg_exception	,
		invalid_arg_exception_code	,
		"Invalid Argument"	)

FC_DECLARE_EXCEPTION() [9/18]

fc::FC_DECLARE_EXCEPTION	(	invalid_operation_exception	,
		invalid_operation_exception_code	,
		"Invalid Operation"	)

FC_DECLARE_EXCEPTION() [10/18]

fc::FC_DECLARE_EXCEPTION	(	key_not_found_exception	,
		key_not_found_exception_code	,
		"Key Not Found"	)

FC_DECLARE_EXCEPTION() [11/18]

fc::FC_DECLARE_EXCEPTION	(	null_optional	,
		null_optional_code	,
		"null optional"	)

FC_DECLARE_EXCEPTION() [12/18]

fc::FC_DECLARE_EXCEPTION	(	out_of_range_exception	,
		out_of_range_exception_code	,
		"Out of Range"	)

FC_DECLARE_EXCEPTION() [13/18]

fc::FC_DECLARE_EXCEPTION	(	overflow_exception	,
		overflow_code	,
		"Integer Overflow"	)

FC_DECLARE_EXCEPTION() [14/18]

fc::FC_DECLARE_EXCEPTION	(	parse_error_exception	,
		parse_error_exception_code	,
		"Parse Error"	)

FC_DECLARE_EXCEPTION() [15/18]

fc::FC_DECLARE_EXCEPTION	(	timeout_exception	,
		timeout_exception_code	,
		"Timeout"	)

FC_DECLARE_EXCEPTION() [16/18]

fc::FC_DECLARE_EXCEPTION	(	udt_exception	,
		udt_error_code	,
		"UDT error"	)

FC_DECLARE_EXCEPTION() [17/18]

fc::FC_DECLARE_EXCEPTION	(	underflow_exception	,
		underflow_code	,
		"Integer Underflow"	)

FC_DECLARE_EXCEPTION() [18/18]

fc::FC_DECLARE_EXCEPTION	(	unknown_host_exception	,
		unknown_host_exception_code	,
		"Unknown Host"	)

file_size()

uint64_t fc::file_size

(

const path &

p

)

Definition at line 227 of file filesystem.cpp.

{ return boost::filesystem::file_size(p); }

Here is the caller graph for this function:

find_executable_in_path()

fc::path fc::find_executable_in_path

(

const fc::string

name

)

Definition at line 15 of file process.cpp.

                                                      {
  try {
    return fc::string(bp::find_executable_in_path( std::string(name), "" ));
  } catch (...) {
    const char* p = std::getenv("PATH");
    FC_THROW( "Unable to find executable ${exe} in path.", 
      ("exe", name)
      ("inner", fc::except_str() )
      ("PATH", fc::string(p!=nullptr?p:"") ) );
  }
  return fc::path();
}

Here is the call graph for this function:

find_invalid()

template<typename octet_iterator >

std::pair< octet_iterator, uint32_t > fc::find_invalid	(	octet_iterator	start,
		octet_iterator	end,
		const std::pair< uint32_t, uint32_t > &	invalid_range )

Definition at line 22 of file utf8.cpp.

   {
      FC_ASSERT( invalid_range.first <= invalid_range.second );
      octet_iterator result = start;
      uint32_t value = UINT32_MAX;
      while( result != end ) {
         octet_iterator itr = result;
         utf8::internal::utf_error err_code = utf8::internal::validate_next( result, end, value );
         if( err_code != utf8::internal::UTF8_OK )
            return {result, UINT32_MAX};
         if( value >= invalid_range.first && value <= invalid_range.second )
            return {itr, value};
      }
      return {result, UINT32_MAX};
   }

Here is the call graph for this function:

Here is the caller graph for this function:

fixed_size()

string fc::fixed_size	(	size_t	s,
		const string &	str )

Definition at line 85 of file console_appender.cpp.

                                                    {
      if( str.size() == s ) return str;
      if( str.size() > s ) return str.substr( 0, s );
      string tmp = str;
      tmp.append( s - str.size(), ' ' );
      return tmp;
   }

Here is the caller graph for this function:

float128_to_uint128()

void fc::float128_to_uint128 ( const float128_t & f, sysio::chain::uint128_t & u )

inline

Definition at line 120 of file database_utils.hpp.

                                                                          {
      memcpy(&u, &f, sizeof(u));
   }

Here is the call graph for this function:

Here is the caller graph for this function:

float64_to_double()

void fc::float64_to_double ( const float64_t & f, double & d )

inline

Definition at line 110 of file database_utils.hpp.

                                                          {
      memcpy(&d, &f, sizeof(d));
   }

Here is the call graph for this function:

Here is the caller graph for this function:

format_string()

string fc::format_string	(	const fc::string &	frmt,
		const variant_object &	args,
		bool	minimize = false )

Definition at line 773 of file variant.cpp.

{
   std::string result;
   const string& format = ( minimize && frmt.size() > minimize_max_size ) ?
         frmt.substr( 0, minimize_max_size ) + "..." : frmt;
 
   const auto arg_num = (args.size() == 0) ? 1 : args.size();
   const auto max_format_size = std::max(minimize_max_size, format.size());
   // limit each arg size when minimize is set
   const auto minimize_sub_max_size = minimize ? ( max_format_size - format.size() ) / arg_num :  minimize_max_size;
   // reserve space for each argument replaced by ...
   result.reserve( max_format_size + 3 * args.size());
   size_t prev = 0;
   size_t next = format.find( '$' );
   while( prev != string::npos && prev < format.size() ) {
      if( next != string::npos ) {
         clean_append( result, format, prev, next - prev );
      } else {
         clean_append( result, format, prev );
      }
 
      // if we got to the end, return it.
      if( next == string::npos ) {
         return result;
      } else if( minimize && result.size() > minimize_max_size ) {
         result += "...";
         return result;
      }
 
      // if we are not at the end, then update the start
      prev = next + 1;
 
      if( format[prev] == '{' ) {
         // if the next char is a open, then find close
         next = format.find( '}', prev );
         // if we found close...
         if( next != string::npos ) {
            // the key is between prev and next
            string key = format.substr( prev + 1, (next - prev - 1) );
 
            auto val = args.find( key );
            bool replaced = true;
            if( val != args.end() ) {
               if( val->value().is_object() || val->value().is_array() ) {
                  if( minimize && (result.size() >= minimize_max_size)) {
                     replaced = false;
                  } else {
                     const auto max_length = minimize ? minimize_sub_max_size : std::numeric_limits<uint64_t>::max();
                     try {
                        // clean_append not needed as to_string is valid utf8
                        result += json::to_string( val->value(), fc::time_point::maximum(),
                                                   json::output_formatting::stringify_large_ints_and_doubles, max_length );
                     } catch (...) {
                        replaced = false;
                     }
                  }
               } else if( val->value().is_blob() ) {
                  if( minimize && val->value().get_blob().data.size() > minimize_sub_max_size ) {
                     replaced = false;
                  } else {
                     clean_append( result, val->value().as_string() );
                  }
               } else if( val->value().is_string() ) {
                  if( minimize && val->value().get_string().size() > minimize_sub_max_size ) {
                     auto sz = std::min( minimize_sub_max_size, minimize_max_size - result.size() );
                     clean_append( result, val->value().get_string(), 0, sz );
                     result += "...";
                  } else {
                     clean_append( result, val->value().get_string() );
                  }
               } else {
                  clean_append( result, val->value().as_string() );
               }
            } else {
               replaced = false;
            }
            if( !replaced ) {
               result += "${";
               clean_append( result, key );
               result += "}";
            }
            prev = next + 1;
            // find the next $
            next = format.find( '$', prev );
         } else {
            // we didn't find it.. continue to while...
         }
      } else {
         clean_append( result, format, prev, 1 );
         ++prev;
         next = format.find( '$', prev );
      }
   }
   return result;
}

Here is the call graph for this function:

Here is the caller graph for this function:

from_base32()

std::vector< char > fc::from_base32

(

const fc::string &

b32

)

Definition at line 6 of file base32.cpp.

    {
       auto len = cyoBase32DecodeGetLength( b32.size() );
       std::vector<char> v(len);
       len = cyoBase32Decode( v.data(), b32.c_str(), b32.size() );
       v.resize( len );
       return v;
    }

from_base36()

std::vector< char > fc::from_base36

(

const fc::string &

b36

)

Definition at line 45 of file base36.cpp.

    {
        if ( b36.empty() ) {
           std::vector<char> empty;
           return empty;
        }
 
       fc::bigint value;
 
       fc::bigint pos = 0; 
       fc::bigint _36(36);
       for( auto itr = b36.rbegin(); itr != b36.rend(); ++itr )
       {
          if( *itr >= '0' && *itr <= '9' )
              value = value +  _36.exp(pos) * fc::bigint(*itr - '0');
          else if( *itr >= 'a' && *itr <= 'z' )
              value = value + (_36.exp(pos) *  fc::bigint(10+*itr - 'a'));
          else if( *itr >= 'A' && *itr <= 'Z' )
              value = value + (_36.exp(pos) *  fc::bigint(10+*itr - 'A'));
          else
          {
             wlog("unknown '${char}'", ("char",fc::string(&*itr,1)) );
          }
          ++pos;
       }
 
       std::vector<char> bytes = value;
       int leading_zeros = 0, len = bytes.size();
       const char *in = b36.c_str();
       while (*in++ == '0') { leading_zeros++; }
       char* first = bytes.data();
       while (len > 0 && *first == 0) { first++; len--; }
       std::vector<char> result;
       result.resize(leading_zeros + len, 0);
       memcpy( result.data() + leading_zeros, first, len );
       return result;
    }

Here is the call graph for this function:

from_base58() [1/2]

std::vector< char > fc::from_base58

(

const std::string &

base58_str

)

Definition at line 628 of file base58.cpp.

                                                           {
   std::vector<unsigned char> out;
   if( !DecodeBase58( base58_str.c_str(), out ) ) {
     FC_THROW_EXCEPTION( parse_error_exception, "Unable to decode base58 string ${base58_str}", ("base58_str",base58_str) );
   }
   return std::vector<char>((const char*)out.data(), ((const char*)out.data())+out.size() );
}

Here is the call graph for this function:

Here is the caller graph for this function:

from_base58() [2/2]

size_t fc::from_base58	(	const std::string &	base58_str,
		char *	out_data,
		size_t	out_data_len )

Returns

the number of bytes decoded

Definition at line 638 of file base58.cpp.

                                                                                       {
  //slog( "%s", base58_str.c_str() );
  std::vector<unsigned char> out;
  if( !DecodeBase58( base58_str.c_str(), out ) ) {
    FC_THROW_EXCEPTION( parse_error_exception, "Unable to decode base58 string ${base58_str}", ("base58_str",base58_str) );
  }
  FC_ASSERT( out.size() <= out_data_len );
  memcpy( out_data, out.data(), out.size() );
  return out.size();
}

Here is the call graph for this function:

from_hex() [1/2]

uint8_t fc::from_hex

(

char

c

)

Definition at line 6 of file hex.cpp.

                               {
      if( c >= '0' && c <= '9' )
        return c - '0';
      if( c >= 'a' && c <= 'f' )
          return c - 'a' + 10;
      if( c >= 'A' && c <= 'F' )
          return c - 'A' + 10;
      FC_THROW_EXCEPTION( exception, "Invalid hex character '${c}'", ("c", fc::string(&c,1) ) );
      return 0;
    }

Here is the caller graph for this function:

from_hex() [2/2]

size_t fc::from_hex	(	const fc::string &	hex_str,
		char *	out_data,
		size_t	out_data_len )

Returns

the number of bytes decoded

Definition at line 27 of file hex.cpp.

                                                                                    {
        fc::string::const_iterator i = hex_str.begin();
        uint8_t* out_pos = (uint8_t*)out_data;
        uint8_t* out_end = out_pos + out_data_len;
        while( i != hex_str.end() && out_end != out_pos ) {
          *out_pos = from_hex( *i ) << 4;   
          ++i;
          if( i != hex_str.end() )  {
              *out_pos |= from_hex( *i );
              ++i;
          }
          ++out_pos;
        }
        return out_pos - (uint8_t*)out_data;
    }

Here is the call graph for this function:

from_index()

template<typename variant , int32_t i = 0>

void fc::from_index	(	variant &	v,
		int	index )

Definition at line 15 of file static_variant.hpp.

{
  if constexpr(i >= std::variant_size_v<variant>)
  {
    FC_THROW_EXCEPTION(fc::assert_exception, "Provided index out of range for variant.");
  }
  else if (index == 0)
  {
     auto value = variant(std::in_place_index<i>);
     v = std::move(value); 
  }
  else
  {
     from_index<variant, i + 1>(v, index - 1);
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

from_variant() [1/103]

void fc::from_variant	(	const fc::variant &	input_variant,
		fc::microseconds &	output_microseconds )

Definition at line 164 of file time.cpp.

  {
    output_microseconds = microseconds(input_variant.as_int64());
  }

Here is the call graph for this function:

from_variant() [2/103]

void fc::from_variant	(	const fc::variant &	variant_to_convert,
		fc::path &	path_output )

Definition at line 43 of file filesystem.cpp.

  {
    std::wstring wide_string;
    fc::decodeUtf8(variant_to_convert.as_string(), &wide_string);
    path_output = path(wide_string);
  }

Here is the call graph for this function:

from_variant() [3/103]

template<typename T , typename... U>

void fc::from_variant	(	const fc::variant &	v,
		bip::multiset< T, U... > &	s )

Definition at line 75 of file container.hpp.

                                                                      {
      detail::from_variant_to_set( v, s );
   }

Here is the call graph for this function:

from_variant() [4/103]

template<typename T , typename... U>

void fc::from_variant	(	const fc::variant &	v,
		bip::set< T, U... > &	s )

Definition at line 65 of file container.hpp.

                                                                 {
      detail::from_variant_to_set( v, s );
   }

Here is the call graph for this function:

from_variant() [5/103]

template<typename T , typename... U>

void fc::from_variant	(	const fc::variant &	v,
		boost::container::deque< T, U... > &	d )

Definition at line 529 of file variant.hpp.

   {
      const variants& vars = v.get_array();
      if( vars.size() > MAX_NUM_ARRAY_ELEMENTS ) throw std::range_error( "too large" );
      d.clear();
      d.resize( vars.size() );
      for( uint32_t i = 0; i < vars.size(); ++i ) {
         from_variant( vars[i], d[i] );
      }
   }

Here is the call graph for this function:

from_variant() [6/103]

template<typename... U>

void fc::from_variant	(	const fc::variant &	v,
		boost::container::vector< char, U... > &	vec )

Definition at line 135 of file flat.hpp.

   {
      const auto& str = v.get_string();
      FC_ASSERT( str.size() <= 2*MAX_SIZE_OF_BYTE_ARRAYS ); // Doubled because hex strings needs two characters per byte
      vec.resize( str.size() / 2 );
      if( vec.size() ) {
         size_t r = fc::from_hex( str, vec.data(), vec.size() );
         FC_ASSERT( r == vec.size() );
      }
   }

Here is the call graph for this function:

from_variant() [7/103]

template<typename T , typename... U>

void fc::from_variant	(	const fc::variant &	v,
		boost::container::vector< T, U... > &	vec )

Definition at line 115 of file flat.hpp.

                                                                               {
      const variants& vars = v.get_array();
      FC_ASSERT( vars.size() <= MAX_NUM_ARRAY_ELEMENTS );
      vec.clear();
      vec.resize( vars.size() );
      for( uint32_t i = 0; i < vars.size(); ++i ) {
         from_variant( vars[i], vec[i] );
      }
   }

Here is the call graph for this function:

from_variant() [8/103]

template<typename T , typename... Args>

void fc::from_variant	(	const fc::variant &	v,
		boost::multi_index_container< T, Args... > &	s )

Definition at line 683 of file variant.hpp.

   {
      const variants& vars = v.get_array();
      c.clear();
      for( const auto& item : vars )
         c.insert( item.as<T>() );
   }

Here is the call graph for this function:

from_variant() [9/103]

template<typename T >

void fc::from_variant	(	const fc::variant &	v,
		boost::multiprecision::number< T > &	n )

Definition at line 693 of file variant.hpp.

                                                                                                 {
      n = boost::multiprecision::number<T>(v.get_string());
   }

Here is the call graph for this function:

from_variant() [10/103]

template<typename T , typename... U>

void fc::from_variant	(	const fc::variant &	v,
		flat_multiset< T, U... > &	s )

Definition at line 162 of file flat.hpp.

                                                                        {
      detail::from_variant_to_flat_set( v, s );
   }

Here is the call graph for this function:

from_variant() [11/103]

template<typename T , typename... U>

void fc::from_variant	(	const fc::variant &	v,
		flat_set< T, U... > &	s )

Definition at line 152 of file flat.hpp.

                                                                   {
      detail::from_variant_to_flat_set( v, s );
   }

Here is the call graph for this function:

from_variant() [12/103]

void fc::from_variant ( const fc::variant & v, params::permission_level & a )

inline

Overloaded from_variant to allow parsing an account with a permission wildcard (empty) from a string instead of an object

Parameters

v
a

Definition at line 113 of file account_query_db.hpp.

                                                                           {
      if (v.is_string()) {
         from_variant(v, a.actor);
         a.permission = {};
      } else if (v.is_object()) {
         const auto& vo = v.get_object();
         if(vo.contains("actor"))
            from_variant(vo["actor"], a.actor);
         else
            SYS_THROW(sysio::chain::invalid_http_request, "Missing Actor field");
 
         if(vo.contains("permission") && vo.size() == 2)
            from_variant(vo["permission"], a.permission);
         else if (vo.size() == 1)
            a.permission = {};
         else
            SYS_THROW(sysio::chain::invalid_http_request, "Unrecognized fields in account");
      }
   }

Here is the call graph for this function:

from_variant() [13/103]

template<typename T >

void fc::from_variant	(	const fc::variant &	v,
		safe< T > &	s )

Definition at line 672 of file variant.hpp.

{ s.value = v.as_uint64(); }

Here is the call graph for this function:

from_variant() [14/103]

template<typename A , typename B >

void fc::from_variant	(	const fc::variant &	v,
		std::pair< A, B > &	p )

Definition at line 606 of file variant.hpp.

   {
      const variants& vars = v.get_array();
      if( vars.size() > 0 )
         vars[0].as<A>( p.first );
      if( vars.size() > 1 )
         vars[1].as<B>( p.second );
   }

Here is the call graph for this function:

from_variant() [15/103]

template<typename T >

void fc::from_variant	(	const fc::variant &	v,
		std::unique_ptr< T > &	s )

Definition at line 657 of file variant.hpp.

   {
      if( var.is_null() ) vo.reset();
      else if( vo ) from_variant( var, *vo );
      else {
          vo.reset( new T() );
          from_variant( var, *vo );
      }
   }

Here is the call graph for this function:

from_variant() [16/103]

template<typename... T>

void fc::from_variant	(	const fc::variant &	v,
		std::variant< T... > &	s )

Definition at line 79 of file static_variant.hpp.

{
  auto ar = v.get_array();
  if( ar.size() < 2 )
  {
    s = std::variant<T...>();
    return;
  }
  from_index(s, ar[0].as_uint64());
  std::visit( to_static_variant(ar[1]), s );
}

Here is the call graph for this function:

from_variant() [17/103]

template<uint16_t IntervalMs, uint64_t EpochMs>

void fc::from_variant	(	const fc::variant &	v,
		sysio::chain::block_timestamp< IntervalMs, EpochMs > &	t )

Definition at line 90 of file block_timestamp.hpp.

                                                                                          {
     t = v.as<fc::time_point>();
  }

Here is the call graph for this function:

from_variant() [18/103]

void fc::from_variant	(	const fc::variant &	v,
		sysio::chain::chain_id_type &	cid )

Definition at line 18 of file chain_id_type.cpp.

                                                                       {
      from_variant( v, static_cast<fc::sha256&>(cid) );
   }

Here is the call graph for this function:

Here is the caller graph for this function:

from_variant() [19/103]

template<typename T >

void fc::from_variant	(	const fc::variant &	v,
		sysio::chain::may_not_exist< T > &	e )

Definition at line 164 of file abi_def.hpp.

                                                                     {
   from_variant( v, e.value );
}

Here is the call graph for this function:

from_variant() [20/103]

void fc::from_variant	(	const fc::variant &	v,
		sysio::chain::name &	check )

Definition at line 39 of file name.cpp.

{ check.set( v.get_string() ); }

Here is the call graph for this function:

from_variant() [21/103]

void fc::from_variant	(	const fc::variant &	v,
		UInt< 16 > &	n )

Definition at line 754 of file variant.cpp.

{ n = static_cast<uint16_t>(v.as_uint64()); }

Here is the call graph for this function:

from_variant() [22/103]

void fc::from_variant	(	const fc::variant &	v,
		UInt< 32 > &	n )

Definition at line 758 of file variant.cpp.

{ n = static_cast<uint32_t>(v.as_uint64()); }

Here is the call graph for this function:

from_variant() [23/103]

void fc::from_variant	(	const fc::variant &	v,
		UInt< 64 > &	n )

Definition at line 761 of file variant.cpp.

{ n = v.as_uint64(); }

Here is the call graph for this function:

from_variant() [24/103]

void fc::from_variant	(	const fc::variant &	v,
		UInt< 8 > &	n )

Definition at line 750 of file variant.cpp.

{ n = static_cast<uint8_t>(v.as_uint64()); }

Here is the call graph for this function:

from_variant() [25/103]

void fc::from_variant	(	const fc::variant &	v,
		url &	u )

Definition at line 85 of file url.cpp.

  {
    u  = url( v.as_string() ); 
  }

Here is the call graph for this function:

from_variant() [26/103]

void fc::from_variant	(	const fc::variant &	var,
		__int128 &	vo )

Definition at line 683 of file variant.cpp.

{
   if( var.is_int64() ) {
      vo = var.as_int64();
   } else if( var.is_string() ) {
      vo = static_cast<__int128>( boost::multiprecision::int128_t(var.as_string()) );
   } else {
      FC_THROW_EXCEPTION( bad_cast_exception, "Cannot convert variant of type '${type}' into a int128_t", ("type", var.get_type()) );
   }
}

Here is the call graph for this function:

from_variant() [27/103]

void fc::from_variant	(	const fc::variant &	var,
		bool &	vo )

Definition at line 704 of file variant.cpp.

{
   vo = var.as_bool();
}

Here is the call graph for this function:

from_variant() [28/103]

void fc::from_variant	(	const fc::variant &	var,
		double &	vo )

Definition at line 709 of file variant.cpp.

{
   vo = var.as_double();
}

Here is the call graph for this function:

from_variant() [29/103]

void fc::from_variant	(	const fc::variant &	var,
		fc::variant &	vo )

Definition at line 631 of file variant.cpp.

{ vo = var; }

from_variant() [30/103]

void fc::from_variant	(	const fc::variant &	var,
		fc::variants &	vo )

Definition at line 621 of file variant.cpp.

{
   vo = var.get_array();
}

Here is the call graph for this function:

from_variant() [31/103]

void fc::from_variant	(	const fc::variant &	var,
		float &	vo )

Definition at line 714 of file variant.cpp.

{
   vo = static_cast<float>(var.as_double());
}

Here is the call graph for this function:

from_variant() [32/103]

void fc::from_variant	(	const fc::variant &	var,
		int16_t &	vo )

Definition at line 647 of file variant.cpp.

{ vo = static_cast<int16_t>(var.as_int64()); }

Here is the call graph for this function:

from_variant() [33/103]

void fc::from_variant	(	const fc::variant &	var,
		int32_t &	vo )

Definition at line 659 of file variant.cpp.

{
   vo = static_cast<int32_t>(var.as_int64());
}

Here is the call graph for this function:

from_variant() [34/103]

void fc::from_variant	(	const fc::variant &	var,
		int64_t &	vo )

Definition at line 694 of file variant.cpp.

{
   vo = var.as_int64();
}

Here is the call graph for this function:

from_variant() [35/103]

void fc::from_variant	(	const fc::variant &	var,
		int8_t &	vo )

Definition at line 639 of file variant.cpp.

{ vo = static_cast<int8_t>(var.as_int64()); }

Here is the call graph for this function:

from_variant() [36/103]

void fc::from_variant	(	const fc::variant &	var,
		mutable_variant_object &	vo )

Definition at line 419 of file variant_object.cpp.

   {
      vo = var.get_object();
   }

Here is the call graph for this function:

from_variant() [37/103]

template<typename T , std::size_t S>

void fc::from_variant	(	const fc::variant &	var,
		std::array< T, S > &	vo )

Definition at line 577 of file variant.hpp.

   {
      const variants& vars = var.get_array();
      for( std::size_t i = 0; i < S; ++i )
         tmp[i] = vars.at(i).as<T>();
   }

Here is the call graph for this function:

from_variant() [38/103]

template<typename T >

void fc::from_variant	(	const fc::variant &	var,
		std::deque< T > &	vo )

Definition at line 507 of file variant.hpp.

   {
      const variants& vars = var.get_array();
      if( vars.size() > MAX_NUM_ARRAY_ELEMENTS ) throw std::range_error( "too large" );
      tmp.clear();
      for( auto itr = vars.begin(); itr != vars.end(); ++itr )
         tmp.push_back( itr->as<T>() );
   }

Here is the call graph for this function:

from_variant() [39/103]

template<typename K , typename T >

void fc::from_variant	(	const fc::variant &	var,
		std::map< K, T > &	vo )

Definition at line 454 of file variant.hpp.

   {
      const variants& vars = var.get_array();
      if( vars.size() > MAX_NUM_ARRAY_ELEMENTS ) throw std::range_error( "too large" );
      vo.clear();
      for( auto itr = vars.begin(); itr != vars.end(); ++itr )
         vo.insert( itr->as< std::pair<K,T> >() );
   }

Here is the call graph for this function:

from_variant() [40/103]

template<typename K , typename T >

void fc::from_variant	(	const fc::variant &	var,
		std::multimap< K, T > &	vo )

Definition at line 474 of file variant.hpp.

   {
      const variants& vars = var.get_array();
      if( vars.size() > MAX_NUM_ARRAY_ELEMENTS ) throw std::range_error( "too large" );
      vo.clear();
      for( auto itr = vars.begin(); itr != vars.end(); ++itr )
         vo.insert( itr->as< std::pair<K,T> >() );
   }

Here is the call graph for this function:

from_variant() [41/103]

template<typename T >

void fc::from_variant	(	const fc::variant &	var,
		std::set< T > &	vo )

Definition at line 495 of file variant.hpp.

   {
      const variants& vars = var.get_array();
      if( vars.size() > MAX_NUM_ARRAY_ELEMENTS ) throw std::range_error( "too large" );
      vo.clear();
      //vo.reserve( vars.size() );
      for( auto itr = vars.begin(); itr != vars.end(); ++itr )
         vo.insert( itr->as<T>() );
   }

Here is the call graph for this function:

from_variant() [42/103]

template<typename T >

void fc::from_variant	(	const fc::variant &	var,
		std::shared_ptr< T > &	vo )

Definition at line 640 of file variant.hpp.

   {
      if( var.is_null() ) vo = nullptr;
      else if( vo ) from_variant( var, *vo );
      else {
          vo = std::make_shared<T>();
          from_variant( var, *vo );
      }
   }

Here is the call graph for this function:

from_variant() [43/103]

template<typename K , typename T >

void fc::from_variant	(	const fc::variant &	var,
		std::unordered_map< K, T > &	vo )

Definition at line 434 of file variant.hpp.

   {
      const variants& vars = var.get_array();
      if( vars.size() > MAX_NUM_ARRAY_ELEMENTS ) throw std::range_error( "too large" );
      vo.clear();
      for( auto itr = vars.begin(); itr != vars.end(); ++itr )
         vo.insert( itr->as< std::pair<K,T> >() );
 
   }

Here is the call graph for this function:

from_variant() [44/103]

template<typename T >

void fc::from_variant	(	const fc::variant &	var,
		std::unordered_set< T > &	vo )

Definition at line 412 of file variant.hpp.

   {
      const variants& vars = var.get_array();
      if( vars.size() > MAX_NUM_ARRAY_ELEMENTS ) throw std::range_error( "too large" );
      vo.clear();
      vo.reserve( vars.size() );
      for( auto itr = vars.begin(); itr != vars.end(); ++itr )
         vo.insert( itr->as<T>() );
   }

Here is the call graph for this function:

from_variant() [45/103]

void fc::from_variant	(	const fc::variant &	var,
		std::vector< char > &	vo )

Definition at line 736 of file variant.cpp.

{
   const auto& str = var.get_string();
   FC_ASSERT( str.size() <= 2*MAX_SIZE_OF_BYTE_ARRAYS ); // Doubled because hex strings needs two characters per byte
   FC_ASSERT( str.size() % 2 == 0, "the length of hex string should be even number" );
   vo.resize( str.size() / 2 );
   if( vo.size() ) {
      size_t r = from_hex( str, vo.data(), vo.size() );
      FC_ASSERT( r == vo.size() );
   }
}

Here is the call graph for this function:

from_variant() [46/103]

template<typename T >

void fc::from_variant	(	const fc::variant &	var,
		std::vector< T > &	tmp )

Definition at line 554 of file variant.hpp.

   {
      const variants& vars = var.get_array();
      if( vars.size() > MAX_NUM_ARRAY_ELEMENTS ) throw std::range_error( "too large" );
      tmp.clear();
      tmp.reserve( vars.size() );
      for( auto itr = vars.begin(); itr != vars.end(); ++itr )
         tmp.push_back( itr->as<T>() );
   }

Here is the call graph for this function:

from_variant() [47/103]

void fc::from_variant	(	const fc::variant &	var,
		string &	vo )

Definition at line 724 of file variant.cpp.

{
   vo = var.as_string();
}

Here is the call graph for this function:

from_variant() [48/103]

void fc::from_variant ( const fc::variant & var, sysio::chain::asset & vo )

inline

Definition at line 108 of file asset.hpp.

                                                                    {
   vo = sysio::chain::asset::from_string(var.get_string());
}

Here is the call graph for this function:

from_variant() [49/103]

void fc::from_variant ( const fc::variant & var, sysio::chain::extended_asset & vo )

inline

Definition at line 114 of file asset.hpp.

                                                                             {
   if( var.is_array() ) {
      const auto& va = var.get_array();
      from_variant(va.at(0), vo.quantity);
      from_variant(va.at(1), vo.contract);
   } else {
      const auto& vars = var.get_object();
      from_variant(vars["quantity"], vo.quantity);
      from_variant(vars["contract"], vo.contract);
   }
}

Here is the call graph for this function:

from_variant() [50/103]

void fc::from_variant ( const fc::variant & var, sysio::chain::symbol & vo )

inline

Definition at line 173 of file symbol.hpp.

                                                                        {
      vo = sysio::chain::symbol::from_string(var.get_string());
   }

Here is the call graph for this function:

from_variant() [51/103]

void fc::from_variant ( const fc::variant & var, sysio::chain::symbol_code & vo )

inline

Definition at line 182 of file symbol.hpp.

                                                                             {
      vo = sysio::chain::symbol(0, var.get_string().c_str()).to_symbol_code();
   }

Here is the call graph for this function:

from_variant() [52/103]

void fc::from_variant	(	const fc::variant &	var,
		fc::time_point &	t )

Definition at line 83 of file time.cpp.

                                                           {
    t = fc::time_point::from_iso_string( v.as_string() );
  }

Here is the call graph for this function:

from_variant() [53/103]

void fc::from_variant	(	const fc::variant &	var,
		fc::time_point_sec &	t )

Definition at line 89 of file time.cpp.

                                                               {
    t = fc::time_point_sec::from_iso_string( v.as_string() );
  }

Here is the call graph for this function:

from_variant() [54/103]

void fc::from_variant	(	const fc::variant &	var,
		uint16_t &	vo )

Definition at line 643 of file variant.cpp.

{ vo = static_cast<uint16_t>(var.as_uint64()); }

Here is the call graph for this function:

from_variant() [55/103]

void fc::from_variant	(	const fc::variant &	var,
		uint32_t &	vo )

Definition at line 650 of file variant.cpp.

{
   vo = static_cast<uint32_t>(var.as_uint64());
}

Here is the call graph for this function:

from_variant() [56/103]

void fc::from_variant	(	const fc::variant &	var,
		uint64_t &	vo )

Definition at line 699 of file variant.cpp.

{
   vo = var.as_uint64();
}

Here is the call graph for this function:

from_variant() [57/103]

void fc::from_variant	(	const fc::variant &	var,
		uint8_t &	vo )

Definition at line 635 of file variant.cpp.

{ vo = static_cast<uint8_t>(var.as_uint64()); }

Here is the call graph for this function:

from_variant() [58/103]

void fc::from_variant	(	const fc::variant &	var,
		unsigned __int128 &	vo )

Definition at line 668 of file variant.cpp.

{
   if( var.is_uint64() ) {
      vo = var.as_uint64();
   } else if( var.is_string() ) {
      vo = static_cast<unsigned __int128>( boost::multiprecision::uint128_t(var.as_string()) );
   } else {
      FC_THROW_EXCEPTION( bad_cast_exception, "Cannot convert variant of type '${type}' into a uint128_t", ("type", var.get_type()) );
   }
}

Here is the call graph for this function:

from_variant() [59/103]

void fc::from_variant	(	const fc::variant &	var,
		variant_object &	vo )

Definition at line 182 of file variant_object.cpp.

   {
      vo = var.get_object();
   }

Here is the call graph for this function:

from_variant() [60/103]

void fc::from_variant	(	const variant &	e,
		exception &	ll )

Definition at line 134 of file exception.cpp.

   {
      auto obj = v.get_object();
      if( obj.contains( "stack" ) )
         ll.my->_elog =  obj["stack"].as<log_messages>();
      if( obj.contains( "code" ) )
         ll.my->_code = obj["code"].as_int64();
      if( obj.contains( "name" ) )
         ll.my->_name = obj["name"].as_string();
      if( obj.contains( "message" ) )
         ll.my->_what = obj["message"].as_string();
   }

from_variant() [61/103]

void fc::from_variant	(	const variant &	e,
		log_level &	ll )

Definition at line 133 of file log_message.cpp.

   {
      try 
      {
        if( v.as_string() == "all" ) e = log_level::all;
        else if( v.as_string() == "debug" ) e = log_level::debug;
        else if( v.as_string() == "info" ) e = log_level::info;
        else if( v.as_string() == "warn" ) e = log_level::warn;
        else if( v.as_string() == "error" ) e = log_level::error;
        else if( v.as_string() == "off" ) e = log_level::off;
        else FC_THROW_EXCEPTION( bad_cast_exception, "Failed to cast from Variant to log_level" );
      } FC_RETHROW_EXCEPTIONS( error, 
                                   "Expected 'all|debug|info|warn|error|off', but got '${variant}'",
                                   ("variant",v) );
   }

Here is the call graph for this function:

from_variant() [62/103]

void fc::from_variant	(	const variant &	l,
		log_context &	c )

Definition at line 95 of file log_message.cpp.

   { 
        c = log_context(l); 
   }

from_variant() [63/103]

void fc::from_variant	(	const variant &	l,
		log_message &	c )

Definition at line 100 of file log_message.cpp.

   { 
        c = log_message(l); 
   }

from_variant() [64/103]

template<typename T , size_t N>

void fc::from_variant	(	const variant &	v,
		array< T, N > &	bi )

Definition at line 111 of file array.hpp.

  {
    std::vector<char> ve = v.as< std::vector<char> >();
    if( ve.size() )
    {
        memcpy(&bi, ve.data(), fc::min<size_t>(ve.size(),sizeof(bi)) );
    }
    else
        memset( &bi, char(0), sizeof(bi) );
  }

Here is the call graph for this function:

from_variant() [65/103]

void fc::from_variant	(	const variant &	v,
		bigint &	bi )

decodes the big int as base64 string, or a number

Definition at line 218 of file bigint.cpp.

  {
    if( v.is_numeric() ) bi = bigint( static_cast<unsigned long>(v.as_uint64()) );
    else
    {
        std::string b64 = v.as_string();
        std::string bin = base64_decode(b64);
        bi = bigint(bin.c_str(), bin.size() );
    }
  }

Here is the call graph for this function:

from_variant() [66/103]

template<typename K , typename V , typename... U>

void fc::from_variant	(	const variant &	v,
		bip::map< K, V, U... > &	m )

Definition at line 85 of file container.hpp.

                                                                 {
      detail::from_variant_to_map( v, m );
   }

Here is the call graph for this function:

from_variant() [67/103]

template<typename K , typename V , typename... U>

void fc::from_variant	(	const variant &	v,
		bip::multimap< K, V, U... > &	m )

Definition at line 95 of file container.hpp.

                                                                      {
      detail::from_variant_to_map( v, m );
   }

Here is the call graph for this function:

from_variant() [68/103]

void fc::from_variant ( const variant & v, blob & b )

inline

Definition at line 195 of file database_utils.hpp.

                                                  {
      string _s = base64_decode(v.as_string());
      b.data = std::vector<char>(_s.begin(), _s.end());
   }

Here is the call graph for this function:

from_variant() [69/103]

template<typename OidType >

void fc::from_variant	(	const variant &	v,
		chainbase::oid< OidType > &	oid )

Definition at line 105 of file database_utils.hpp.

                                                                     {
      from_variant(v, oid._id);
   }

Here is the call graph for this function:

from_variant() [70/103]

template<typename Storage >

void fc::from_variant	(	const variant &	v,
		fixed_string< Storage > &	s )

Definition at line 168 of file fixed_string.hpp.

                                                                   {
      s = v.as_string();
   }

Here is the call graph for this function:

from_variant() [71/103]

template<typename K , typename V , typename... U>

void fc::from_variant	(	const variant &	v,
		flat_map< K, V, U... > &	m )

Definition at line 172 of file flat.hpp.

                                                                   {
      detail::from_variant_to_flat_map( v, m );
   }

Here is the call graph for this function:

from_variant() [72/103]

template<typename K , typename V , typename... U>

void fc::from_variant	(	const variant &	v,
		flat_multimap< K, V, U... > &	m )

Definition at line 182 of file flat.hpp.

                                                                        {
      detail::from_variant_to_flat_map( v, m );
   }

Here is the call graph for this function:

from_variant() [73/103]

void fc::from_variant ( const variant & v, float128_t & f )

inline

Definition at line 154 of file database_utils.hpp.

                                                        {
      // Temporarily hold the binary in uint128_t before casting it to float128_t
      char temp[sizeof(sysio::chain::uint128_t)];
      memset(temp, 0, sizeof(temp));
      auto s = v.as_string();   
      FC_ASSERT( s.size() == 2 + 2 * sizeof(temp) && s.find("0x") == 0, "Failure in converting hex data into a float128_t");    
      auto sz = from_hex( s.substr(2), temp, sizeof(temp) );
      // Assumes platform is little endian and hex representation of 128-bit integer is in little endian order. 
      FC_ASSERT( sz == sizeof(temp), "Failure in converting hex data into a float128_t" );  
      memcpy(&f, temp, sizeof(f));
   }

Here is the call graph for this function:

from_variant() [74/103]

void fc::from_variant ( const variant & v, float64_t & f )

inline

Definition at line 137 of file database_utils.hpp.

                                                       {
      double double_f;
      from_variant(v, double_f);
      double_to_float64(double_f, f);
   }

Here is the call graph for this function:

from_variant() [75/103]

void fc::from_variant	(	const variant &	v,
		private_key &	bi )

decodes the big int as base64 string, or a number

Definition at line 359 of file pke.cpp.

  {
    bi = private_key( v.as<std::vector<char> >() ); 
  }

Here is the call graph for this function:

from_variant() [76/103]

void fc::from_variant	(	const variant &	v,
		public_key &	bi )

decodes the big int as base64 string, or a number

Definition at line 346 of file pke.cpp.

  {
    bi = public_key( v.as<std::vector<char> >() ); 
  }

Here is the call graph for this function:

from_variant() [77/103]

void fc::from_variant	(	const variant &	v,
		ripemd160 &	bi )

Definition at line 107 of file ripemd160.cpp.

  {
    std::vector<char> ve = v.as< std::vector<char> >();
    if( ve.size() )
    {
        memcpy(&bi, ve.data(), fc::min<size_t>(ve.size(),sizeof(bi)) );
    }
    else
        memset( &bi, char(0), sizeof(bi) );
  }

Here is the call graph for this function:

from_variant() [78/103]

void fc::from_variant	(	const variant &	v,
		sha1 &	bi )

Definition at line 93 of file sha1.cpp.

  {
    std::vector<char> ve = v.as< std::vector<char> >();
    if( ve.size() )
    {
        memcpy(&bi, ve.data(), fc::min<size_t>(ve.size(),sizeof(bi)) );
    }
    else
        memset( &bi, char(0), sizeof(bi) );
  }

Here is the call graph for this function:

from_variant() [79/103]

void fc::from_variant	(	const variant &	v,
		sha224 &	bi )

Definition at line 88 of file sha224.cpp.

  {
    std::vector<char> ve = v.as< std::vector<char> >();
    if( ve.size() )
    {
        memcpy(&bi, ve.data(), fc::min<size_t>(ve.size(),sizeof(bi)) );
    }
    else
        memset( &bi, char(0), sizeof(bi) );
  }

Here is the call graph for this function:

from_variant() [80/103]

void fc::from_variant	(	const variant &	v,
		sha256 &	bi )

Definition at line 210 of file sha256.cpp.

  {
    std::vector<char> ve = v.as< std::vector<char> >();
    if( ve.size() )
    {
        memcpy(&bi, ve.data(), fc::min<size_t>(ve.size(),sizeof(bi)) );
    }
    else
        memset( &bi, char(0), sizeof(bi) );
  }

Here is the call graph for this function:

from_variant() [81/103]

void fc::from_variant	(	const variant &	v,
		sha3 &	bi )

Definition at line 280 of file sha3.cpp.

{
    const auto &ve = v.as<std::vector<char>>();
    if (ve.size())
        memcpy(&bi, ve.data(), fc::min<size_t>(ve.size(), sizeof(bi)));
    else
        memset(&bi, char(0), sizeof(bi));
}

Here is the call graph for this function:

from_variant() [82/103]

void fc::from_variant	(	const variant &	v,
		sha512 &	bi )

Definition at line 95 of file sha512.cpp.

  {
    std::vector<char> ve = v.as< std::vector<char> >();
    if( ve.size() )
    {
        memcpy(&bi, ve.data(), fc::min<size_t>(ve.size(),sizeof(bi)) );
    }
    else
        memset( &bi, char(0), sizeof(bi) );
  }

Here is the call graph for this function:

from_variant() [83/103]

void fc::from_variant ( const variant & v, sysio::chain::shared_blob & b )

inline

Definition at line 184 of file database_utils.hpp.

                                                                   {
      string _s = base64_decode(v.as_string());
      b = sysio::chain::shared_blob(_s.begin(), _s.end(), b.get_allocator());
   }

Here is the call graph for this function:

from_variant() [84/103]

void fc::from_variant ( const variant & v, sysio::chain::shared_string & s )

inline

Definition at line 172 of file database_utils.hpp.

                                                                     {
      string _s;
      from_variant(v, _s);
      s = sysio::chain::shared_string(_s.begin(), _s.end(), s.get_allocator());
   }

Here is the call graph for this function:

from_variant() [85/103]

template<typename T >

void fc::from_variant	(	const variant &	v,
		sysio::chain::shared_vector< T > &	sv )

Definition at line 206 of file database_utils.hpp.

                                                                         {
      std::vector<T> _v;
      from_variant(v, _v);
      sv = sysio::chain::shared_vector<T>(_v.begin(), _v.end(), sv.get_allocator());
   }

Here is the call graph for this function:

from_variant() [86/103]

template<typename T >

void fc::from_variant	(	const variant &	v,
		T &	o )

Definition at line 104 of file variant.hpp.

   {
      if_enum<typename fc::reflector<T>::is_enum>::from_variant( v, o );
   }

Here is the call graph for this function:

from_variant() [87/103]

void fc::from_variant	(	const variant &	var,
		crypto::private_key &	vo )

Definition at line 149 of file private_key.cpp.

   {
      vo = fc::crypto::private_key(var.as_string());
   }

Here is the call graph for this function:

from_variant() [88/103]

void fc::from_variant	(	const variant &	var,
		crypto::public_key &	vo )

Definition at line 114 of file public_key.cpp.

   {
      vo = fc::crypto::public_key(var.as_string());
   }

Here is the call graph for this function:

from_variant() [89/103]

void fc::from_variant	(	const variant &	var,
		crypto::r1::private_key &	vo )

Definition at line 625 of file elliptic_r1.cpp.

  {
    fc::sha256 sec;
    from_variant( var, sec );
    vo = crypto::r1::private_key::regenerate(sec);
  }

Here is the call graph for this function:

from_variant() [90/103]

void fc::from_variant	(	const variant &	var,
		crypto::r1::public_key &	vo )

Definition at line 636 of file elliptic_r1.cpp.

  {
    crypto::r1::public_key_data dat;
    from_variant( var, dat );
    vo = crypto::r1::public_key(dat);
  }

Here is the call graph for this function:

from_variant() [91/103]

void fc::from_variant	(	const variant &	var,
		crypto::signature &	vo )

Definition at line 93 of file signature.cpp.

   {
      vo = fc::crypto::signature(var.as_string());
   }

Here is the call graph for this function:

from_variant() [92/103]

void fc::from_variant	(	const variant &	var,
		ecc::private_key &	vo )

Definition at line 221 of file elliptic_common.cpp.

{
    fc::sha256 sec;
    from_variant( var, sec );
    vo = ecc::private_key::regenerate(sec);
}

Here is the call graph for this function:

from_variant() [93/103]

void fc::from_variant	(	const variant &	var,
		ecc::public_key &	vo )

Definition at line 233 of file elliptic_common.cpp.

{
    ecc::public_key_data dat;
    from_variant( var, dat );
    vo = ecc::public_key(dat);
}

Here is the call graph for this function:

from_variant() [94/103]

void fc::from_variant	(	const variant &	var,
		em::private_key &	vo )

Definition at line 222 of file elliptic_em_common.cpp.

{
    fc::sha256 sec;
    from_variant( var, sec );
    vo = em::private_key::regenerate(sec);
}

Here is the call graph for this function:

from_variant() [95/103]

void fc::from_variant	(	const variant &	var,
		em::public_key &	vo )

Definition at line 234 of file elliptic_em_common.cpp.

{
    em::public_key_data dat;
    from_variant( var, dat );
    vo = em::public_key(dat);
}

Here is the call graph for this function:

from_variant() [96/103]

template<typename IntType , typename EnumType >

void fc::from_variant	(	const variant &	var,
		enum_type< IntType, EnumType > &	vo )

Definition at line 56 of file enum_type.hpp.

  {
    vo.value = var.as<EnumType>();
  }

Here is the call graph for this function:

from_variant() [97/103]

void fc::from_variant	(	const variant &	var,
		ip::address &	vo )

Definition at line 153 of file ip.cpp.

  {
    vo = ip::address(var.as_string());
  }

Here is the call graph for this function:

from_variant() [98/103]

void fc::from_variant	(	const variant &	var,
		ip::endpoint &	vo )

Definition at line 144 of file ip.cpp.

  {
     vo = ip::endpoint::from_string(var.as_string());
  }

Here is the call graph for this function:

from_variant() [99/103]

void fc::from_variant	(	const variant &	var,
		real128 &	vo )

Definition at line 125 of file real128.cpp.

   {
     vo = real128(var.as_string());
   }

Here is the call graph for this function:

from_variant() [100/103]

void fc::from_variant	(	const variant &	var,
		signed_int &	vo )

Definition at line 7 of file varint.cpp.

{ vo.value = static_cast<int32_t>(var.as_int64()); }

Here is the call graph for this function:

from_variant() [101/103]

template<typename T >

void fc::from_variant	(	const variant &	var,
		std::optional< T > &	vo )

Definition at line 392 of file variant.hpp.

   {
      if( var.is_null() ) vo = std::optional<T>();
      else
      {
          vo = T();
          from_variant( var, *vo );
      }
   }

Here is the call graph for this function:

from_variant() [102/103]

void fc::from_variant	(	const variant &	var,
		uint128 &	vo )

Definition at line 378 of file uint128.cpp.

{ vo = uint128(var.as_string()); }

Here is the call graph for this function:

from_variant() [103/103]

void fc::from_variant	(	const variant &	var,
		unsigned_int &	vo )

Definition at line 9 of file varint.cpp.

{ vo.value = static_cast<uint32_t>(var.as_uint64()); }

Here is the call graph for this function:

generate_key_pair()

void fc::generate_key_pair	(	public_key &	pub,
		private_key &	priv )

Definition at line 329 of file pke.cpp.

    {
       static bool init = true;
       if( init ) { ERR_load_crypto_strings(); init = false; }
 
       pub.my = std::make_shared<detail::pke_impl>();
       priv.my = pub.my;
       pub.my->rsa = RSA_generate_key( 2048, 65537, NULL, NULL );
    }

get_approximate_relative_time_string() [1/2]

string fc::get_approximate_relative_time_string	(	const time_point &	event_time,
		const time_point &	relative_to_time = fc::time_point::now(),
		const std::string &	ago = " ago" )

Definition at line 154 of file time.cpp.

                                                                      {
    return get_approximate_relative_time_string(time_point_sec(event_time), time_point_sec(relative_to_time), ago);
  }

Here is the call graph for this function:

get_approximate_relative_time_string() [2/2]

string fc::get_approximate_relative_time_string	(	const time_point_sec &	event_time,
		const time_point_sec &	relative_to_time = fc::time_point::now(),
		const std::string &	ago = " ago" )

return a human-readable approximate time, relative to now() e.g., "4 hours ago", "2 months ago", etc.

Definition at line 94 of file time.cpp.

                                                                              {
 
 
    string ago = default_ago;
    int32_t seconds_ago = relative_to_time.sec_since_epoch() - event_time.sec_since_epoch();
    if (seconds_ago < 0)
    {
       ago = " in the future";
       seconds_ago = -seconds_ago;
    }
    std::stringstream result;
    if (seconds_ago < 90)
    {
      result << seconds_ago << " second" << (seconds_ago > 1 ? "s" : "") << ago;
      return result.str();
    }
    uint32_t minutes_ago = (seconds_ago + 30) / 60;
    if (minutes_ago < 90)
    {
      result << minutes_ago << " minute" << (minutes_ago > 1 ? "s" : "") << ago;
      return result.str();
    }
    uint32_t hours_ago = (minutes_ago + 30) / 60;
    if (hours_ago < 90)
    {
      result << hours_ago << " hour" << (hours_ago > 1 ? "s" : "") << ago;
      return result.str();
    }
    uint32_t days_ago = (hours_ago + 12) / 24;
    if (days_ago < 90)
    {
      result << days_ago << " day" << (days_ago > 1 ? "s" : "") << ago;
      return result.str();
    }
    uint32_t weeks_ago = (days_ago + 3) / 7;
    if (weeks_ago < 70)
    {
      result << weeks_ago << " week" << (weeks_ago > 1 ? "s" : "") << ago;
      return result.str();
    }
    uint32_t months_ago = (days_ago + 15) / 30;
    if (months_ago < 12)
    {
      result << months_ago << " month" << (months_ago > 1 ? "s" : "") << ago;
      return result.str();
    }
    uint32_t years_ago = days_ago / 365;
    result << years_ago << " year" << (months_ago > 1 ? "s" : "");
    if (months_ago < 12 * 5)
    {
      uint32_t leftover_days = days_ago - (years_ago * 365);
      uint32_t leftover_months = (leftover_days + 15) / 30;
      if (leftover_months)
        result << leftover_months <<  " month" << (months_ago > 1 ? "s" : "");
    }
    result << ago;
    return result.str();
  }

Here is the call graph for this function:

Here is the caller graph for this function:

get_index()

template<typename VariantType , typename T , std::size_t index = 0>

std::size_t fc::get_index ( )

constexpr

Definition at line 33 of file static_variant.hpp.

{
  if constexpr (index == std::variant_size_v<VariantType>) 
  {
    return index;
  } 
  else if constexpr (std::is_same_v<std::variant_alternative_t<index, VariantType>, T>) 
  {
    return index;
  } 
  else 
  {
    return get_index<VariantType, T, index + 1>();
  }
} 

Here is the call graph for this function:

Here is the caller graph for this function:

get_null_url()

std::shared_ptr< detail::url_impl > fc::get_null_url

(

)

Definition at line 115 of file url.cpp.

  {
    static auto u = std::make_shared<detail::url_impl>();
    return u; 
  }

Here is the caller graph for this function:

get_thread_name()

const string & fc::get_thread_name

(

)

Definition at line 144 of file logger_config.cpp.

                                   {
      if( thread_name.empty() ) {
#ifdef FC_USE_PTHREAD_NAME_NP
         char thr_name[64];
         int rc = pthread_getname_np( pthread_self(), thr_name, 64 );
         if( rc == 0 ) {
            thread_name = thr_name;
         }
#else
         static int thread_count = 0;
         thread_name = string( "thread-" ) + fc::to_string( thread_count++ );
#endif
      }
      return thread_name;
   }

Here is the call graph for this function:

Here is the caller graph for this function:

Hash128to64()

uint64_t fc::Hash128to64 ( const uint128 & x )

inline

Definition at line 55 of file city.cpp.

                                              {
  // Murmur-inspired hashing.
  const uint64_t kMul = 0x9ddfea08eb382d69ULL;
  uint64_t a = (Uint128Low64(x) ^ Uint128High64(x)) * kMul;
  a ^= (a >> 47);
  uint64_t b = (Uint128High64(x) ^ a) * kMul;
  b ^= (b >> 47);
  b *= kMul;
  return b;
}

Here is the call graph for this function:

hash64()

uint64_t fc::hash64	(	const char *	buf,
		size_t	len )

Definition at line 221 of file sha256.cpp.

  {
    sha256 sha_value = sha256::hash(buf,len);
    return sha_value._hash[0];
  }

Here is the call graph for this function:

hash_value()

std::size_t fc::hash_value ( const fc::sha256 & v )

inline

Definition at line 13 of file unapplied_transaction_queue.hpp.

                                                   {
     return v._hash[3];
  }

history_context_serialize_container()

template<typename ST , typename P , typename T >

datastream< ST > & fc::history_context_serialize_container	(	datastream< ST > &	ds,
		const chainbase::database &	db,
		const P &	context,
		const std::vector< T > &	v )

Definition at line 70 of file serialization.hpp.

                                                                           {
   fc::raw::pack(ds, unsigned_int(v.size()));
   for (const auto& x : v) {
      ds << make_history_context_wrapper(db, context, x);
   }
   return ds;
}

Here is the call graph for this function:

history_pack_big_bytes() [1/2]

template<typename ST >

void fc::history_pack_big_bytes	(	datastream< ST > &	ds,
		const std::optional< sysio::chain::bytes > &	v )

Definition at line 106 of file serialization.hpp.

                                                                                       {
   fc::raw::pack(ds, v.has_value());
   if (v)
      history_pack_big_bytes(ds, *v);
}

Here is the call graph for this function:

history_pack_big_bytes() [2/2]

template<typename ST >

void fc::history_pack_big_bytes	(	datastream< ST > &	ds,
		const sysio::chain::bytes &	v )

Definition at line 99 of file serialization.hpp.

                                                                          {
   history_pack_varuint64(ds, v.size());
   if (v.size())
      ds.write(&v.front(), v.size());
}

Here is the call graph for this function:

Here is the caller graph for this function:

history_pack_varuint64()

template<typename ST >

void fc::history_pack_varuint64 ( datastream< ST > & ds, uint64_t val )

inline

Definition at line 89 of file serialization.hpp.

                                                                     {
   do {
      uint8_t b = uint8_t(val) & 0x7f;
      val >>= 7;
      b |= ((val > 0) << 7);
      ds.write((char*)&b, 1);
   } while (val);
}

Here is the caller graph for this function:

history_serialize_container() [1/2]

template<typename ST , typename T >

datastream< ST > & fc::history_serialize_container	(	datastream< ST > &	ds,
		const chainbase::database &	db,
		const std::vector< std::shared_ptr< T > > &	v )

Definition at line 59 of file serialization.hpp.

                                                                                  {
   fc::raw::pack(ds, unsigned_int(v.size()));
   for (auto& x : v) {
      SYS_ASSERT(!!x, sysio::chain::plugin_exception, "null inside container");
      ds << make_history_serial_wrapper(db, *x);
   }
   return ds;
}

Here is the call graph for this function:

history_serialize_container() [2/2]

template<typename ST , typename T >

datastream< ST > & fc::history_serialize_container	(	datastream< ST > &	ds,
		const chainbase::database &	db,
		const T &	v )

Definition at line 51 of file serialization.hpp.

                                                                                                         {
   fc::raw::pack(ds, unsigned_int(v.size()));
   for (auto& x : v)
      ds << make_history_serial_wrapper(db, x);
   return ds;
}

Here is the call graph for this function:

home_path()

const fc::path & fc::home_path

(

)

Returns

the home directory on Linux and OS X and the Profile directory on Windows

Definition at line 471 of file filesystem.cpp.

   {
      static fc::path p = []()
      {
#ifdef WIN32
          HANDLE access_token;
          if (!OpenProcessToken(GetCurrentProcess(), TOKEN_READ, &access_token))
            FC_ASSERT(false, "Unable to open an access token for the current process");
          wchar_t user_profile_dir[MAX_PATH];
          DWORD user_profile_dir_len = sizeof(user_profile_dir);
          BOOL success = GetUserProfileDirectoryW(access_token, user_profile_dir, &user_profile_dir_len);
          CloseHandle(access_token);
          if (!success)
            FC_ASSERT(false, "Unable to get the user profile directory");
          return fc::path(std::wstring(user_profile_dir));
#else
          char* home = getenv( "HOME" );
          if( nullptr == home )
          {
             struct passwd* pwd = getpwuid(getuid());
             if( pwd )
             {
                 return fc::path( std::string( pwd->pw_dir ) );
             }
             FC_ASSERT( home != nullptr, "The HOME environment variable is not set" );
          }
          return fc::path( std::string(home) );
#endif
      }();
      return p;
   }

Here is the caller graph for this function:

hours()

microseconds fc::hours ( int64_t h )

inlineconstexpr

Definition at line 35 of file time.hpp.

{ return minutes(60*h); }

Here is the call graph for this function:

Here is the caller graph for this function:

initLibSnark()

void fc::initLibSnark ( )

noexcept

Definition at line 17 of file alt_bn128.cpp.

                                 {
        static bool s_initialized = []() noexcept {
            libff::inhibit_profiling_info = true;
            libff::inhibit_profiling_counters = true;
            libff::alt_bn128_pp::init_public_params();
            return true; 
        }();
        (void)s_initialized;
    }

Here is the call graph for this function:

Here is the caller graph for this function:

is_directory()

bool fc::is_directory

(

const path &

p

)

Definition at line 225 of file filesystem.cpp.

{ return boost::filesystem::is_directory(p); }

Here is the caller graph for this function:

is_regular_file()

bool fc::is_regular_file

(

const path &

p

)

Definition at line 226 of file filesystem.cpp.

{ return boost::filesystem::is_regular_file(p); }

Here is the caller graph for this function:

is_utf8()

bool fc::is_utf8

(

const std::string &

str

)

Definition at line 13 of file utf8.cpp.

    {
       return utf8::is_valid( str.begin(), str.end() );
    }

Here is the call graph for this function:

is_valid_utf8()

bool fc::is_valid_utf8

(

const std::string_view &

str

)

0x80-0x9F C1 control characters are considered invalid as well as invalid utf8 code points.

Returns

true if prune_invalid_utf8 should be called.

Definition at line 40 of file utf8.cpp.

                                                   {
      const auto invalid_range = std::make_pair<uint32_t, uint32_t>(0x80, 0x9F);
      auto [itr, v] = find_invalid( str.begin(), str.end(), invalid_range );
      return itr == str.end();
   }

Here is the call graph for this function:

Here is the caller graph for this function:

k1_recover()

std::variant< k1_recover_error, bytes > fc::k1_recover	(	const bytes &	signature,
		const bytes &	digest )

Definition at line 13 of file k1_recover.cpp.

                                                                                                {
        const secp256k1_context* context{k1_recover_context()};
        FC_ASSERT(context != nullptr);
 
        if (signature.size() != 65 || digest.size() != 32) {
            return k1_recover_error::input_error;
        }
 
        int recid = signature[0];
        if (recid<27 || recid>=35) return k1_recover_error::invalid_signature;
        recid = (recid - 27) & 3;
 
        secp256k1_ecdsa_recoverable_signature sig;
        if (!secp256k1_ecdsa_recoverable_signature_parse_compact(context, &sig, (const unsigned char*)&signature[1], recid)) {
            return k1_recover_error::invalid_signature;
        }
 
        secp256k1_pubkey pub_key;
        if (!secp256k1_ecdsa_recover(context, &pub_key, &sig, (const unsigned char*)&digest[0])) {
            return k1_recover_error::recover_error;
        }
 
        size_t kOutLen{65};
        bytes out(kOutLen, '\0');
        secp256k1_ec_pubkey_serialize(context, (unsigned char*)&out[0], &kOutLen, &pub_key, SECP256K1_EC_UNCOMPRESSED);
        return out;
    }

Here is the call graph for this function:

Here is the caller graph for this function:

k1_recover_context()

const secp256k1_context * fc::k1_recover_context

(

)

Definition at line 8 of file k1_recover.cpp.

                                                  {
        static secp256k1_context* ctx = secp256k1_context_create(SECP256K1_CONTEXT_VERIFY);
        return ctx;
    }

Here is the call graph for this function:

Here is the caller graph for this function:

make_fused() [1/5]

template<typename R >

std::function< R, fc::tuple<> > fc::make_fused

(

const std::function< R > &

f

)

Definition at line 7 of file make_fused.hpp.

                                                                    {
      return [=]( fc::tuple<> ){ return f(); };
   }

make_fused() [2/5]

template<typename R , typename A >

std::function< R(fc::tuple< A >) > fc::make_fused

(

const std::function< R(A)> &

f

)

Definition at line 11 of file make_fused.hpp.

                                                                        {
      return [f]( fc::tuple<A> t){ return f(t.a); };
   }

make_fused() [3/5]

template<typename R , typename A , typename B >

std::function< R(fc::tuple< A, B >) > fc::make_fused

(

const std::function< R(A, B)> &

f

)

Definition at line 15 of file make_fused.hpp.

                                                                            {
      return [f]( fc::tuple<A,B> t){ return f(t.a,t.b); };
   }

make_fused() [4/5]

template<typename R , typename A , typename B , typename C >

std::function< R(fc::tuple< A, B, C >) > fc::make_fused

(

const std::function< R(A, B, C)> &

f

)

Definition at line 19 of file make_fused.hpp.

                                                                                {
      return [f]( fc::tuple<A,B,C> t){ return f(t.a,t.b,t.c); };
   }

make_fused() [5/5]

template<typename R , typename A , typename B , typename C , typename D >

std::function< R(fc::tuple< A, B, C, D >) > fc::make_fused

(

const std::function< R(A, B, C, D)> &

f

)

Definition at line 23 of file make_fused.hpp.

                                                                                    {
      return [f]( fc::tuple<A,B,C> t){ return f(t.a,t.b,t.c,t.d); };
   }

make_relative()

fc::path fc::make_relative	(	const path &	from,
		const path &	to )

Definition at line 369 of file filesystem.cpp.

                                                             {
    boost::filesystem::path a_From = boost::filesystem::absolute(from);
    boost::filesystem::path a_To = boost::filesystem::absolute(to);
    boost::filesystem::path ret;
    boost::filesystem::path::const_iterator itrFrom(a_From.begin()), itrTo(a_To.begin());
    // Find common base
    for( boost::filesystem::path::const_iterator toEnd( a_To.end() ), fromEnd( a_From.end() ) ; itrFrom != fromEnd && itrTo != toEnd && *itrFrom == *itrTo; ++itrFrom, ++itrTo );
    // Navigate backwards in directory to reach previously found base
    for( boost::filesystem::path::const_iterator fromEnd( a_From.end() ); itrFrom != fromEnd; ++itrFrom ) {
      if( (*itrFrom) != "." )
         ret /= "..";
    }
    // Now navigate down the directory branch
    for (; itrTo != a_To.end(); ++itrTo)
      ret /= *itrTo;
    return ret;
  }

make_scoped_exit()

template<typename Callback >

scoped_exit< Callback > fc::make_scoped_exit

(

Callback &&

c

)

Definition at line 35 of file scoped_exit.hpp.

                                                          {
      return scoped_exit<Callback>( std::forward<Callback>(c) );
   }

Here is the caller graph for this function:

make_tuple()

tuple fc::make_tuple ( )

inline

Definition at line 68 of file tuple.hpp.

{ return tuple<>(); }

milliseconds()

microseconds fc::milliseconds ( int64_t s )

inlineconstexpr

Definition at line 33 of file time.hpp.

{ return microseconds( s * 1000 ); }

Here is the caller graph for this function:

min()

template<typename T >

const T & fc::min	(	const T &	a,
		const T &	b )

Definition at line 140 of file utility.hpp.

{ return a < b ? a: b; }

Here is the caller graph for this function:

minutes()

microseconds fc::minutes ( int64_t m )

inlineconstexpr

Definition at line 34 of file time.hpp.

{ return seconds(60*m); }

Here is the call graph for this function:

Here is the caller graph for this function:

modexp()

std::variant< modular_arithmetic_error, bytes > fc::modexp	(	const bytes &	_base,
		const bytes &	_exponent,
		const bytes &	_modulus )

Definition at line 7 of file modular_arithmetic.cpp.

    {
        if (_modulus.size() == 0) {
            return modular_arithmetic_error::modulus_len_zero;
        }
 
        auto output = bytes(_modulus.size(), '\0');
 
        mpz_t base, exponent, modulus;
        mpz_inits(base, exponent, modulus, nullptr);
 
        if (_base.size()) {
            mpz_import(base, _base.size(), 1, 1, 0, 0, _base.data());
        }
 
        if (_exponent.size()) {
            mpz_import(exponent, _exponent.size(), 1, 1, 0, 0, _exponent.data());
        }
 
        mpz_import(modulus, _modulus.size(), 1, 1, 0, 0, _modulus.data());
 
        if (mpz_sgn(modulus) == 0) {
            mpz_clears(base, exponent, modulus, nullptr);
            return output;
        }
 
        mpz_t result;
        mpz_init(result);
 
        mpz_powm(result, base, exponent, modulus);
        // export as little-endian
        mpz_export(output.data(), nullptr, -1, 1, 0, 0, result);
        // and convert to big-endian
        std::reverse(output.begin(), output.end());
 
        mpz_clears(base, exponent, modulus, result, nullptr);
 
        return output;
    }

Here is the caller graph for this function:

move_append()

template<typename Container >

void fc::move_append	(	Container &	dest,
		Container &&	src )

Definition at line 151 of file utility.hpp.

                                                      {
    if (src.empty()) {
      return;
    } else if (dest.empty()) {
      dest = std::move(src);
    } else {
      dest.insert(std::end(dest), std::make_move_iterator(std::begin(src)), std::make_move_iterator(std::end(src)));
    }
  }

Here is the caller graph for this function:

number_from_stream()

template<typename T , json::parse_type parser_type>

variant fc::number_from_stream

(

T &

in

)

Definition at line 253 of file json.cpp.

   {
      std::stringstream ss;
 
      bool  dot = false;
      bool  neg = false;
      if( in.peek() == '-')
      {
        neg = true;
        ss.put( in.get() );
      }
      bool done = false;
 
      try
      {
        while( !done )
        {
          char c = in.peek();
          switch( c )
          {
              case '.':
                 if (dot)
                    FC_THROW_EXCEPTION(parse_error_exception, "Can't parse a number with two decimal places");
                 dot = true;
              case '0':
              case '1':
              case '2':
              case '3':
              case '4':
              case '5':
              case '6':
              case '7':
              case '8':
              case '9':
                 ss.put( in.get() );
                 break;
              case '\0':
                 FC_THROW_EXCEPTION( eof_exception, "unexpected end of file" );
              default:
                 if( isalnum( c ) )
                 {
                    return ss.str() + stringFromToken( in );
                 }
                done = true;
                break;
          }
        }
      }
      catch (fc::eof_exception&)
      {
      }
      catch (const std::ios_base::failure&)
      {
      }
      std::string str = ss.str();
      if (str == "-." || str == "." || str == "-") // check the obviously wrong things we could have encountered
        FC_THROW_EXCEPTION(parse_error_exception, "Can't parse token \"${token}\" as a JSON numeric constant", ("token", str));
      if( dot )
        return parser_type == json::parse_type::legacy_parser_with_string_doubles ? variant(str) : variant(to_double(str));
      if( neg )
        return to_int64(str);
      return to_uint64(str);
   }

Here is the call graph for this function:

Here is the caller graph for this function:

objectFromStream()

template<typename T , json::parse_type parser_type>

variant_object fc::objectFromStream	(	T &	in,
		uint32_t	max_depth )

Definition at line 171 of file json.cpp.

   {
      mutable_variant_object obj;
      try
      {
         char c = in.peek();
         if( c != '{' )
            FC_THROW_EXCEPTION( parse_error_exception,
                                     "Expected '{', but read '${char}'",
                                     ("char",string(&c, &c + 1)) );
         in.get();
         while( in.peek() != '}' )
         {
            if( in.peek() == ',' )
            {
               in.get();
               continue;
            }
            if( skip_white_space(in) ) continue;
            string key = stringFromStream( in );
            skip_white_space(in);
            if( in.peek() != ':' )
            {
               FC_THROW_EXCEPTION( parse_error_exception, "Expected ':' after key \"${key}\"",
                                        ("key", key) );
            }
            in.get();
            auto val = variant_from_stream<T, parser_type>( in, max_depth - 1 );
 
            obj(std::move(key),std::move(val));
            //skip_white_space(in);
         }
         if( in.peek() == '}' )
         {
            in.get();
            return obj;
         }
         FC_THROW_EXCEPTION( parse_error_exception, "Expected '}' after ${variant}", ("variant", obj ) );
      }
      catch( const fc::eof_exception& e )
      {
         FC_THROW_EXCEPTION( parse_error_exception, "Unexpected EOF: ${e}", ("e", e.to_detail_string() ) );
      }
      catch( const std::ios_base::failure& e )
      {
         FC_THROW_EXCEPTION( parse_error_exception, "Unexpected EOF: ${e}", ("e", e.what() ) );
      } FC_RETHROW_EXCEPTIONS( warn, "Error parsing object" );
   }

Here is the call graph for this function:

Here is the caller graph for this function:

operator!()

bool fc::operator!

(

const fc::variant &

a

)

Definition at line 890 of file variant.cpp.

   {
      return !a.as_bool();
   }

operator!=() [1/12]

template<typename T , size_t N>

bool fc::operator!=	(	const array< T, N > &	a,
		const array< T, N > &	b )

Definition at line 102 of file array.hpp.

  { return 0 != memcmp( a.data, b.data, N*sizeof(T) ); }

operator!=() [2/12]

bool fc::operator!=	(	const directory_iterator &	r,
		const directory_iterator &	l )

Definition at line 191 of file filesystem.cpp.

                                                                                 {
        return *r._p != *l._p;
      }

operator!=() [3/12]

bool fc::operator!=	(	const fc::path &	l,
		const fc::path &	r )

Definition at line 83 of file filesystem.cpp.

{ return *l._p != *r._p; }

operator!=() [4/12]

bool fc::operator!=	(	const fc::variant &	a,
		const fc::variant &	b )

Definition at line 885 of file variant.cpp.

   {
      return !( a == b );
   }

operator!=() [5/12]

bool fc::operator!=	(	const logger &	l,
		std::nullptr_t	)

Definition at line 56 of file logger.cpp.

{ return !!l.my;  }

operator!=() [6/12]

bool fc::operator!=	(	const recursive_directory_iterator &	r,
		const recursive_directory_iterator &	l )

Definition at line 212 of file filesystem.cpp.

                                                                                                     {
        return *r._p != *l._p;
      }

operator!=() [7/12]

bool fc::operator!=	(	const ripemd160 &	h1,
		const ripemd160 &	h2 )

Definition at line 96 of file ripemd160.cpp.

                                                              {
  return memcmp( h1._hash, h2._hash, sizeof(h1._hash) ) != 0;
}

operator!=() [8/12]

bool fc::operator!=	(	const sha1 &	h1,
		const sha1 &	h2 )

Definition at line 82 of file sha1.cpp.

                                                    {
  return memcmp( h1._hash, h2._hash, sizeof(h1._hash) ) != 0;
}

operator!=() [9/12]

bool fc::operator!=	(	const sha224 &	h1,
		const sha224 &	h2 )

Definition at line 77 of file sha224.cpp.

                                                            {
      return memcmp( h1._hash, h2._hash, sizeof(sha224) ) != 0;
    }

operator!=() [10/12]

bool fc::operator!=	(	const sha256 &	h1,
		const sha256 &	h2 )

Definition at line 98 of file sha256.cpp.

                                                            {
       return !(h1 == h2);
    }

operator!=() [11/12]

bool fc::operator!=	(	const sha3 &	h1,
		const sha3 &	h2 )

Definition at line 262 of file sha3.cpp.

{
    return !(h1 == h2);
}

operator!=() [12/12]

bool fc::operator!=	(	const sha512 &	h1,
		const sha512 &	h2 )

Definition at line 84 of file sha512.cpp.

                                                            {
      return memcmp( h1._hash, h2._hash, sizeof(h1._hash) ) != 0;
    }

operator&()

bloom_filter fc::operator& ( const bloom_filter & a, const bloom_filter & b )

inline

Definition at line 582 of file bloom_filter.hpp.

{
   bloom_filter result = a;
   result &= b;
   return result;
}

operator*()

variant fc::operator*	(	const fc::variant &	a,
		const fc::variant &	b )

Definition at line 976 of file variant.cpp.

   {
      if( a.is_double()  || b.is_double() ) return a.as_double() * b.as_double();
      if( a.is_int64()   || b.is_int64() )  return a.as_int64() * b.as_int64();
      if( a.is_uint64()  || b.is_uint64() ) return a.as_uint64() * b.as_uint64();
      if( a.is_array()  && b.is_array() )
      {
         const variants& aa = a.get_array();
         const variants& ba = b.get_array();
         variants result;
         result.reserve( std::max(aa.size(),ba.size()) );
         auto num = std::max(aa.size(),ba.size());
         for( unsigned i = 0; i < num; ++i )
         {
            if( aa.size() > i && ba.size() > i )
               result[i]  = aa[i] * ba[i];
            else if( aa.size() > i )
               result[i]  = aa[i];
            else
               result[i]  = ba[i];
         }
         return result;
      }
      FC_ASSERT( false, "invalid operation ${a} * ${b}", ("a",a)("b",b) );
   }

Here is the call graph for this function:

operator+() [1/2]

variant fc::operator+	(	const fc::variant &	a,
		const fc::variant &	b )

Definition at line 923 of file variant.cpp.

   {
      if( a.is_array()  && b.is_array() )
      {
         const variants& aa = a.get_array();
         const variants& ba = b.get_array();
         variants result;
         result.reserve( std::max(aa.size(),ba.size()) );
         auto num = std::max(aa.size(),ba.size());
         for( unsigned i = 0; i < num; ++i )
         {
            if( aa.size() > i && ba.size() > i )
               result[i]  = aa[i] + ba[i];
            else if( aa.size() > i )
               result[i]  = aa[i];
            else
               result[i]  = ba[i];
         }
         return result;
      }
      if( a.is_string()  || b.is_string() ) return a.as_string() + b.as_string();
      if( a.is_double()  || b.is_double() ) return a.as_double() + b.as_double();
      if( a.is_int64()   || b.is_int64() )  return a.as_int64() + b.as_int64();
      if( a.is_uint64()  || b.is_uint64() ) return a.as_uint64() + b.as_uint64();
      FC_ASSERT( false, "invalid operation ${a} + ${b}", ("a",a)("b",b) );
   }

Here is the call graph for this function:

operator+() [2/2]

template<typename T , unsigned int S, typename U , typename A >

auto fc::operator+	(	const fwd< T, S, A > &	x,
		U &&	u ) -> typename detail::add<T,U>::type

Definition at line 42 of file fwd_impl.hpp.

{ return *x+fc::forward<U>(u); }

operator-() [1/2]

variant fc::operator-	(	const fc::variant &	a,
		const fc::variant &	b )

Definition at line 950 of file variant.cpp.

   {
      if( a.is_array()  && b.is_array() )
      {
         const variants& aa = a.get_array();
         const variants& ba = b.get_array();
         variants result;
         result.reserve( std::max(aa.size(),ba.size()) );
         auto num = std::max(aa.size(),ba.size());
         for( unsigned i = 0; i < num; --i )
         {
            if( aa.size() > i && ba.size() > i )
               result[i]  = aa[i] - ba[i];
            else if( aa.size() > i )
               result[i]  = aa[i];
            else
               result[i]  = ba[i];
         }
         return result;
      }
      if( a.is_string()  || b.is_string() ) return a.as_string() - b.as_string();
      if( a.is_double()  || b.is_double() ) return a.as_double() - b.as_double();
      if( a.is_int64()   || b.is_int64() )  return a.as_int64() - b.as_int64();
      if( a.is_uint64()  || b.is_uint64() ) return a.as_uint64() - b.as_uint64();
      FC_ASSERT( false, "invalid operation ${a} + ${b}", ("a",a)("b",b) );
   }

Here is the call graph for this function:

operator-() [2/2]

template<typename T , unsigned int S, typename U , typename A >

auto fc::operator-	(	const fwd< T, S, A > &	x,
		U &&	u ) -> typename detail::sub<T,U>::type

Definition at line 45 of file fwd_impl.hpp.

{ return *x-fc::forward<U>(u); }

operator/() [1/2]

path fc::operator/	(	const fc::path &	p,
		const fc::path &	o )

Definition at line 89 of file filesystem.cpp.

                                                         {
      path tmp;
      tmp = *p._p / *o._p;
      return tmp;
   }

operator/() [2/2]

variant fc::operator/	(	const fc::variant &	a,
		const fc::variant &	b )

Definition at line 1001 of file variant.cpp.

   {
      if( a.is_double()  || b.is_double() ) return a.as_double() / b.as_double();
      if( a.is_int64()   || b.is_int64() )  return a.as_int64() / b.as_int64();
      if( a.is_uint64()  || b.is_uint64() ) return a.as_uint64() / b.as_uint64();
      if( a.is_array()  && b.is_array() )
      {
         const variants& aa = a.get_array();
         const variants& ba = b.get_array();
         variants result;
         result.reserve( std::max(aa.size(),ba.size()) );
         auto num = std::max(aa.size(),ba.size());
         for( unsigned i = 0; i < num; ++i )
         {
            if( aa.size() > i && ba.size() > i )
               result[i]  = aa[i] / ba[i];
            else if( aa.size() > i )
               result[i]  = aa[i];
            else
               result[i]  = ba[i];
         }
         return result;
      }
      FC_ASSERT( false, "invalid operation ${a} / ${b}", ("a",a)("b",b) );
   }

Here is the call graph for this function:

operator<() [1/9]

template<typename T , size_t N>

bool fc::operator<	(	const array< T, N > &	a,
		const array< T, N > &	b )

Definition at line 94 of file array.hpp.

  { return  memcmp( a.data, b.data, N*sizeof(T) ) < 0 ; }

operator<() [2/9]

bool fc::operator<	(	const fc::path &	l,
		const fc::path &	r )

Definition at line 81 of file filesystem.cpp.

{ return *l._p < *r._p; }

operator<() [3/9]

bool fc::operator<	(	const fc::variant &	a,
		const fc::variant &	b )

Definition at line 895 of file variant.cpp.

   {
      if( a.is_string()  || b.is_string() ) return a.as_string() < b.as_string();
      if( a.is_double()  || b.is_double() ) return a.as_double() < b.as_double();
      if( a.is_int64()   || b.is_int64() )  return a.as_int64() < b.as_int64();
      if( a.is_uint64()  || b.is_uint64() ) return a.as_uint64() < b.as_uint64();
      FC_ASSERT( false, "Invalid operation" );
   }

Here is the call graph for this function:

operator<() [4/9]

bool fc::operator<	(	const ripemd160 &	h1,
		const ripemd160 &	h2 )

Definition at line 93 of file ripemd160.cpp.

                                                             {
  return memcmp( h1._hash, h2._hash, sizeof(h1._hash) ) < 0;
}

operator<() [5/9]

bool fc::operator<	(	const sha1 &	h1,
		const sha1 &	h2 )

Definition at line 79 of file sha1.cpp.

                                                   {
  return memcmp( h1._hash, h2._hash, sizeof(h1._hash) ) < 0;
}

operator<() [6/9]

bool fc::operator<	(	const sha224 &	h1,
		const sha224 &	h2 )

Definition at line 74 of file sha224.cpp.

                                                           {
      return memcmp( h1._hash, h2._hash, sizeof(sha224) ) < 0;
    }

operator<() [7/9]

bool fc::operator<	(	const sha256 &	h1,
		const sha256 &	h2 )

Definition at line 95 of file sha256.cpp.

                                                           {
      return memcmp( h1._hash, h2._hash, sizeof(h1._hash) ) < 0;
    }

operator<() [8/9]

bool fc::operator<	(	const sha3 &	h1,
		const sha3 &	h2 )

Definition at line 258 of file sha3.cpp.

{
    return memcmp(h1._hash, h2._hash, sizeof(h1._hash)) < 0;
}

operator<() [9/9]

bool fc::operator<	(	const sha512 &	h1,
		const sha512 &	h2 )

Definition at line 81 of file sha512.cpp.

                                                           {
      return memcmp( h1._hash, h2._hash, sizeof(h1._hash) ) < 0;
    }

operator<<() [1/60]

ripemd160 fc::operator<<	(	const ripemd160 &	h1,
		uint32_t	i )

Definition at line 73 of file ripemd160.cpp.

                                                          {
  ripemd160 result;
  fc::detail::shift_l( h1.data(), result.data(), result.data_size(), i );
  return result;
}

operator<<() [2/60]

sha1 fc::operator<<	(	const sha1 &	h1,
		uint32_t	i )

Definition at line 59 of file sha1.cpp.

                                                {
  sha1 result;
  fc::detail::shift_l( h1.data(), result.data(), result.data_size(), i );
  return result;
}

operator<<() [3/60]

sha224 fc::operator<<	(	const sha224 &	h1,
		uint32_t	i )

Definition at line 57 of file sha224.cpp.

                                                        {
      sha224 result;
      fc::detail::shift_l( h1.data(), result.data(), result.data_size(), i );
      return result;
    }

operator<<() [4/60]

sha256 fc::operator<<	(	const sha256 &	h1,
		uint32_t	i )

Definition at line 71 of file sha256.cpp.

                                                        {
      sha256 result;
      fc::detail::shift_l( h1.data(), result.data(), result.data_size(), i );
      return result;
    }

operator<<() [5/60]

sha3 fc::operator<<	(	const sha3 &	h1,
		uint32_t	i )

Definition at line 229 of file sha3.cpp.

{
    sha3 result;
    fc::detail::shift_l(h1.data(), result.data(), result.data_size(), i);
    return result;
}

operator<<() [6/60]

sha512 fc::operator<<	(	const sha512 &	h1,
		uint32_t	i )

Definition at line 58 of file sha512.cpp.

                                                        {
      sha512 result;
      fc::detail::shift_l( h1.data(), result.data(), result.data_size(), i );
      return result;
    }

operator<<() [7/60]

template<typename ST >

datastream< ST > & fc::operator<< ( datastream< ST > & ds, const __int128 & d )

inline

Definition at line 1 of file datastream.hpp.

                                                                         {
  ds.write( (const char*)&d, sizeof(d) );
  return ds;
}

Here is the call graph for this function:

operator<<() [8/60]

template<typename ST >

datastream< ST > & fc::operator<<	(	datastream< ST > &	ds,
		const history_context_wrapper< bool, sysio::chain::action_trace > &	obj )

Definition at line 572 of file serialization.hpp.

                                                                                                                 {
   bool debug_mode = obj.context;
   fc::raw::pack(ds, fc::unsigned_int(1));
   fc::raw::pack(ds, as_type<fc::unsigned_int>(obj.obj.action_ordinal));
   fc::raw::pack(ds, as_type<fc::unsigned_int>(obj.obj.creator_action_ordinal));
   fc::raw::pack(ds, bool(obj.obj.receipt));
   if (obj.obj.receipt) {
      fc::raw::pack(ds, make_history_serial_wrapper(obj.db, as_type<sysio::chain::action_receipt>(*obj.obj.receipt)));
   }
   fc::raw::pack(ds, as_type<uint64_t>(obj.obj.receiver.to_uint64_t()));
   fc::raw::pack(ds, make_history_serial_wrapper(obj.db, as_type<sysio::chain::action>(obj.obj.act)));
   fc::raw::pack(ds, as_type<bool>(obj.obj.context_free));
   fc::raw::pack(ds, as_type<int64_t>(debug_mode ? obj.obj.elapsed.count() : 0));
   if (debug_mode)
      fc::raw::pack(ds, as_type<std::string>(obj.obj.console));
   else
      fc::raw::pack(ds, std::string{});
   history_serialize_container(ds, obj.db, as_type<flat_set<sysio::chain::account_delta>>(obj.obj.account_ram_deltas));
 
   std::optional<std::string> e;
   if (obj.obj.except) {
      if (debug_mode)
         e = obj.obj.except->to_string();
      else
         e = "Y";
   }
   fc::raw::pack(ds, as_type<std::optional<std::string>>(e));
   fc::raw::pack(ds,
                 as_type<std::optional<uint64_t>>(debug_mode ? obj.obj.error_code : cap_error_code(obj.obj.error_code)));
   fc::raw::pack(ds, as_type<sysio::chain::bytes>(obj.obj.return_value));
 
   return ds;
}

operator<<() [9/60]

template<typename ST >

datastream< ST > & fc::operator<<	(	datastream< ST > &	ds,
		const history_context_wrapper< bool, sysio::state_history::augmented_transaction_trace > &	obj )

Definition at line 572 of file serialization.hpp.

                                                                                                    {
   std::pair<uint8_t, bool> context = std::make_pair(sysio::chain::transaction_receipt_header::hard_fail, obj.context);
   ds << make_history_context_wrapper(obj.db, context, obj.obj);
   return ds;
}

operator<<() [10/60]

template<typename ST , typename P , typename T >

datastream< ST > & fc::operator<<	(	datastream< ST > &	ds,
		const history_context_wrapper< P, std::vector< T > > &	obj )

Definition at line 106 of file serialization.hpp.

                                                                                                    {
   return history_context_serialize_container(ds, obj.db, obj.context, obj.obj);
}

operator<<() [11/60]

template<typename ST >

datastream< ST > & fc::operator<<	(	datastream< ST > &	ds,
		const history_context_wrapper< std::pair< uint8_t, bool >, sysio::state_history::augmented_transaction_trace > &	obj )

Definition at line 572 of file serialization.hpp.

                                                                                                               {
   auto& trace      = *obj.obj.trace;
   bool  debug_mode = obj.context.second;
   fc::raw::pack(ds, fc::unsigned_int(0));
   fc::raw::pack(ds, as_type<sysio::chain::transaction_id_type>(trace.id));
   if (trace.receipt) {
      if (trace.failed_dtrx_trace && trace.receipt->status.value == sysio::chain::transaction_receipt_header::soft_fail)
         fc::raw::pack(ds, uint8_t(sysio::chain::transaction_receipt_header::executed));
      else
         fc::raw::pack(ds, as_type<uint8_t>(trace.receipt->status.value));
      fc::raw::pack(ds, as_type<uint32_t>(trace.receipt->cpu_usage_us));
      fc::raw::pack(ds, as_type<fc::unsigned_int>(trace.receipt->net_usage_words));
   } else {
      fc::raw::pack(ds, uint8_t(obj.context.first));
      fc::raw::pack(ds, uint32_t(0));
      fc::raw::pack(ds, fc::unsigned_int(0));
   }
   fc::raw::pack(ds, as_type<int64_t>(debug_mode ? trace.elapsed.count() : 0));
   fc::raw::pack(ds, as_type<uint64_t>(trace.net_usage));
   fc::raw::pack(ds, as_type<bool>(trace.scheduled));
   history_context_serialize_container(ds, obj.db, debug_mode,
                                       as_type<std::vector<sysio::chain::action_trace>>(trace.action_traces));
 
   fc::raw::pack(ds, bool(trace.account_ram_delta));
   if (trace.account_ram_delta) {
      fc::raw::pack(
          ds, make_history_serial_wrapper(obj.db, as_type<sysio::chain::account_delta>(*trace.account_ram_delta)));
   }
 
   std::optional<std::string> e;
   if (trace.except) {
      if (debug_mode)
         e = trace.except->to_string();
      else
         e = "Y";
   }
   fc::raw::pack(ds, as_type<std::optional<std::string>>(e));
   fc::raw::pack(ds, as_type<std::optional<uint64_t>>(debug_mode ? trace.error_code : cap_error_code(trace.error_code)));
 
   fc::raw::pack(ds, bool(trace.failed_dtrx_trace));
   if (trace.failed_dtrx_trace) {
      uint8_t stat = sysio::chain::transaction_receipt_header::hard_fail;
      if (trace.receipt && trace.receipt->status.value == sysio::chain::transaction_receipt_header::soft_fail)
         stat = sysio::chain::transaction_receipt_header::soft_fail;
      std::pair<uint8_t, bool> context = std::make_pair(stat, debug_mode);
      fc::raw::pack( //
          ds, make_history_context_wrapper(
                  obj.db, context,
                  sysio::state_history::augmented_transaction_trace{trace.failed_dtrx_trace, obj.obj.partial}));
   }
 
   bool include_partial = obj.obj.partial && !trace.failed_dtrx_trace;
   fc::raw::pack(ds, include_partial);
   if (include_partial) {
      auto& partial = *obj.obj.partial;
      fc::raw::pack(ds, fc::unsigned_int(0));
      fc::raw::pack(ds, as_type<sysio::chain::time_point_sec>(partial.expiration));
      fc::raw::pack(ds, as_type<uint16_t>(partial.ref_block_num));
      fc::raw::pack(ds, as_type<uint32_t>(partial.ref_block_prefix));
      fc::raw::pack(ds, as_type<fc::unsigned_int>(partial.max_net_usage_words));
      fc::raw::pack(ds, as_type<uint8_t>(partial.max_cpu_usage_ms));
      fc::raw::pack(ds, as_type<fc::unsigned_int>(partial.delay_sec));
      fc::raw::pack(ds, as_type<sysio::chain::extensions_type>(partial.transaction_extensions));
      fc::raw::pack(ds, as_type<std::vector<sysio::chain::signature_type>>(partial.signatures));
      fc::raw::pack(ds, as_type<std::vector<sysio::chain::bytes>>(partial.context_free_data));
   }
 
   return ds;
}

operator<<() [12/60]

template<typename ST >

datastream< ST > & fc::operator<<	(	datastream< ST > &	ds,
		const history_context_wrapper< sysio::chain::table_id_object, sysio::chain::index64_object > &	obj )

Definition at line 220 of file serialization.hpp.

                                                                                                    {
   return serialize_secondary_index(ds, obj.context, obj.obj);
}

Here is the call graph for this function:

operator<<() [13/60]

template<typename ST >

datastream< ST > & fc::operator<<	(	datastream< ST > &	ds,
		const history_context_wrapper< sysio::chain::table_id_object, sysio::chain::key_value_object > &	obj )

Definition at line 106 of file serialization.hpp.

                                                                                                      {
   fc::raw::pack(ds, fc::unsigned_int(0));
   fc::raw::pack(ds, as_type<uint64_t>(obj.context.code.to_uint64_t()));
   fc::raw::pack(ds, as_type<uint64_t>(obj.context.scope.to_uint64_t()));
   fc::raw::pack(ds, as_type<uint64_t>(obj.context.table.to_uint64_t()));
   fc::raw::pack(ds, as_type<uint64_t>(obj.obj.primary_key));
   fc::raw::pack(ds, as_type<uint64_t>(obj.obj.payer.to_uint64_t()));
   fc::raw::pack(ds, as_type<sysio::chain::shared_string>(obj.obj.value));
   return ds;
}

operator<<() [14/60]

template<typename ST , typename First , typename Second >

datastream< ST > & fc::operator<<	(	datastream< ST > &	ds,
		const history_serial_wrapper< std::pair< First, Second > > &	obj )

Definition at line 106 of file serialization.hpp.

                                                                                                          {
   fc::raw::pack(ds, obj.obj.first);
   fc::raw::pack(ds, obj.obj.second);
   return ds;
}

operator<<() [15/60]

template<typename ST , typename T >

datastream< ST > & fc::operator<<	(	datastream< ST > &	ds,
		const history_serial_wrapper< std::vector< T > > &	obj )

Definition at line 106 of file serialization.hpp.

                                                                                                {
   return history_serialize_container(ds, obj.db, obj.obj);
}

operator<<() [16/60]

template<typename ST >

datastream< ST > & fc::operator<<	(	datastream< ST > &	ds,
		const history_serial_wrapper< sysio::chain::account_delta > &	obj )

Definition at line 220 of file serialization.hpp.

                                                                                                           {
   fc::raw::pack(ds, as_type<uint64_t>(obj.obj.account.to_uint64_t()));
   fc::raw::pack(ds, as_type<int64_t>(obj.obj.delta));
   return ds;
}

operator<<() [17/60]

template<typename ST >

datastream< ST > & fc::operator<<	(	datastream< ST > &	ds,
		const history_serial_wrapper< sysio::chain::account_metadata_object > &	obj )

Definition at line 106 of file serialization.hpp.

                                                                                                 {
   fc::raw::pack(ds, fc::unsigned_int(0));
   fc::raw::pack(ds, as_type<uint64_t>(obj.obj.name.to_uint64_t()));
   fc::raw::pack(ds, as_type<bool>(obj.obj.is_privileged()));
   fc::raw::pack(ds, as_type<fc::time_point>(obj.obj.last_code_update));
   bool has_code = obj.obj.code_hash != sysio::chain::digest_type();
   fc::raw::pack(ds, has_code);
   if (has_code) {
      fc::raw::pack(ds, as_type<uint8_t>(obj.obj.vm_type));
      fc::raw::pack(ds, as_type<uint8_t>(obj.obj.vm_version));
      fc::raw::pack(ds, as_type<sysio::chain::digest_type>(obj.obj.code_hash));
   }
   return ds;
}

operator<<() [18/60]

template<typename ST >

datastream< ST > & fc::operator<<	(	datastream< ST > &	ds,
		const history_serial_wrapper< sysio::chain::account_object > &	obj )

Definition at line 106 of file serialization.hpp.

                                                                                                            {
   fc::raw::pack(ds, fc::unsigned_int(0));
   fc::raw::pack(ds, as_type<uint64_t>(obj.obj.name.to_uint64_t()));
   fc::raw::pack(ds, as_type<sysio::chain::block_timestamp_type>(obj.obj.creation_date));
   fc::raw::pack(ds, as_type<sysio::chain::shared_string>(obj.obj.abi));
   return ds;
}

operator<<() [19/60]

template<typename ST >

datastream< ST > & fc::operator<<	(	datastream< ST > &	ds,
		const history_serial_wrapper< sysio::chain::action > &	obj )

Definition at line 220 of file serialization.hpp.

                                                                                                    {
   fc::raw::pack(ds, as_type<uint64_t>(obj.obj.account.to_uint64_t()));
   fc::raw::pack(ds, as_type<uint64_t>(obj.obj.name.to_uint64_t()));
   history_serialize_container(ds, obj.db, as_type<std::vector<sysio::chain::permission_level>>(obj.obj.authorization));
   fc::raw::pack(ds, as_type<sysio::chain::bytes>(obj.obj.data));
   return ds;
}

operator<<() [20/60]

template<typename ST >

datastream< ST > & fc::operator<<	(	datastream< ST > &	ds,
		const history_serial_wrapper< sysio::chain::action_receipt > &	obj )

Definition at line 220 of file serialization.hpp.

                                                                                                            {
   fc::raw::pack(ds, fc::unsigned_int(0));
   fc::raw::pack(ds, as_type<uint64_t>(obj.obj.receiver.to_uint64_t()));
   fc::raw::pack(ds, as_type<sysio::chain::digest_type>(obj.obj.act_digest));
   fc::raw::pack(ds, as_type<uint64_t>(obj.obj.global_sequence));
   fc::raw::pack(ds, as_type<uint64_t>(obj.obj.recv_sequence));
   history_serialize_container(ds, obj.db, as_type<flat_map<sysio::chain::name, uint64_t>>(obj.obj.auth_sequence));
   fc::raw::pack(ds, as_type<fc::unsigned_int>(obj.obj.code_sequence));
   fc::raw::pack(ds, as_type<fc::unsigned_int>(obj.obj.abi_sequence));
   return ds;
}

operator<<() [21/60]

template<typename ST >

datastream< ST > & fc::operator<<	(	datastream< ST > &	ds,
		const history_serial_wrapper< sysio::chain::chain_config > &	obj )

Definition at line 220 of file serialization.hpp.

                                                                                                          {
   fc::raw::pack(ds, fc::unsigned_int(1));
   fc::raw::pack(ds, as_type<uint64_t>(obj.obj.max_block_net_usage));
   fc::raw::pack(ds, as_type<uint32_t>(obj.obj.target_block_net_usage_pct));
   fc::raw::pack(ds, as_type<uint32_t>(obj.obj.max_transaction_net_usage));
   fc::raw::pack(ds, as_type<uint32_t>(obj.obj.base_per_transaction_net_usage));
   fc::raw::pack(ds, as_type<uint32_t>(obj.obj.net_usage_leeway));
   fc::raw::pack(ds, as_type<uint32_t>(obj.obj.context_free_discount_net_usage_num));
   fc::raw::pack(ds, as_type<uint32_t>(obj.obj.context_free_discount_net_usage_den));
   fc::raw::pack(ds, as_type<uint32_t>(obj.obj.max_block_cpu_usage));
   fc::raw::pack(ds, as_type<uint32_t>(obj.obj.target_block_cpu_usage_pct));
   fc::raw::pack(ds, as_type<uint32_t>(obj.obj.max_transaction_cpu_usage));
   fc::raw::pack(ds, as_type<uint32_t>(obj.obj.min_transaction_cpu_usage));
   fc::raw::pack(ds, as_type<uint32_t>(obj.obj.max_transaction_lifetime));
   fc::raw::pack(ds, as_type<uint32_t>(obj.obj.deferred_trx_expiration_window));
   fc::raw::pack(ds, as_type<uint32_t>(obj.obj.max_transaction_delay));
   fc::raw::pack(ds, as_type<uint32_t>(obj.obj.max_inline_action_size));
   fc::raw::pack(ds, as_type<uint16_t>(obj.obj.max_inline_action_depth));
   fc::raw::pack(ds, as_type<uint16_t>(obj.obj.max_authority_depth));
   fc::raw::pack(ds, as_type<uint32_t>(obj.obj.max_action_return_value_size));
   return ds;
}

operator<<() [22/60]

template<typename ST >

datastream< ST > & fc::operator<<	(	datastream< ST > &	ds,
		const history_serial_wrapper< sysio::chain::code_object > &	obj )

Definition at line 106 of file serialization.hpp.

                                                                                                         {
   fc::raw::pack(ds, fc::unsigned_int(0));
   fc::raw::pack(ds, as_type<uint8_t>(obj.obj.vm_type));
   fc::raw::pack(ds, as_type<uint8_t>(obj.obj.vm_version));
   fc::raw::pack(ds, as_type<sysio::chain::digest_type>(obj.obj.code_hash));
   fc::raw::pack(ds, as_type<sysio::chain::shared_string>(obj.obj.code));
   return ds;
}

operator<<() [23/60]

template<typename ST >

datastream< ST > & fc::operator<<	(	datastream< ST > &	ds,
		const history_serial_wrapper< sysio::chain::generated_transaction_object > &	obj )

Definition at line 220 of file serialization.hpp.

                                                                                                      {
   fc::raw::pack(ds, fc::unsigned_int(0));
   fc::raw::pack(ds, as_type<uint64_t>(obj.obj.sender.to_uint64_t()));
   fc::raw::pack(ds, as_type<__uint128_t>(obj.obj.sender_id));
   fc::raw::pack(ds, as_type<uint64_t>(obj.obj.payer.to_uint64_t()));
   fc::raw::pack(ds, as_type<sysio::chain::transaction_id_type>(obj.obj.trx_id));
   fc::raw::pack(ds, as_type<sysio::chain::shared_string>(obj.obj.packed_trx));
   return ds;
}

operator<<() [24/60]

template<typename ST >

datastream< ST > & fc::operator<<	(	datastream< ST > &	ds,
		const history_serial_wrapper< sysio::chain::global_property_object > &	obj )

Definition at line 220 of file serialization.hpp.

                                                                                                {
   fc::raw::pack(ds, fc::unsigned_int(1));
   fc::raw::pack(ds, as_type<std::optional<sysio::chain::block_num_type>>(obj.obj.proposed_schedule_block_num));
   fc::raw::pack(ds, make_history_serial_wrapper(
                         obj.db, as_type<sysio::chain::shared_producer_authority_schedule>(obj.obj.proposed_schedule)));
   fc::raw::pack(ds, make_history_serial_wrapper(obj.db, as_type<sysio::chain::chain_config>(obj.obj.configuration)));
   fc::raw::pack(ds, as_type<sysio::chain::chain_id_type>(obj.obj.chain_id));
   fc::raw::pack(ds,
                 make_history_serial_wrapper(obj.db, as_type<sysio::chain::wasm_config>(obj.obj.wasm_configuration)));
   return ds;
}

operator<<() [25/60]

template<typename ST >

datastream< ST > & fc::operator<<	(	datastream< ST > &	ds,
		const history_serial_wrapper< sysio::chain::permission_level > &	obj )

Definition at line 220 of file serialization.hpp.

                                                                                                              {
   fc::raw::pack(ds, as_type<uint64_t>(obj.obj.actor.to_uint64_t()));
   fc::raw::pack(ds, as_type<uint64_t>(obj.obj.permission.to_uint64_t()));
   return ds;
}

operator<<() [26/60]

template<typename ST >

datastream< ST > & fc::operator<<	(	datastream< ST > &	ds,
		const history_serial_wrapper< sysio::chain::permission_level_weight > &	obj )

Definition at line 220 of file serialization.hpp.

                                                                                                 {
   fc::raw::pack(ds, make_history_serial_wrapper(obj.db, as_type<sysio::chain::permission_level>(obj.obj.permission)));
   fc::raw::pack(ds, as_type<uint16_t>(obj.obj.weight));
   return ds;
}

operator<<() [27/60]

template<typename ST >

datastream< ST > & fc::operator<<	(	datastream< ST > &	ds,
		const history_serial_wrapper< sysio::chain::permission_link_object > &	obj )

Definition at line 220 of file serialization.hpp.

                                                                                                {
   fc::raw::pack(ds, fc::unsigned_int(0));
   fc::raw::pack(ds, as_type<uint64_t>(obj.obj.account.to_uint64_t()));
   fc::raw::pack(ds, as_type<uint64_t>(obj.obj.code.to_uint64_t()));
   fc::raw::pack(ds, as_type<uint64_t>(obj.obj.message_type.to_uint64_t()));
   fc::raw::pack(ds, as_type<uint64_t>(obj.obj.required_permission.to_uint64_t()));
   return ds;
}

operator<<() [28/60]

template<typename ST >

datastream< ST > & fc::operator<<	(	datastream< ST > &	ds,
		const history_serial_wrapper< sysio::chain::permission_object > &	obj )

Definition at line 220 of file serialization.hpp.

                                                                                                               {
   fc::raw::pack(ds, fc::unsigned_int(0));
   fc::raw::pack(ds, as_type<uint64_t>(obj.obj.owner.to_uint64_t()));
   fc::raw::pack(ds, as_type<uint64_t>(obj.obj.name.to_uint64_t()));
   if (obj.obj.parent._id) {
      auto&       index  = obj.db.get_index<sysio::chain::permission_index>();
      const auto* parent = index.find(obj.obj.parent);
      if (!parent) {
         auto undo = index.last_undo_session();
         auto it   = std::find_if(undo.removed_values.begin(), undo.removed_values.end(),
                                [&](auto& x) { return x.id._id == obj.obj.parent; });
         SYS_ASSERT(it != undo.removed_values.end(), sysio::chain::plugin_exception,
                    "can not find parent of permission_object");
         parent = &*it;
      }
      fc::raw::pack(ds, as_type<uint64_t>(parent->name.to_uint64_t()));
   } else {
      fc::raw::pack(ds, as_type<uint64_t>(0));
   }
   fc::raw::pack(ds, as_type<fc::time_point>(obj.obj.last_updated));
   fc::raw::pack(ds, make_history_serial_wrapper(obj.db, as_type<sysio::chain::shared_authority>(obj.obj.auth)));
   return ds;
}

operator<<() [29/60]

template<typename ST >

datastream< ST > & fc::operator<<	(	datastream< ST > &	ds,
		const history_serial_wrapper< sysio::chain::protocol_state_object > &	obj )

Definition at line 220 of file serialization.hpp.

                                                                                                                   {
   fc::raw::pack(ds, fc::unsigned_int(0));
   history_serialize_container(ds, obj.db, obj.obj.activated_protocol_features);
   return ds;
}

operator<<() [30/60]

template<typename ST >

datastream< ST > & fc::operator<<	(	datastream< ST > &	ds,
		const history_serial_wrapper< sysio::chain::protocol_state_object::activated_protocol_feature > &	obj )

Definition at line 220 of file serialization.hpp.

                                                                                                         {
   fc::raw::pack(ds, fc::unsigned_int(0));
   fc::raw::pack(ds, as_type<sysio::chain::digest_type>(obj.obj.feature_digest));
   fc::raw::pack(ds, as_type<uint32_t>(obj.obj.activation_block_num));
   return ds;
}

operator<<() [31/60]

template<typename ST >

datastream< ST > & fc::operator<<	(	datastream< ST > &	ds,
		const history_serial_wrapper< sysio::chain::resource_limits::elastic_limit_parameters > &	obj )

Definition at line 220 of file serialization.hpp.

                                                                                                                 {
   fc::raw::pack(ds, fc::unsigned_int(0));
   fc::raw::pack(ds, as_type<uint64_t>(obj.obj.target));
   fc::raw::pack(ds, as_type<uint64_t>(obj.obj.max));
   fc::raw::pack(ds, as_type<uint32_t>(obj.obj.periods));
   fc::raw::pack(ds, as_type<uint32_t>(obj.obj.max_multiplier));
   fc::raw::pack(
       ds, make_history_serial_wrapper(obj.db, as_type<sysio::chain::resource_limits::ratio>(obj.obj.contract_rate)));
   fc::raw::pack(
       ds, make_history_serial_wrapper(obj.db, as_type<sysio::chain::resource_limits::ratio>(obj.obj.expand_rate)));
   return ds;
}

operator<<() [32/60]

template<typename ST >

datastream< ST > & fc::operator<<	(	datastream< ST > &	ds,
		const history_serial_wrapper< sysio::chain::resource_limits::ratio > &	obj )

Definition at line 220 of file serialization.hpp.

                                                                                              {
   fc::raw::pack(ds, fc::unsigned_int(0));
   fc::raw::pack(ds, as_type<uint64_t>(obj.obj.numerator));
   fc::raw::pack(ds, as_type<uint64_t>(obj.obj.denominator));
   return ds;
}

operator<<() [33/60]

template<typename ST >

datastream< ST > & fc::operator<<	(	datastream< ST > &	ds,
		const history_serial_wrapper< sysio::chain::resource_limits::resource_limits_config_object > &	obj )

Definition at line 220 of file serialization.hpp.

                                                                                                      {
   fc::raw::pack(ds, fc::unsigned_int(0));
   fc::raw::pack(
       ds, make_history_serial_wrapper(
               obj.db, as_type<sysio::chain::resource_limits::elastic_limit_parameters>(obj.obj.cpu_limit_parameters)));
   fc::raw::pack(
       ds, make_history_serial_wrapper(
               obj.db, as_type<sysio::chain::resource_limits::elastic_limit_parameters>(obj.obj.net_limit_parameters)));
   fc::raw::pack(ds, as_type<uint32_t>(obj.obj.account_cpu_usage_average_window));
   fc::raw::pack(ds, as_type<uint32_t>(obj.obj.account_net_usage_average_window));
   return ds;
};

operator<<() [34/60]

template<typename ST >

datastream< ST > & fc::operator<<	(	datastream< ST > &	ds,
		const history_serial_wrapper< sysio::chain::resource_limits::resource_limits_object > &	obj )

Definition at line 220 of file serialization.hpp.

                                                                                                               {
   SYS_ASSERT(!obj.obj.pending, sysio::chain::plugin_exception,
              "accepted_block sent while resource_limits_object in pending state");
   fc::raw::pack(ds, fc::unsigned_int(0));
   fc::raw::pack(ds, as_type<uint64_t>(obj.obj.owner.to_uint64_t()));
   fc::raw::pack(ds, as_type<int64_t>(obj.obj.net_weight));
   fc::raw::pack(ds, as_type<int64_t>(obj.obj.cpu_weight));
   fc::raw::pack(ds, as_type<int64_t>(obj.obj.ram_bytes));
   return ds;
}

operator<<() [35/60]

template<typename ST >

datastream< ST > & fc::operator<<	(	datastream< ST > &	ds,
		const history_serial_wrapper< sysio::chain::resource_limits::resource_limits_state_object > &	obj )

Definition at line 220 of file serialization.hpp.

                                                                                                     {
   fc::raw::pack(ds, fc::unsigned_int(0));
   fc::raw::pack(ds, make_history_serial_wrapper(obj.db, as_type<sysio::chain::resource_limits::usage_accumulator>(
                                                             obj.obj.average_block_net_usage)));
   fc::raw::pack(ds, make_history_serial_wrapper(obj.db, as_type<sysio::chain::resource_limits::usage_accumulator>(
                                                             obj.obj.average_block_cpu_usage)));
   fc::raw::pack(ds, as_type<uint64_t>(obj.obj.total_net_weight));
   fc::raw::pack(ds, as_type<uint64_t>(obj.obj.total_cpu_weight));
   fc::raw::pack(ds, as_type<uint64_t>(obj.obj.total_ram_bytes));
   fc::raw::pack(ds, as_type<uint64_t>(obj.obj.virtual_net_limit));
   fc::raw::pack(ds, as_type<uint64_t>(obj.obj.virtual_cpu_limit));
   return ds;
}

operator<<() [36/60]

template<typename ST >

datastream< ST > & fc::operator<<	(	datastream< ST > &	ds,
		const history_serial_wrapper< sysio::chain::resource_limits::resource_usage_object > &	obj )

Definition at line 220 of file serialization.hpp.

                                                                                                              {
   fc::raw::pack(ds, fc::unsigned_int(0));
   fc::raw::pack(ds, as_type<uint64_t>(obj.obj.owner.to_uint64_t()));
   fc::raw::pack(ds, make_history_serial_wrapper(
                         obj.db, as_type<sysio::chain::resource_limits::usage_accumulator>(obj.obj.net_usage)));
   fc::raw::pack(ds, make_history_serial_wrapper(
                         obj.db, as_type<sysio::chain::resource_limits::usage_accumulator>(obj.obj.cpu_usage)));
   fc::raw::pack(ds, as_type<uint64_t>(obj.obj.ram_usage));
   return ds;
}

operator<<() [37/60]

template<typename ST >

datastream< ST > & fc::operator<<	(	datastream< ST > &	ds,
		const history_serial_wrapper< sysio::chain::resource_limits::usage_accumulator > &	obj )

Definition at line 220 of file serialization.hpp.

                                                                                                          {
   fc::raw::pack(ds, fc::unsigned_int(0));
   fc::raw::pack(ds, as_type<uint32_t>(obj.obj.last_ordinal));
   fc::raw::pack(ds, as_type<uint64_t>(obj.obj.value_ex));
   fc::raw::pack(ds, as_type<uint64_t>(obj.obj.consumed));
   return ds;
}

operator<<() [38/60]

template<typename ST >

datastream< ST > & fc::operator<<	(	datastream< ST > &	ds,
		const history_serial_wrapper< sysio::chain::shared_authority > &	obj )

Definition at line 220 of file serialization.hpp.

                                                                                                              {
   fc::raw::pack(ds, as_type<uint32_t>(obj.obj.threshold));
   history_serialize_container(ds, obj.db, obj.obj.keys);
   history_serialize_container(ds, obj.db, obj.obj.accounts);
   history_serialize_container(ds, obj.db, obj.obj.waits);
   return ds;
}

operator<<() [39/60]

template<typename ST >

datastream< ST > & fc::operator<<	(	datastream< ST > &	ds,
		const history_serial_wrapper< sysio::chain::shared_block_signing_authority_v0 > &	obj )

Definition at line 220 of file serialization.hpp.

                                                                                                           {
   fc::raw::pack(ds, as_type<uint32_t>(obj.obj.threshold));
   history_serialize_container(ds, obj.db,
                               as_type<sysio::chain::shared_vector<sysio::chain::shared_key_weight>>(obj.obj.keys));
}

operator<<() [40/60]

template<typename ST >

datastream< ST > & fc::operator<<	(	datastream< ST > &	ds,
		const history_serial_wrapper< sysio::chain::shared_key_weight > &	obj )

Definition at line 220 of file serialization.hpp.

                                                                                                               {
   fc::raw::pack(ds, as_type<sysio::chain::public_key_type>(obj.obj.key));
   fc::raw::pack(ds, as_type<uint16_t>(obj.obj.weight));
   return ds;
}

operator<<() [41/60]

template<typename ST >

datastream< ST > & fc::operator<<	(	datastream< ST > &	ds,
		const history_serial_wrapper< sysio::chain::shared_producer_authority > &	obj )

Definition at line 220 of file serialization.hpp.

                                                                                                   {
   fc::raw::pack(ds, as_type<uint64_t>(obj.obj.producer_name.to_uint64_t()));
   fc::raw::pack(ds, as_type<sysio::chain::shared_block_signing_authority>(obj.obj.authority));
   return ds;
}

operator<<() [42/60]

template<typename ST >

datastream< ST > & fc::operator<<	(	datastream< ST > &	ds,
		const history_serial_wrapper< sysio::chain::shared_producer_authority_schedule > &	obj )

Definition at line 220 of file serialization.hpp.

                                                                                                            {
   fc::raw::pack(ds, as_type<uint32_t>(obj.obj.version));
   history_serialize_container(
       ds, obj.db, as_type<sysio::chain::shared_vector<sysio::chain::shared_producer_authority>>(obj.obj.producers));
   return ds;
}

operator<<() [43/60]

template<typename ST >

datastream< ST > & fc::operator<<	(	datastream< ST > &	ds,
		const history_serial_wrapper< sysio::chain::table_id_object > &	obj )

Definition at line 106 of file serialization.hpp.

                                                                                                             {
   fc::raw::pack(ds, fc::unsigned_int(0));
   fc::raw::pack(ds, as_type<uint64_t>(obj.obj.code.to_uint64_t()));
   fc::raw::pack(ds, as_type<uint64_t>(obj.obj.scope.to_uint64_t()));
   fc::raw::pack(ds, as_type<uint64_t>(obj.obj.table.to_uint64_t()));
   fc::raw::pack(ds, as_type<uint64_t>(obj.obj.payer.to_uint64_t()));
   return ds;
}

operator<<() [44/60]

template<typename ST >

datastream< ST > & fc::operator<<	(	datastream< ST > &	ds,
		const history_serial_wrapper< sysio::chain::wait_weight > &	obj )

Definition at line 220 of file serialization.hpp.

                                                                                                         {
   fc::raw::pack(ds, as_type<uint32_t>(obj.obj.wait_sec));
   fc::raw::pack(ds, as_type<uint16_t>(obj.obj.weight));
   return ds;
}

operator<<() [45/60]

template<typename ST >

datastream< ST > & fc::operator<<	(	datastream< ST > &	ds,
		const history_serial_wrapper< sysio::chain::wasm_config > &	obj )

Definition at line 220 of file serialization.hpp.

                                                                                                         {
   fc::raw::pack(ds, fc::unsigned_int(0));
   fc::raw::pack(ds, as_type<uint32_t>(obj.obj.max_mutable_global_bytes));
   fc::raw::pack(ds, as_type<uint32_t>(obj.obj.max_table_elements));
   fc::raw::pack(ds, as_type<uint32_t>(obj.obj.max_section_elements));
   fc::raw::pack(ds, as_type<uint32_t>(obj.obj.max_linear_memory_init));
   fc::raw::pack(ds, as_type<uint32_t>(obj.obj.max_func_local_bytes));
   fc::raw::pack(ds, as_type<uint32_t>(obj.obj.max_nested_structures));
   fc::raw::pack(ds, as_type<uint32_t>(obj.obj.max_symbol_bytes));
   fc::raw::pack(ds, as_type<uint32_t>(obj.obj.max_module_bytes));
   fc::raw::pack(ds, as_type<uint32_t>(obj.obj.max_code_bytes));
   fc::raw::pack(ds, as_type<uint32_t>(obj.obj.max_pages));
   fc::raw::pack(ds, as_type<uint32_t>(obj.obj.max_call_depth));
   return ds;
}

operator<<() [46/60]

template<typename ST >

datastream< ST > & fc::operator<< ( datastream< ST > & ds, const int16_t & d )

inline

Definition at line 246 of file datastream.hpp.

                                                                        {
  ds.write( (const char*)&d, sizeof(d) );
  return ds;
}

operator<<() [47/60]

template<typename ST >

datastream< ST > & fc::operator<< ( datastream< ST > & ds, const int32_t & d )

inline

Definition at line 222 of file datastream.hpp.

                                                                        {
  ds.write( (const char*)&d, sizeof(d) );
  return ds;
}

operator<<() [48/60]

template<typename ST >

datastream< ST > & fc::operator<< ( datastream< ST > & ds, const int64_t & d )

inline

Definition at line 198 of file datastream.hpp.

                                                                        {
  ds.write( (const char*)&d, sizeof(d) );
  return ds;
}

operator<<() [49/60]

template<typename ST >

datastream< ST > & fc::operator<< ( datastream< ST > & ds, const int8_t & d )

inline

Definition at line 270 of file datastream.hpp.

                                                                       {
  ds.write( (const char*)&d, sizeof(d) );
  return ds;
}

operator<<() [50/60]

template<typename ST , typename T >

datastream< ST > & fc::operator<<	(	datastream< ST > &	ds,
		const sysio::state_history::big_vector_wrapper< T > &	obj )

Definition at line 70 of file serialization.hpp.

                                                                                                   {
   FC_ASSERT(obj.obj.size() <= 1024 * 1024 * 1024);
   fc::raw::pack(ds, unsigned_int((uint32_t)obj.obj.size()));
   for (auto& x : obj.obj)
      fc::raw::pack(ds, x);
   return ds;
}

operator<<() [51/60]

template<typename ST >

datastream< ST > & fc::operator<<	(	datastream< ST > &	ds,
		const sysio::state_history::get_blocks_result_v0 &	obj )

Definition at line 572 of file serialization.hpp.

                                                                                                  {
   fc::raw::pack(ds, obj.head);
   fc::raw::pack(ds, obj.last_irreversible);
   fc::raw::pack(ds, obj.this_block);
   fc::raw::pack(ds, obj.prev_block);
   history_pack_big_bytes(ds, obj.block);
   history_pack_big_bytes(ds, obj.traces);
   history_pack_big_bytes(ds, obj.deltas);
   return ds;
}

operator<<() [52/60]

template<typename ST >

datastream< ST > & fc::operator<< ( datastream< ST > & ds, const uint16_t & d )

inline

Definition at line 258 of file datastream.hpp.

                                                                         {
  ds.write( (const char*)&d, sizeof(d) );
  return ds;
}

operator<<() [53/60]

template<typename ST >

datastream< ST > & fc::operator<< ( datastream< ST > & ds, const uint32_t & d )

inline

Definition at line 234 of file datastream.hpp.

                                                                         {
  ds.write( (const char*)&d, sizeof(d) );
  return ds;
}

operator<<() [54/60]

template<typename ST >

datastream< ST > & fc::operator<< ( datastream< ST > & ds, const uint64_t & d )

inline

Definition at line 210 of file datastream.hpp.

                                                                         {
  ds.write( (const char*)&d, sizeof(d) );
  return ds;
}

operator<<() [55/60]

template<typename ST >

datastream< ST > & fc::operator<< ( datastream< ST > & ds, const uint8_t & d )

inline

Definition at line 281 of file datastream.hpp.

                                                                        {
  ds.write( (const char*)&d, sizeof(d) );
  return ds;
}

operator<<() [56/60]

template<typename ST >

datastream< ST > & fc::operator<< ( datastream< ST > & ds, const unsigned __int128 & d )

inline

Definition at line 186 of file datastream.hpp.

                                                                                  {
  ds.write( (const char*)&d, sizeof(d) );
  return ds;
}

operator<<() [57/60]

template<typename ST , typename T >

datastream< ST > & fc::operator<<	(	datastream< ST > &	s,
		const sysio::chain::may_not_exist< T > &	v )

Definition at line 133 of file abi_def.hpp.

                                                                                     {
   raw::pack(s, v.value);
   return s;
}

operator<<() [58/60]

std::ostream & fc::operator<<	(	std::ostream &	os,
		const fc::microseconds &	t )

Definition at line 254 of file test_common.hpp.

                                                                    {
      os << t.count();
      return os;
   }

Here is the call graph for this function:

operator<<() [59/60]

template<typename ... Ts>

std::ostream & fc::operator<<	(	std::ostream &	os,
		const std::variant< Ts... > &	v )

Definition at line 249 of file test_common.hpp.

                                                                       {
      os << fc::json::to_string(v, fc::time_point::maximum());
      return os;
   }

Here is the call graph for this function:

operator<<() [60/60]

template<typename T , unsigned int S, typename U , typename A >

auto fc::operator<<	(	U &	u,
		const fwd< T, S, A > &	f ) -> typename detail::insert_op<U,T>::type

Definition at line 48 of file fwd_impl.hpp.

{ return u << *f; }

operator<=()

bool fc::operator<=	(	const variant &	a,
		const variant &	b )

Definition at line 913 of file variant.cpp.

   {
      if( a.is_string()  || b.is_string() ) return a.as_string() <= b.as_string();
      if( a.is_double()  || b.is_double() ) return a.as_double() <= b.as_double();
      if( a.is_int64()   || b.is_int64() )  return a.as_int64() <= b.as_int64();
      if( a.is_uint64()  || b.is_uint64() ) return a.as_uint64() <= b.as_uint64();
      FC_ASSERT( false, "Invalid operation" );
   }

Here is the call graph for this function:

operator==() [1/13]

template<typename T , size_t N>

bool fc::operator==	(	const array< T, N > &	a,
		const array< T, N > &	b )

Definition at line 91 of file array.hpp.

  { return 0 == memcmp( a.data, b.data, N*sizeof(T) ); }

operator==() [2/13]

bool fc::operator==	(	const directory_iterator &	r,
		const directory_iterator &	l )

Definition at line 188 of file filesystem.cpp.

                                                                                 {
        return *r._p == *l._p;
      }

operator==() [3/13]

bool fc::operator==	(	const fc::path &	l,
		const fc::path &	r )

Definition at line 82 of file filesystem.cpp.

{ return *l._p == *r._p; }

operator==() [4/13]

bool fc::operator==	(	const fc::variant &	a,
		const fc::variant &	b )

Definition at line 875 of file variant.cpp.

   {
      if( a.is_string()  || b.is_string() ) return a.as_string() == b.as_string();
      if( a.is_double()  || b.is_double() ) return a.as_double() == b.as_double();
      if( a.is_int64()   || b.is_int64() )  return a.as_int64() == b.as_int64();
      if( a.is_uint64()  || b.is_uint64() ) return a.as_uint64() == b.as_uint64();
      if( a.is_array()   || b.is_array() )  return a.get_array() == b.get_array();
      return false;
   }

Here is the call graph for this function:

operator==() [5/13]

bool fc::operator==	(	const logger &	l,
		std::nullptr_t	)

Definition at line 55 of file logger.cpp.

{ return !l.my; }

operator==() [6/13]

bool fc::operator==	(	const private_key &	a,
		const private_key &	b )

operator==() [7/13]

bool fc::operator==	(	const recursive_directory_iterator &	r,
		const recursive_directory_iterator &	l )

Definition at line 209 of file filesystem.cpp.

                                                                                                     {
        return *r._p == *l._p;
      }

operator==() [8/13]

bool fc::operator==	(	const ripemd160 &	h1,
		const ripemd160 &	h2 )

Definition at line 99 of file ripemd160.cpp.

                                                              {
  return memcmp( h1._hash, h2._hash, sizeof(h1._hash) ) == 0;
}

operator==() [9/13]

bool fc::operator==	(	const sha1 &	h1,
		const sha1 &	h2 )

Definition at line 85 of file sha1.cpp.

                                                    {
  return memcmp( h1._hash, h2._hash, sizeof(h1._hash) ) == 0;
}

operator==() [10/13]

bool fc::operator==	(	const sha224 &	h1,
		const sha224 &	h2 )

Definition at line 80 of file sha224.cpp.

                                                            {
      return memcmp( h1._hash, h2._hash, sizeof(sha224) ) == 0;
    }

operator==() [11/13]

bool fc::operator==	(	const sha256 &	h1,
		const sha256 &	h2 )

Definition at line 101 of file sha256.cpp.

                                                            {
       // idea to not use memcmp, from:
       //   https://lemire.me/blog/2018/08/22/avoid-lexicographical-comparisons-when-testing-for-string-equality/
       return
             h1._hash[0] == h2._hash[0] &&
             h1._hash[1] == h2._hash[1] &&
             h1._hash[2] == h2._hash[2] &&
             h1._hash[3] == h2._hash[3];
    }

operator==() [12/13]

bool fc::operator==	(	const sha3 &	h1,
		const sha3 &	h2 )

Definition at line 266 of file sha3.cpp.

{
    // idea to not use memcmp, from:
    //   https://lemire.me/blog/2018/08/22/avoid-lexicographical-comparisons-when-testing-for-string-equality/
    return h1._hash[0] == h2._hash[0] &&
             h1._hash[1] == h2._hash[1] &&
             h1._hash[2] == h2._hash[2] &&
             h1._hash[3] == h2._hash[3];
}

operator==() [13/13]

bool fc::operator==	(	const sha512 &	h1,
		const sha512 &	h2 )

Definition at line 87 of file sha512.cpp.

                                                            {
      return memcmp( h1._hash, h2._hash, sizeof(h1._hash) ) == 0;
    }

operator>() [1/8]

template<typename T , size_t N>

bool fc::operator>	(	const array< T, N > &	a,
		const array< T, N > &	b )

Definition at line 98 of file array.hpp.

  { return  memcmp( a.data, b.data, N*sizeof(T) ) > 0 ; }

operator>() [2/8]

bool fc::operator>	(	const fc::variant &	a,
		const fc::variant &	b )

Definition at line 904 of file variant.cpp.

   {
      if( a.is_string()  || b.is_string() ) return a.as_string() > b.as_string();
      if( a.is_double()  || b.is_double() ) return a.as_double() > b.as_double();
      if( a.is_int64()   || b.is_int64() )  return a.as_int64() > b.as_int64();
      if( a.is_uint64()  || b.is_uint64() ) return a.as_uint64() > b.as_uint64();
      FC_ASSERT( false, "Invalid operation" );
   }

Here is the call graph for this function:

operator>() [3/8]

bool fc::operator>	(	const ripemd160 &	h1,
		const ripemd160 &	h2 )

Definition at line 90 of file ripemd160.cpp.

                                                             {
  return memcmp( h1._hash, h2._hash, sizeof(h1._hash) ) > 0;
}

operator>() [4/8]

bool fc::operator>	(	const sha1 &	h1,
		const sha1 &	h2 )

Definition at line 76 of file sha1.cpp.

                                                   {
  return memcmp( h1._hash, h2._hash, sizeof(h1._hash) ) > 0;
}

operator>() [5/8]

bool fc::operator>	(	const sha224 &	h1,
		const sha224 &	h2 )

Definition at line 71 of file sha224.cpp.

                                                           {
      return memcmp( h1._hash, h2._hash, sizeof(sha224) ) > 0;
    }

operator>() [6/8]

bool fc::operator>	(	const sha256 &	h1,
		const sha256 &	h2 )

Definition at line 92 of file sha256.cpp.

                                                           {
      return memcmp( h1._hash, h2._hash, sizeof(h1._hash) ) > 0;
    }

operator>() [7/8]

bool fc::operator>	(	const sha3 &	h1,
		const sha3 &	h2 )

Definition at line 254 of file sha3.cpp.

{
    return memcmp(h1._hash, h2._hash, sizeof(h1._hash)) > 0;
}

operator>() [8/8]

bool fc::operator>	(	const sha512 &	h1,
		const sha512 &	h2 )

Definition at line 78 of file sha512.cpp.

                                                           {
      return memcmp( h1._hash, h2._hash, sizeof(h1._hash) ) > 0;
    }

operator>=() [1/6]

bool fc::operator>=	(	const ripemd160 &	h1,
		const ripemd160 &	h2 )

Definition at line 87 of file ripemd160.cpp.

                                                              {
  return memcmp( h1._hash, h2._hash, sizeof(h1._hash) ) >= 0;
}

operator>=() [2/6]

bool fc::operator>=	(	const sha1 &	h1,
		const sha1 &	h2 )

Definition at line 73 of file sha1.cpp.

                                                    {
  return memcmp( h1._hash, h2._hash, sizeof(h1._hash) ) >= 0;
}

operator>=() [3/6]

bool fc::operator>=	(	const sha224 &	h1,
		const sha224 &	h2 )

Definition at line 68 of file sha224.cpp.

                                                            {
      return memcmp( h1._hash, h2._hash, sizeof(sha224) ) >= 0;
    }

operator>=() [4/6]

bool fc::operator>=	(	const sha256 &	h1,
		const sha256 &	h2 )

Definition at line 89 of file sha256.cpp.

                                                            {
      return memcmp( h1._hash, h2._hash, sizeof(h1._hash) ) >= 0;
    }

operator>=() [5/6]

bool fc::operator>=	(	const sha3 &	h1,
		const sha3 &	h2 )

Definition at line 250 of file sha3.cpp.

{
    return memcmp(h1._hash, h2._hash, sizeof(h1._hash)) >= 0;
}

operator>=() [6/6]

bool fc::operator>=	(	const sha512 &	h1,
		const sha512 &	h2 )

Definition at line 75 of file sha512.cpp.

                                                            {
      return memcmp( h1._hash, h2._hash, sizeof(h1._hash) ) >= 0;
    }

operator>>() [1/14]

sha256 fc::operator>>	(	const sha256 &	h1,
		uint32_t	i )

Definition at line 76 of file sha256.cpp.

                                                        {
      sha256 result;
      fc::detail::shift_r( h1.data(), result.data(), result.data_size(), i );
      return result;
    }

operator>>() [2/14]

sha3 fc::operator>>	(	const sha3 &	h1,
		uint32_t	i )

Definition at line 235 of file sha3.cpp.

{
    sha3 result;
    fc::detail::shift_r(h1.data(), result.data(), result.data_size(), i);
    return result;
}

operator>>() [3/14]

template<typename ST , typename DATA >

datastream< ST > & fc::operator>> ( datastream< ST > & ds, __int128 & d )

inline

Definition at line 186 of file datastream.hpp.

                                                                   {
  ds.read((char*)&d, sizeof(d) );
  return ds;
}

operator>>() [4/14]

template<typename ST , typename DATA >

datastream< ST > & fc::operator>> ( datastream< ST > & ds, int16_t & d )

inline

Definition at line 258 of file datastream.hpp.

                                                                  {
  ds.read((char*)&d, sizeof(d) );
  return ds;
}

operator>>() [5/14]

template<typename ST , typename DATA >

datastream< ST > & fc::operator>> ( datastream< ST > & ds, int32_t & d )

inline

Definition at line 234 of file datastream.hpp.

                                                                  {
  ds.read((char*)&d, sizeof(d) );
  return ds;
}

operator>>() [6/14]

template<typename ST , typename DATA >

datastream< ST > & fc::operator>> ( datastream< ST > & ds, int64_t & d )

inline

Definition at line 210 of file datastream.hpp.

                                                                  {
  ds.read((char*)&d, sizeof(d) );
  return ds;
}

operator>>() [7/14]

template<typename ST , typename DATA >

datastream< ST > & fc::operator>> ( datastream< ST > & ds, int8_t & d )

inline

Definition at line 281 of file datastream.hpp.

                                                                 {
  ds.read((char*)&d, sizeof(d) );
  return ds;
}

operator>>() [8/14]

template<typename ST , typename DATA >

datastream< ST > & fc::operator>> ( datastream< ST > & ds, uint16_t & d )

inline

Definition at line 270 of file datastream.hpp.

                                                                   {
  ds.read((char*)&d, sizeof(d) );
  return ds;
}

operator>>() [9/14]

template<typename ST , typename DATA >

datastream< ST > & fc::operator>> ( datastream< ST > & ds, uint32_t & d )

inline

Definition at line 246 of file datastream.hpp.

                                                                   {
  ds.read((char*)&d, sizeof(d) );
  return ds;
}

operator>>() [10/14]

template<typename ST , typename DATA >

datastream< ST > & fc::operator>> ( datastream< ST > & ds, uint64_t & d )

inline

Definition at line 222 of file datastream.hpp.

                                                                   {
  ds.read((char*)&d, sizeof(d) );
  return ds;
}

operator>>() [11/14]

template<typename ST , typename DATA >

datastream< ST > & fc::operator>> ( datastream< ST > & ds, uint8_t & d )

inline

Definition at line 292 of file datastream.hpp.

                                                                  {
  ds.read((char*)&d, sizeof(d) );
  return ds;
}

operator>>() [12/14]

template<typename ST , typename DATA >

datastream< ST > & fc::operator>> ( datastream< ST > & ds, unsigned __int128 & d )

inline

Definition at line 198 of file datastream.hpp.

                                                                            {
  ds.read((char*)&d, sizeof(d) );
  return ds;
}

operator>>() [13/14]

template<typename ST , typename T >

datastream< ST > & fc::operator>>	(	datastream< ST > &	s,
		sysio::chain::may_not_exist< T > &	v )

Definition at line 152 of file abi_def.hpp.

                                                                               {
   if (s.remaining())
      raw::unpack(s, v.value);
   return s;
}

Here is the call graph for this function:

operator>>() [14/14]

template<typename T , unsigned int S, typename U , typename A >

auto fc::operator>>	(	U &	u,
		fwd< T, S, A > &	f ) -> typename detail::extract_op<U,T>::type

Definition at line 51 of file fwd_impl.hpp.

{ return u >> *f; }

operator^() [1/7]

bloom_filter fc::operator^ ( const bloom_filter & a, const bloom_filter & b )

inline

Definition at line 596 of file bloom_filter.hpp.

{
   bloom_filter result = a;
   result ^= b;
   return result;
}

operator^() [2/7]

ripemd160 fc::operator^	(	const ripemd160 &	h1,
		const ripemd160 &	h2 )

Definition at line 78 of file ripemd160.cpp.

                                                                  {
  ripemd160 result;
  result._hash[0] = h1._hash[0] ^ h2._hash[0];
  result._hash[1] = h1._hash[1] ^ h2._hash[1];
  result._hash[2] = h1._hash[2] ^ h2._hash[2];
  result._hash[3] = h1._hash[3] ^ h2._hash[3];
  result._hash[4] = h1._hash[4] ^ h2._hash[4];
  return result;
}

operator^() [3/7]

sha1 fc::operator^	(	const sha1 &	h1,
		const sha1 &	h2 )

Definition at line 64 of file sha1.cpp.

                                                   {
  sha1 result;
  result._hash[0] = h1._hash[0] ^ h2._hash[0];
  result._hash[1] = h1._hash[1] ^ h2._hash[1];
  result._hash[2] = h1._hash[2] ^ h2._hash[2];
  result._hash[3] = h1._hash[3] ^ h2._hash[3];
  result._hash[4] = h1._hash[4] ^ h2._hash[4];
  return result;
}

operator^() [4/7]

sha224 fc::operator^	(	const sha224 &	h1,
		const sha224 &	h2 )

Definition at line 62 of file sha224.cpp.

                                                             {
      sha224 result;
      for( uint32_t i = 0; i < 7; ++i )
      result._hash[i] = h1._hash[i] ^ h2._hash[i];
      return result;
    }

operator^() [5/7]

sha256 fc::operator^	(	const sha256 &	h1,
		const sha256 &	h2 )

Definition at line 81 of file sha256.cpp.

                                                             {
      sha256 result;
      result._hash[0] = h1._hash[0] ^ h2._hash[0];
      result._hash[1] = h1._hash[1] ^ h2._hash[1];
      result._hash[2] = h1._hash[2] ^ h2._hash[2];
      result._hash[3] = h1._hash[3] ^ h2._hash[3];
      return result;
    }

operator^() [6/7]

sha3 fc::operator^	(	const sha3 &	h1,
		const sha3 &	h2 )

Definition at line 241 of file sha3.cpp.

{
    sha3 result;
    result._hash[0] = h1._hash[0] ^ h2._hash[0];
    result._hash[1] = h1._hash[1] ^ h2._hash[1];
    result._hash[2] = h1._hash[2] ^ h2._hash[2];
    result._hash[3] = h1._hash[3] ^ h2._hash[3];
    return result;
}

operator^() [7/7]

sha512 fc::operator^	(	const sha512 &	h1,
		const sha512 &	h2 )

Definition at line 63 of file sha512.cpp.

                                                             {
      sha512 result;
      result._hash[0] = h1._hash[0] ^ h2._hash[0];
      result._hash[1] = h1._hash[1] ^ h2._hash[1];
      result._hash[2] = h1._hash[2] ^ h2._hash[2];
      result._hash[3] = h1._hash[3] ^ h2._hash[3];
      result._hash[4] = h1._hash[4] ^ h2._hash[4];
      result._hash[5] = h1._hash[5] ^ h2._hash[5];
      result._hash[6] = h1._hash[6] ^ h2._hash[6];
      result._hash[7] = h1._hash[7] ^ h2._hash[7];
      return result;
    }

operator|()

bloom_filter fc::operator| ( const bloom_filter & a, const bloom_filter & b )

inline

Definition at line 589 of file bloom_filter.hpp.

{
   bloom_filter result = a;
   result |= b;
   return result;
}

overloaded()

template<class... Ts>

fc::overloaded

(

Ts...

)

-> overloaded< Ts... >

parseEscape()

template<typename T >

char fc::parseEscape

(

T &

in

)

Definition at line 36 of file json.cpp.

   {
      if( in.peek() == '\\' )
      {
         try {
            in.get();
            switch( in.peek() )
            {
               case 't':
                  in.get();
                  return '\t';
               case 'n':
                  in.get();
                  return '\n';
               case 'r':
                  in.get();
                  return '\r';
               case '\\':
                  in.get();
                  return '\\';
               default:
                  return in.get();
            }
         } FC_RETHROW_EXCEPTIONS( info, "Stream ended with '\\'" );
      }
        FC_THROW_EXCEPTION( parse_error_exception, "Expected '\\'"  );
   }

Here is the caller graph for this function:

pretty_print()

std::string fc::pretty_print	(	const std::string &	v,
		uint8_t	indent )

Definition at line 682 of file json.cpp.

                                                                      {
      int level = 0;
      std::stringstream ss;
      bool first = false;
      bool quote = false;
      bool escape = false;
      for( uint32_t i = 0; i < v.size(); ++i ) {
         switch( v[i] ) {
            case '\\':
              if( !escape ) {
                if( quote )
                  escape = true;
              } else { escape = false; }
              ss<<v[i];
              break;
            case ':':
              if( !quote ) {
                ss<<": ";
              } else {
                ss<<':';
              }
              break;
            case '"':
              if( first ) {
                 ss<<'\n';
                 for( int i = 0; i < level*indent; ++i ) ss<<' ';
                 first = false;
              }
              if( !escape ) {
                quote = !quote;
              }
              escape = false;
              ss<<'"';
              break;
            case '{':
            case '[':
              ss<<v[i];
              if( !quote ) {
                ++level;
                first = true;
              }else {
                escape = false;
              }
              break;
            case '}':
            case ']':
              if( !quote ) {
                if( v[i-1] != '[' && v[i-1] != '{' ) {
                  ss<<'\n';
                }
                --level;
                if( !first ) {
                  for( int i = 0; i < level*indent; ++i ) ss<<' ';
                }
                first = false;
                ss<<v[i];
                break;
              } else {
                escape = false;
                ss<<v[i];
              }
              break;
            case ',':
              if( !quote ) {
                ss<<',';
                first = true;
              } else {
                escape = false;
                ss<<',';
              }
              break;
            case 'n':
              //If we're in quotes and see a \n, \b, \f, \r, \t, or \u, just print it literally but unset the escape flag.
            case 'b':
            case 'f':
            case 'r':
            case 't':
            case 'u':
              if( quote && escape )
                escape = false;
              //No break; fall through to default case
            default:
              if( first ) {
                 ss<<'\n';
                 for( int i = 0; i < level*indent; ++i ) ss<<' ';
                 first = false;
              }
              ss << v[i];
         }
      }
      return ss.str();
    }

Here is the caller graph for this function:

prune_invalid_utf8()

string fc::prune_invalid_utf8

(

const std::string_view &

str

)

Invalid utf8 code points are purned, 0x80-0x9F C1 control characters are escaped

Definition at line 47 of file utf8.cpp.

                                                          {
      const auto invalid_range = std::make_pair<uint32_t, uint32_t>(0x80, 0x9F);
      auto [itr, v] = find_invalid( str.begin(), str.end(), invalid_range );
      if( itr == str.end() ) return std::string( str );
 
      string result;
      auto escape = [&result](uint32_t v) { // v is [0x80-0x9F]
         result += "\\u00";
         result += hex_digits[v >> 4u];
         result += hex_digits[v & 15u];
      };
 
      result = string( str.begin(), itr );
      if( v != UINT32_MAX ) escape(v);
      while( itr != str.end() ) {
         ++itr;
         auto start = itr;
         std::tie(itr, v) = find_invalid( start, str.end(), invalid_range );
         result += string( start, itr );
         if( v != UINT32_MAX ) escape(v);
      }
      return result;
   }

Here is the call graph for this function:

Here is the caller graph for this function:

rand_bytes()

void fc::rand_bytes	(	char *	buf,
		int	count )

Definition at line 9 of file rand.cpp.

{
  int result = RAND_bytes((unsigned char*)buf, count);
  if (result != 1)
    FC_THROW("Error calling OpenSSL's RAND_bytes(): ${code}", ("code", (uint32_t)ERR_get_error()));
}

Here is the caller graph for this function:

rand_pseudo_bytes()

void fc::rand_pseudo_bytes	(	char *	buf,
		int	count )

Definition at line 16 of file rand.cpp.

{
  rand_bytes(buf, count);
}

Here is the call graph for this function:

Here is the caller graph for this function:

read_file_contents()

void fc::read_file_contents	(	const fc::path &	filename,
		std::string &	result )

Grab the full contents of a file into a string object. NB reading a full file into memory is a poor choice if the file may be very large.

Definition at line 14 of file fstream.cpp.

   {
      const boost::filesystem::path& bfp = filename;
      boost::filesystem::ifstream f( bfp, std::ios::in | std::ios::binary );
      FC_ASSERT(f, "Failed to open ${filename}", ("filename", filename));
      // don't use fc::stringstream here as we need something with override for << rdbuf()
      std::stringstream ss;
      ss << f.rdbuf();
      FC_ASSERT(f, "Failed reading ${filename}", ("filename", filename));
      result = ss.str();
   }

Here is the caller graph for this function:

record_assert_trip()

void fc::record_assert_trip	(	const char *	filename,
		uint32_t	lineno,
		const char *	expr )

Definition at line 305 of file exception.cpp.

   {
      fc::mutable_variant_object assert_trip_info =
         fc::mutable_variant_object()
         ("source_file", filename)
         ("source_lineno", lineno)
         ("expr", expr)
         ;
      /* TODO: restore this later
      std::cout
         << "FC_ASSERT triggered:  "
         << fc::json::to_string( assert_trip_info ) << "\n";
         */
      return;
   }

remove()

bool fc::remove

(

const path &

p

)

Definition at line 350 of file filesystem.cpp.

                               {
     try {
        return boost::filesystem::remove( f );
     } catch ( ... ) {
         FC_THROW( "Unable to remove '${path}'", ( "path", f )("exception", fc::except_str() ) );
     }
  }

Here is the call graph for this function:

Here is the caller graph for this function:

remove_all()

void fc::remove_all

(

const path &

p

)

Definition at line 248 of file filesystem.cpp.

{ boost::filesystem::remove_all(p); }

Here is the caller graph for this function:

rename()

void fc::rename	(	const path &	from,
		const path &	to )

Definition at line 326 of file filesystem.cpp.

                                              {
     try {
        boost::filesystem::rename( boost::filesystem::path(f), boost::filesystem::path(t) );
     } catch ( boost::system::system_error& ) {
         try{
             boost::filesystem::copy( boost::filesystem::path(f), boost::filesystem::path(t) );
             boost::filesystem::remove( boost::filesystem::path(f));
         } catch ( boost::system::system_error& e ) {
             FC_THROW( "Rename from ${srcfile} to ${dstfile} failed because ${reason}",
                     ("srcfile",f)("dstfile",t)("reason",e.what() ) );
         }
     } catch ( ... ) {
        FC_THROW( "Rename from ${srcfile} to ${dstfile} failed",
             ("srcfile",f)("dstfile",t)("inner", fc::except_str() ) );
     }
  }

Here is the call graph for this function:

Here is the caller graph for this function:

resize_file()

void fc::resize_file	(	const path &	file,
		size_t	s )

Definition at line 282 of file filesystem.cpp.

  {
    try {
      boost::filesystem::resize_file( f, t );
    }
    catch ( boost::system::system_error& e )
    {
      FC_THROW( "Resize file '${f}' to size ${s} failed: ${reason}",
                ("f",f)("s",t)( "reason", e.what() ) );
    }
    catch ( ... )
    {
      FC_THROW( "Resize file '${f}' to size ${s} failed: ${reason}",
                ("f",f)("s",t)( "reason", fc::except_str() ) );
    }
  }

Here is the call graph for this function:

Here is the caller graph for this function:

resolve()

std::vector< boost::asio::ip::udp::endpoint > fc::resolve	(	boost::asio::io_service &	io_service,
		const std::string &	host,
		uint16_t	port )

Definition at line 6 of file resolve.cpp.

  {
    using q = boost::asio::ip::udp::resolver::query;
    using b = boost::asio::ip::resolver_query_base;
    boost::asio::ip::udp::resolver res(io_service);
    boost::system::error_code ec;
    auto ep = res.resolve(q(host, std::to_string(uint64_t(port)),
                            b::address_configured | b::numeric_service), ec);
    if(!ec)
    {
      std::vector<boost::asio::ip::udp::endpoint> eps;
      while(ep != boost::asio::ip::udp::resolver::iterator())
      {
        if(ep->endpoint().address().is_v4())
        {
         eps.push_back(*ep);
        }
        // TODO: add support for v6
        ++ep;
      }
      return eps;
    }
    FC_THROW_EXCEPTION(unknown_host_exception,
                       "name resolution failed: ${reason}",
                       ("reason", ec.message()));
  }

Here is the caller graph for this function:

seconds()

microseconds fc::seconds ( int64_t s )

inlineconstexpr

Definition at line 32 of file time.hpp.

{ return microseconds( s * 1000000 ); }

Here is the caller graph for this function:

serialize_secondary_index()

template<typename ST , typename T >

datastream< ST > & fc::serialize_secondary_index	(	datastream< ST > &	ds,
		const sysio::chain::table_id_object &	context,
		const T &	obj )

Definition at line 220 of file serialization.hpp.

                                                        {
   fc::raw::pack(ds, fc::unsigned_int(0));
   fc::raw::pack(ds, as_type<uint64_t>(context.code.to_uint64_t()));
   fc::raw::pack(ds, as_type<uint64_t>(context.scope.to_uint64_t()));
   fc::raw::pack(ds, as_type<uint64_t>(context.table.to_uint64_t()));
   fc::raw::pack(ds, as_type<uint64_t>(obj.primary_key));
   fc::raw::pack(ds, as_type<uint64_t>(obj.payer.to_uint64_t()));
   serialize_secondary_index_data(ds, obj.secondary_key);
   return ds;
}

serialize_secondary_index_data() [1/4]

template<typename ST >

void fc::serialize_secondary_index_data	(	datastream< ST > &	ds,
		const float128_t &	obj )

Definition at line 202 of file serialization.hpp.

                                                                               {
   __uint128_t i;
   memcpy(&i, &obj, sizeof(i));
   fc::raw::pack(ds, i);
}

Here is the call graph for this function:

serialize_secondary_index_data() [2/4]

template<typename ST >

void fc::serialize_secondary_index_data	(	datastream< ST > &	ds,
		const float64_t &	obj )

Definition at line 195 of file serialization.hpp.

                                                                              {
   uint64_t i;
   memcpy(&i, &obj, sizeof(i));
   fc::raw::pack(ds, i);
}

Here is the call graph for this function:

serialize_secondary_index_data() [3/4]

template<typename ST >

void fc::serialize_secondary_index_data	(	datastream< ST > &	ds,
		const sysio::chain::key256_t &	obj )

Definition at line 209 of file serialization.hpp.

                                                                                       {
   auto rev = [&](__uint128_t x) {
      char* ch = reinterpret_cast<char*>(&x);
      std::reverse(ch, ch + sizeof(x));
      return x;
   };
   fc::raw::pack(ds, rev(obj[0]));
   fc::raw::pack(ds, rev(obj[1]));
}

Here is the call graph for this function:

serialize_secondary_index_data() [4/4]

template<typename ST , typename T >

void fc::serialize_secondary_index_data	(	datastream< ST > &	ds,
		const T &	obj )

Definition at line 190 of file serialization.hpp.

                                                                      {
   fc::raw::pack(ds, obj);
}

Here is the call graph for this function:

Here is the caller graph for this function:

set_console_echo()

void fc::set_console_echo

(

bool

enable_echo

)

enables / disables echoing of console input, useful for entering passwords on the console.

Definition at line 28 of file console.cpp.

{
   termios oldt;
   tcgetattr(STDIN_FILENO, &oldt);
   termios newt = oldt;
   if( enable_echo )
   {
      newt.c_lflag |= ECHO;
   }
   else
   {
      newt.c_lflag &= ~ECHO;
   }
   tcsetattr(STDIN_FILENO, TCSANOW, &newt);
}

Here is the caller graph for this function:

set_os_thread_name()

void fc::set_os_thread_name

(

const string &

name

)

Definition at line 136 of file logger_config.cpp.

                                                 {
#ifdef FC_USE_PTHREAD_NAME_NP
      pthread_setname_np( pthread_self(), name.c_str() );
#endif
   }

Here is the caller graph for this function:

set_thread_name()

void fc::set_thread_name

(

const string &

name

)

Definition at line 141 of file logger_config.cpp.

                                              {
      thread_name = name;
   }

set_variant_type()

void fc::set_variant_type	(	variant *	v,
		variant::type_id	t )

The TypeID is stored in the 'last byte' of the variant.

Definition at line 18 of file variant.cpp.

{
   char* data = reinterpret_cast<char*>(v);
   data[ sizeof(variant) -1 ] = t;
}

Here is the caller graph for this function:

skip_white_space()

template<typename T >

bool fc::skip_white_space

(

T &

in

)

Definition at line 65 of file json.cpp.

   {
       bool skipped = false;
       while( true )
       {
          switch( in.peek() )
          {
             case ' ':
             case '\t':
             case '\n':
             case '\r':
                skipped = true;
                in.get();
                break;
             case '\0':
                FC_THROW_EXCEPTION( eof_exception, "unexpected end of file" );
                break;
             default:
                return skipped;
          }
       }
   }

Here is the caller graph for this function:

smaz_compress() [1/2]

uint32_t fc::smaz_compress	(	const char *	in,
		int	inlen,
		char *	out,
		int	outlen )

Definition at line 85 of file smaz.cpp.

                                                                         {
    unsigned int h1,h2,h3=0;
    int verblen = 0, _outlen = outlen;
    char verb[256], *_out = out;
 
    while(inlen) {
        int j = 7, needed;
        char *flush = NULL;
        const char *slot;
 
        h1 = h2 = in[0]<<3;
        if (inlen > 1) h2 += in[1];
        if (inlen > 2) h3 = h2^in[2];
        if (j > inlen) j = inlen;
 
        /* Try to lookup substrings into the hash table, starting from the
         * longer to the shorter substrings */
        for (; j > 0; j--) {
            switch(j) {
            case 1: slot = Smaz_cb[h1%241]; break;
            case 2: slot = Smaz_cb[h2%241]; break;
            default: slot = Smaz_cb[h3%241]; break;
            }
            while(slot[0]) {
                if (slot[0] == j && memcmp(slot+1,in,j) == 0) {
                    /* Match found in the hash table,
                     * prepare a verbatim bytes flush if needed */
                    if (verblen) {
                        needed = (verblen == 1) ? 2 : 2+verblen;
                        flush = out;
                        out += needed;
                        outlen -= needed;
                    }
                    /* Emit the byte */
                    if (outlen <= 0) return _outlen+1;
                    out[0] = slot[slot[0]+1];
                    out++;
                    outlen--;
                    inlen -= j;
                    in += j;
                    goto out;
                } else {
                    slot += slot[0]+2;
                }
            }
        }
        /* Match not found - add the byte to the verbatim buffer */
        verb[verblen] = in[0];
        verblen++;
        inlen--;
        in++;
out:
        /* Prepare a flush if we reached the flush length limit, and there
         * is not already a pending flush operation. */
        if (!flush && (verblen == 256 || (verblen > 0 && inlen == 0))) {
            needed = (verblen == 1) ? 2 : 2+verblen;
            flush = out;
            out += needed;
            outlen -= needed;
            if (outlen < 0) return _outlen+1;
        }
        /* Perform a verbatim flush if needed */
        if (flush) {
            if (verblen == 1) {
                flush[0] = (signed char)254;
                flush[1] = verb[0];
            } else {
                flush[0] = (signed char)255;
                flush[1] = (signed char)(verblen-1);
                memcpy(flush+2,verb,verblen);
            }
            flush = NULL;
            verblen = 0;
        }
    }
    return out-_out;
}

Here is the call graph for this function:

smaz_compress() [2/2]

std::string fc::smaz_compress

(

const std::string &

in

)

Definition at line 207 of file smaz.cpp.

  {
    std::string out;
    out.resize(in.size());
    auto out_len = smaz_compress( in.c_str(), in.size(), &out[0], out.size() );
    FC_ASSERT( out_len <= out.size() );
    out.resize(out_len);
    return out;
  }

Here is the call graph for this function:

Here is the caller graph for this function:

smaz_decompress() [1/2]

void fc::smaz_decompress	(	const char *	in,
		uint32_t	inlen,
		std::stringstream &	ss )

Definition at line 163 of file smaz.cpp.

                                                                           {
    const unsigned char *c = (const unsigned char*) in;
//    char *_out = out;
//    int _outlen = outlen;
 
    while(inlen) {
        if (*c == 254) {
            /* Verbatim byte */
            //if (outlen < 1) return _outlen+1;
            //*out = *(c+1);
            ss.put( *(c+1) );
            //out++;
            //outlen--;
            c += 2;
            inlen -= 2;
        } else if (*c == 255) {
            /* Verbatim string */
            int len = (*(c+1))+1;
            //if (outlen < len) return _outlen+1;
            ss.write( (const char*)(c+2),len );
 
            //memcpy(out,c+2,len);
            //out += len;
            //outlen -= len;
            c += 2+len;
            inlen -= 2+len;
        } else {
            /* Codebook entry */
            const char *s = Smaz_rcb[*c];
            int len = strlen(s);
 
            //if (outlen < len) return _outlen+1;
            //memcpy(out,s,len);
            ss.write( s, len );
            //out += len;
            //outlen -= len;
            c++;
            inlen--;
        }
    }
}

smaz_decompress() [2/2]

std::string fc::smaz_decompress

(

const std::string &

compressed

)

Definition at line 216 of file smaz.cpp.

  {
    std::stringstream ss;
    smaz_decompress( compressed.c_str(), compressed.length(), ss );
    return ss.str();
  }

Here is the call graph for this function:

Here is the caller graph for this function:

stringFromStream()

template<typename T >

std::string fc::stringFromStream

(

T &

in

)

Definition at line 89 of file json.cpp.

   {
      std::stringstream token;
      try
      {
         char c = in.peek();
 
         if( c != '"' )
            FC_THROW_EXCEPTION( parse_error_exception,
                                            "Expected '\"' but read '${char}'",
                                            ("char", string(&c, (&c) + 1) ) );
         in.get();
         while( !in.eof() )
         {
            switch( c = in.peek() )
            {
               case '\\':
                  token << parseEscape( in );
                  break;
               case 0x04:
                  FC_THROW_EXCEPTION( parse_error_exception, "EOF before closing '\"' in string '${token}'",
                                                   ("token", token.str() ) );
               case '"':
                  in.get();
                  return token.str();
               default:
                  token << c;
                  in.get();
            }
         }
         FC_THROW_EXCEPTION( parse_error_exception, "EOF before closing '\"' in string '${token}'",
                                          ("token", token.str() ) );
       } FC_RETHROW_EXCEPTIONS( warn, "while parsing token '${token}'",
                                          ("token", token.str() ) );
   }

Here is the call graph for this function:

Here is the caller graph for this function:

stringFromToken()

template<typename T >

std::string fc::stringFromToken

(

T &

in

)

Definition at line 125 of file json.cpp.

   {
      std::stringstream token;
      try
      {
         char c = in.peek();
 
         while( !in.eof() )
         {
            switch( c = in.peek() )
            {
               case '\\':
                  token << parseEscape( in );
                  break;
               case '\t':
               case ' ':
               case '\n':
                  in.get();
                  return token.str();
               case '\0':
                  FC_THROW_EXCEPTION( eof_exception, "unexpected end of file" );
               default:
                if( isalnum( c ) || c == '_' || c == '-' || c == '.' || c == ':' || c == '/' )
                {
                  token << c;
                  in.get();
                }
                else return token.str();
            }
         }
         return token.str();
      }
      catch( const fc::eof_exception& eof )
      {
         return token.str();
      }
      catch (const std::ios_base::failure&)
      {
         return token.str();
      }
 
      FC_RETHROW_EXCEPTIONS( warn, "while parsing token '${token}'",
                                          ("token", token.str() ) );
   }

Here is the call graph for this function:

Here is the caller graph for this function:

temp_directory_path()

path fc::temp_directory_path

(

)

Definition at line 366 of file filesystem.cpp.

{ return boost::filesystem::temp_directory_path(); }

throw_bad_enum_cast() [1/2]

void fc::throw_bad_enum_cast	(	const char *	k,
		const char *	e )

Definition at line 280 of file exception.cpp.

   {
      FC_THROW_EXCEPTION( bad_cast_exception,
                          "invalid name '${key}' in enum '${enum}'",
                          ("key",k)("enum",e) );
   }

throw_bad_enum_cast() [2/2]

void fc::throw_bad_enum_cast	(	int64_t	i,
		const char *	e )

Definition at line 274 of file exception.cpp.

   {
      FC_THROW_EXCEPTION( bad_cast_exception,
                          "invalid index '${key}' in enum '${enum}'",
                          ("key",i)("enum",e) );
   }

to_base32() [1/2]

std::string fc::to_base32	(	const char *	data,
		size_t	len )

Definition at line 15 of file base32.cpp.

    { 
       auto s = cyoBase32EncodeGetLength(len);
       std::vector<char> b32;
       b32.resize(s);
       cyoBase32Encode( b32.data(), data, len );
       b32.resize( b32.size()-1); // strip the nullterm
       return std::string(b32.begin(),b32.end());
    }

to_base32() [2/2]

std::string fc::to_base32

(

const std::vector< char > &

vec

)

Definition at line 25 of file base32.cpp.

    {
       return to_base32( vec.data(), vec.size() );
    }

Here is the call graph for this function:

Here is the caller graph for this function:

to_base36() [1/2]

fc::string fc::to_base36	(	const char *	data,
		size_t	len )

Definition at line 8 of file base36.cpp.

    {
       if( len == 0 ) return fc::string();
 
       const char* src = data;
       int src_len = len;
       std::unique_ptr<char[]> buffer(new char[len+1]);
       if (*data & 0x80) {
           buffer[0] = 0;
           memcpy( buffer.get() + 1, data, len );
           src = buffer.get();
           src_len++;
       }
       fc::bigint value( src, src_len );
 
       auto base36 = "0123456789abcdefghijklmnopqrstuvwxyz";
       std::vector<char> out( static_cast<size_t>(len * 1.6) + 2 );
       int pos = out.size() - 1;
       out[pos] = '\0';
       fc::bigint _36(36);
       do {
         if( value ) {
           --pos;
           out[pos] = base36[(value % _36).to_int64()];
         }
       } while (value /= _36);
       while (len-- > 0 && *data++ == 0) {
           out[--pos] = '0';
       }
       return &out[pos]; //fc::string( &out[pos], out.size() - pos);
    }

Here is the call graph for this function:

to_base36() [2/2]

fc::string fc::to_base36

(

const std::vector< char > &

vec

)

Definition at line 40 of file base36.cpp.

    {
      return to_base36( (const char*)vec.data(), vec.size() );
    }

Here is the call graph for this function:

Here is the caller graph for this function:

to_base58() [1/2]

std::string fc::to_base58	(	const char *	d,
		size_t	s,
		const fc::yield_function_t &	yield )

Definition at line 618 of file base58.cpp.

                                                                                {
  return EncodeBase58( (const unsigned char*)d, (const unsigned char*)d+s, yield );
}

Here is the call graph for this function:

Here is the caller graph for this function:

to_base58() [2/2]

std::string fc::to_base58	(	const std::vector< char > &	data,
		const fc::yield_function_t &	yield )

Definition at line 622 of file base58.cpp.

{
  if( d.size() )
     return to_base58( d.data(), d.size(), yield );
  return std::string();
}

Here is the call graph for this function:

to_double()

double fc::to_double

(

const fc::string &

i

)

Definition at line 118 of file string.cpp.

  {
    try
    {
      return boost::lexical_cast<double>(i.c_str(), i.size());
    }
    catch( const boost::bad_lexical_cast& e )
    {
      FC_THROW_EXCEPTION( parse_error_exception, "Couldn't parse double" );
    }
    FC_RETHROW_EXCEPTIONS( warn, "${i} => double", ("i",i) )
  }

Here is the call graph for this function:

Here is the caller graph for this function:

to_hex() [1/2]

std::string fc::to_hex	(	const char *	d,
		uint32_t	s )

Definition at line 17 of file hex.cpp.

    {
        std::string r;
        const char* to_hex="0123456789abcdef";
        uint8_t* c = (uint8_t*)d;
        for( uint32_t i = 0; i < s; ++i )
            (r += to_hex[(c[i]>>4)]) += to_hex[(c[i] &0x0f)];
        return r;
    }

Here is the call graph for this function:

Here is the caller graph for this function:

to_hex() [2/2]

std::string fc::to_hex

(

const std::vector< char > &

data

)

Definition at line 42 of file hex.cpp.

    {
       if( data.size() )
          return to_hex( data.data(), data.size() );
       return "";
    }

Here is the call graph for this function:

to_int64()

int64_t fc::to_int64

(

const fc::string &

i

)

Definition at line 92 of file string.cpp.

  {
    try
    {
      return boost::lexical_cast<int64_t>(i.c_str(), i.size());
    }
    catch( const boost::bad_lexical_cast& e )
    {
      FC_THROW_EXCEPTION( parse_error_exception, "Couldn't parse int64_t" );
    }
    FC_RETHROW_EXCEPTIONS( warn, "${i} => int64_t", ("i",i) )
  }

Here is the call graph for this function:

Here is the caller graph for this function:

to_lower()

std::string fc::to_lower

(

const fc::string &

s

)

Definition at line 161 of file string.cpp.

  {
     auto tmp = s;
     boost::algorithm::to_lower(tmp);
     return tmp;
  }

Here is the call graph for this function:

Here is the caller graph for this function:

to_pretty_string()

std::string fc::to_pretty_string

(

int64_t

value

)

Definition at line 26 of file string.cpp.

  {
     std::stringstream ss;
     ss.imbue( {std::locale(), new comma_numpunct} );
     ss << std::fixed << value;
     return ss.str();
  }

to_scalar()

Scalar fc::to_scalar ( const bytes & be )

noexcept

Definition at line 27 of file alt_bn128.cpp.

                                               {
        mpz_t m;
        mpz_init(m);
        mpz_import(m, be.size(), /*order=*/1, /*size=*/1, /*endian=*/0, /*nails=*/0, &be[0]);
        Scalar out{m};
        mpz_clear(m);
        return out;
    }

Here is the caller graph for this function:

to_seekable()

template<typename STREAM >

device_adaptor< STREAM, bio::source_tag > fc::to_seekable

(

STREAM &

strm

)

Definition at line 29 of file bio_device_adaptor.hpp.

                                                                {
   return device_adaptor<STREAM, bio::seekable_device_tag>{strm};
}

to_sink()

template<typename STREAM >

device_adaptor< STREAM, bio::sink_tag > fc::to_sink

(

STREAM &

strm

)

Definition at line 19 of file bio_device_adaptor.hpp.

                                                          {
   return device_adaptor<STREAM, bio::sink_tag>{strm};
}

to_source()

template<typename STREAM >

device_adaptor< STREAM, bio::source_tag > fc::to_source

(

STREAM &

strm

)

Definition at line 24 of file bio_device_adaptor.hpp.

                                                              {
   return device_adaptor<STREAM, bio::source_tag>{strm};
}

to_stream() [1/3]

template<typename T >

void fc::to_stream	(	T &	os,
		const variant &	v,
		const json::yield_function_t &	yield,
		json::output_formatting	format )

Definition at line 612 of file json.cpp.

   {
      yield(os.tellp());
      switch( v.get_type() )
      {
         case variant::null_type:
              os << "null";
              return;
         case variant::int64_type:
         {
              int64_t i = v.as_int64();
              if( format == json::output_formatting::stringify_large_ints_and_doubles &&
                  i > 0xffffffff )
                 os << '"'<<v.as_string()<<'"';
              else
                 os << i;
 
              return;
         }
         case variant::uint64_type:
         {
              uint64_t i = v.as_uint64();
              if( format == json::output_formatting::stringify_large_ints_and_doubles &&
                  i > 0xffffffff )
                 os << '"'<<v.as_string()<<'"';
              else
                 os << i;
 
              return;
         }
         case variant::double_type:
              if (format == json::output_formatting::stringify_large_ints_and_doubles)
                 os << '"'<<v.as_string()<<'"';
              else
                 os << v.as_string();
              return;
         case variant::bool_type:
              os << v.as_string();
              return;
         case variant::string_type:
              os << '"' << escape_string( v.get_string(), yield ) << '"';
              return;
         case variant::blob_type:
              os << '"' << escape_string( v.as_string(), yield ) << '"';
              return;
         case variant::array_type:
           {
              const variants&  a = v.get_array();
              to_stream( os, a, yield, format );
              return;
           }
         case variant::object_type:
           {
              const variant_object& o =  v.get_object();
              to_stream(os, o, yield, format );
              return;
           }
         default:
            FC_THROW_EXCEPTION( fc::invalid_arg_exception, "Unsupported variant type: " + std::to_string( v.get_type() ) );
      }
   }

Here is the call graph for this function:

to_stream() [2/3]

template<typename T >

void fc::to_stream	(	T &	os,
		const variant_object &	o,
		const json::yield_function_t &	yield,
		json::output_formatting	format )

Definition at line 593 of file json.cpp.

   {
       yield(os.tellp());
       os << '{';
       auto itr = o.begin();
 
       while( itr != o.end() )
       {
          os << '"' << escape_string( itr->key(), yield ) << '"';
          os << ':';
          to_stream( os, itr->value(), yield, format );
          ++itr;
          if( itr != o.end() )
             os << ',';
       }
       os << '}';
   }

Here is the call graph for this function:

to_stream() [3/3]

template<typename T >

void fc::to_stream	(	T &	os,
		const variants &	a,
		const json::yield_function_t &	yield,
		json::output_formatting	format )

Definition at line 576 of file json.cpp.

   {
      yield(os.tellp());
      os << '[';
      auto itr = a.begin();
 
      while( itr != a.end() )
      {
         to_stream( os, *itr, yield, format );
         ++itr;
         if( itr != a.end() )
            os << ',';
      }
      os << ']';
   }

Here is the call graph for this function:

Here is the caller graph for this function:

to_string() [1/6]

fc::string fc::to_string

(

double

d

)

Definition at line 131 of file string.cpp.

  {
    // +2 is required to ensure that the double is rounded correctly when read back in.  http://docs.oracle.com/cd/E19957-01/806-3568/ncg_goldberg.html
    std::stringstream ss;
    ss << std::setprecision(std::numeric_limits<double>::digits10 + 2) << std::fixed << d;
    return ss.str();
  }

Here is the caller graph for this function:

to_string() [2/6]

fc::string fc::to_string ( int32_t v )

inline

Definition at line 20 of file string.hpp.

{ return to_string( int64_t(v) ); }

Here is the call graph for this function:

to_string() [3/6]

fc::string fc::to_string

(

int64_t

d

)

Definition at line 144 of file string.cpp.

  {
    return boost::lexical_cast<std::string>(d);
  }

to_string() [4/6]

fc::string fc::to_string

(

uint16_t

d

)

Definition at line 148 of file string.cpp.

  {
    return boost::lexical_cast<std::string>(d);
  }

to_string() [5/6]

fc::string fc::to_string ( uint32_t v )

inline

Definition at line 21 of file string.hpp.

{ return to_string( uint64_t(v) ); }

Here is the call graph for this function:

to_string() [6/6]

fc::string fc::to_string

(

uint64_t

d

)

Definition at line 139 of file string.cpp.

  {
    return boost::lexical_cast<std::string>(d);
  }

to_uint64()

uint64_t fc::to_uint64

(

const fc::string &

i

)

Definition at line 105 of file string.cpp.

  { try {
    try
    {
      return boost::lexical_cast<uint64_t>(i.c_str(), i.size());
    }
    catch( const boost::bad_lexical_cast& e )
    {
      FC_THROW_EXCEPTION( parse_error_exception, "Couldn't parse uint64_t" );
    }
    FC_RETHROW_EXCEPTIONS( warn, "${i} => uint64_t", ("i",i) )
  } FC_CAPTURE_AND_RETHROW( (i) ) }

Here is the call graph for this function:

Here is the caller graph for this function:

to_variant() [1/97]

void fc::to_variant	(	const __int128 &	var,
		fc::variant &	vo )

Definition at line 679 of file variant.cpp.

                                                      {
   vo = boost::multiprecision::int128_t( var ).str();
}

to_variant() [2/97]

template<typename T , size_t N>

void fc::to_variant	(	const array< T, N > &	bi,
		variant &	v )

Definition at line 106 of file array.hpp.

  {
     v = std::vector<char>( (const char*)&bi, ((const char*)&bi) + sizeof(bi) );
  }

to_variant() [3/97]

void fc::to_variant	(	const bigint &	bi,
		variant &	v )

encodes the big int as base64 string, or a number

Definition at line 211 of file bigint.cpp.

  {
    std::vector<char> ve = bi;
    v = fc::variant(base64_encode((unsigned char*)ve.data(),ve.size()));
  }

Here is the call graph for this function:

to_variant() [4/97]

template<typename K , typename V , typename... U>

void fc::to_variant	(	const bip::map< K, V, U... > &	m,
		fc::variant &	vo )

Definition at line 80 of file container.hpp.

                                                                   {
      detail::to_variant_from_map( m, vo );
   }

Here is the call graph for this function:

to_variant() [5/97]

template<typename K , typename V , typename... U>

void fc::to_variant	(	const bip::multimap< K, V, U... > &	m,
		fc::variant &	vo )

Definition at line 90 of file container.hpp.

                                                                        {
      detail::to_variant_from_map( m, vo );
   }

Here is the call graph for this function:

to_variant() [6/97]

template<typename T , typename... U>

void fc::to_variant	(	const bip::multiset< T, U... > &	s,
		fc::variant &	vo )

Definition at line 70 of file container.hpp.

                                                                     {
      detail::to_variant_from_set( s, vo );
   }

Here is the call graph for this function:

to_variant() [7/97]

template<typename T , typename... U>

void fc::to_variant	(	const bip::set< T, U... > &	s,
		fc::variant &	vo )

Definition at line 60 of file container.hpp.

                                                                {
      detail::to_variant_from_set( s, vo );
   }

Here is the call graph for this function:

to_variant() [8/97]

void fc::to_variant ( const blob & b, variant & v )

inline

Definition at line 190 of file database_utils.hpp.

                                                {
      v = variant(base64_encode(b.data.data(), b.data.size()));
   }

Here is the call graph for this function:

to_variant() [9/97]

template<typename T , typename... U>

void fc::to_variant	(	const boost::container::deque< T, U... > &	d,
		fc::variant &	vo )

Definition at line 542 of file variant.hpp.

   {
      if( d.size() > MAX_NUM_ARRAY_ELEMENTS ) throw std::range_error( "too large" );
      variants vars(d.size());
      for( size_t i = 0; i < d.size(); ++i ) {
         vars[i] = fc::variant( d[i] );
      }
      vo = std::move( vars );
   }

to_variant() [10/97]

template<typename... U>

void fc::to_variant	(	const boost::container::vector< char, U... > &	vec,
		fc::variant &	vo )

Definition at line 126 of file flat.hpp.

                                                                                 {
      FC_ASSERT( vec.size() <= MAX_SIZE_OF_BYTE_ARRAYS );
      if( vec.size() )
         vo = variant( fc::to_hex( vec.data(), vec.size() ) );
      else
         vo = "";
   }

Here is the call graph for this function:

to_variant() [11/97]

template<typename T , typename... U>

void fc::to_variant	(	const boost::container::vector< T, U... > &	vec,
		fc::variant &	vo )

Definition at line 104 of file flat.hpp.

                                                                              {
      FC_ASSERT( vec.size() <= MAX_NUM_ARRAY_ELEMENTS );
      variants vars;
      vars.reserve( vec.size() );
      for( const auto& item : vec ) {
         vars.emplace_back( item );
      }
      vo = std::move(vars);
   }

to_variant() [12/97]

template<typename T , typename... Args>

void fc::to_variant	(	const boost::multi_index_container< T, Args... > &	s,
		fc::variant &	v )

Definition at line 674 of file variant.hpp.

   {
       std::vector<fc::variant> vars;
       vars.reserve( c.size() );
       for( const auto& item : c )
          vars.emplace_back( fc::variant(item) );
       v = std::move(vars);
   }

to_variant() [13/97]

template<typename T >

void fc::to_variant	(	const boost::multiprecision::number< T > &	n,
		fc::variant &	v )

Definition at line 690 of file variant.hpp.

                                                                                               {
      v = n.str();
   }

to_variant() [14/97]

template<typename OidType >

void fc::to_variant	(	const chainbase::oid< OidType > &	oid,
		variant &	v )

Definition at line 100 of file database_utils.hpp.

                                                                   {
      v = variant(oid._id);
   }

to_variant() [15/97]

void fc::to_variant	(	const crypto::private_key &	var,
		variant &	vo,
		const fc::yield_function_t &	yield = fc::yield_function_t() )

Definition at line 144 of file private_key.cpp.

   {
      vo = var.to_string(yield);
   }

Here is the call graph for this function:

to_variant() [16/97]

void fc::to_variant	(	const crypto::public_key &	var,
		fc::variant &	vo,
		const fc::yield_function_t &	yield = fc::yield_function_t() )

Definition at line 109 of file public_key.cpp.

   {
      vo = var.to_string(yield);
   }

Here is the call graph for this function:

to_variant() [17/97]

void fc::to_variant	(	const crypto::r1::private_key &	var,
		variant &	vo )

Definition at line 621 of file elliptic_r1.cpp.

  {
    vo = var.get_secret();
  }

Here is the call graph for this function:

to_variant() [18/97]

void fc::to_variant	(	const crypto::r1::public_key &	var,
		variant &	vo )

Definition at line 632 of file elliptic_r1.cpp.

  {
    vo = var.serialize();
  }

Here is the call graph for this function:

to_variant() [19/97]

void fc::to_variant	(	const crypto::signature &	var,
		fc::variant &	vo,
		const fc::yield_function_t &	yield = fc::yield_function_t() )

Definition at line 88 of file signature.cpp.

   {
      vo = var.to_string(yield);
   }

Here is the call graph for this function:

to_variant() [20/97]

void fc::to_variant	(	const ecc::private_key &	var,
		variant &	vo )

Definition at line 216 of file elliptic_common.cpp.

{
    vo = var.get_secret();
}

Here is the call graph for this function:

to_variant() [21/97]

void fc::to_variant	(	const ecc::public_key &	var,
		variant &	vo )

Definition at line 228 of file elliptic_common.cpp.

{
    vo = var.serialize();
}

Here is the call graph for this function:

to_variant() [22/97]

void fc::to_variant	(	const em::private_key &	var,
		variant &	vo )

Definition at line 217 of file elliptic_em_common.cpp.

{
    vo = var.get_secret();
}

Here is the call graph for this function:

to_variant() [23/97]

void fc::to_variant	(	const em::public_key &	var,
		variant &	vo )

Definition at line 229 of file elliptic_em_common.cpp.

{
    vo = var.serialize();
}

Here is the call graph for this function:

to_variant() [24/97]

template<typename IntType , typename EnumType >

void fc::to_variant	(	const enum_type< IntType, EnumType > &	var,
		variant &	vo )

Definition at line 51 of file enum_type.hpp.

  {
    vo = (EnumType)var.value;
  }

to_variant() [25/97]

void fc::to_variant	(	const exception &	e,
		variant &	v )

Definition at line 126 of file exception.cpp.

   {
      v = mutable_variant_object( "code", e.code() )
                                ( "name", e.name() )
                                ( "message", e.what() )
                                ( "stack", e.get_log() );
 
   }

to_variant() [26/97]

void fc::to_variant	(	const fc::microseconds &	input_microseconds,
		fc::variant &	output_variant )

Definition at line 160 of file time.cpp.

  {
    output_variant = input_microseconds.count();
  }

Here is the call graph for this function:

to_variant() [27/97]

void fc::to_variant	(	const fc::path &	path_to_convert,
		fc::variant &	variant_output )

Definition at line 31 of file filesystem.cpp.

  {
    std::wstring wide_string = path_to_convert.generic_wstring();
    std::string utf8_string;
    fc::encodeUtf8(wide_string, &utf8_string);
    variant_output = utf8_string;
 
    //std::string path = t.to_native_ansi_path();
    //std::replace(path.begin(), path.end(), '\\', '/');
    //v = path;
  }

Here is the call graph for this function:

to_variant() [28/97]

template<typename Storage >

void fc::to_variant	(	const fixed_string< Storage > &	s,
		variant &	v )

Definition at line 163 of file fixed_string.hpp.

                                                                 {
      v = std::string(s);
   }

to_variant() [29/97]

template<typename K , typename V , typename... U>

void fc::to_variant	(	const flat_map< K, V, U... > &	m,
		fc::variant &	vo )

Definition at line 167 of file flat.hpp.

                                                                     {
      detail::to_variant_from_map( m, vo );
   }

Here is the call graph for this function:

to_variant() [30/97]

template<typename K , typename V , typename... U>

void fc::to_variant	(	const flat_multimap< K, V, U... > &	m,
		fc::variant &	vo )

Definition at line 177 of file flat.hpp.

                                                                          {
      detail::to_variant_from_map( m, vo );
   }

Here is the call graph for this function:

to_variant() [31/97]

template<typename T , typename... U>

void fc::to_variant	(	const flat_multiset< T, U... > &	s,
		fc::variant &	vo )

Definition at line 157 of file flat.hpp.

                                                                       {
      detail::to_variant_from_set( s, vo );
   }

Here is the call graph for this function:

to_variant() [32/97]

template<typename T , typename... U>

void fc::to_variant	(	const flat_set< T, U... > &	s,
		fc::variant &	vo )

Definition at line 147 of file flat.hpp.

                                                                  {
      detail::to_variant_from_set( s, vo );
   }

Here is the call graph for this function:

to_variant() [33/97]

void fc::to_variant ( const float128_t & f, variant & v )

inline

Definition at line 144 of file database_utils.hpp.

                                                      {
      // Assumes platform is little endian and hex representation of 128-bit integer is in little endian order. 
      char as_bytes[sizeof(sysio::chain::uint128_t)];
      memcpy(as_bytes, &f, sizeof(as_bytes));
      std::string s = "0x"; 
      s.append( to_hex( as_bytes, sizeof(as_bytes) ) );
      v = s;
   }

Here is the call graph for this function:

to_variant() [34/97]

void fc::to_variant ( const float64_t & f, variant & v )

inline

Definition at line 130 of file database_utils.hpp.

                                                     {
      double double_f;
      float64_to_double(f, double_f);
      v = variant(double_f);
   }

Here is the call graph for this function:

to_variant() [35/97]

void fc::to_variant	(	const int16_t &	var,
		fc::variant &	vo )

Definition at line 645 of file variant.cpp.

{ vo = int64_t(var); }

to_variant() [36/97]

void fc::to_variant	(	const int32_t &	var,
		fc::variant &	vo )

Definition at line 655 of file variant.cpp.

                                                     {
   vo = int64_t(var);
}

to_variant() [37/97]

void fc::to_variant	(	const int8_t &	var,
		fc::variant &	vo )

Definition at line 637 of file variant.cpp.

{ vo = int64_t(var); }

to_variant() [38/97]

void fc::to_variant	(	const ip::address &	var,
		variant &	vo )

Definition at line 149 of file ip.cpp.

  {
    vo = fc::string(var);
  }

to_variant() [39/97]

void fc::to_variant	(	const ip::endpoint &	var,
		variant &	vo )

Definition at line 140 of file ip.cpp.

  {
      vo = fc::string(var);
  }

to_variant() [40/97]

void fc::to_variant	(	const log_context &	l,
		variant &	v )

Definition at line 90 of file log_message.cpp.

   { 
      v = l.to_variant();     
   }

to_variant() [41/97]

void fc::to_variant	(	const log_message &	l,
		variant &	v )

Definition at line 104 of file log_message.cpp.

   {
        v = m.to_variant();
   }

Here is the call graph for this function:

to_variant() [42/97]

void fc::to_variant	(	const mutable_variant_object &	var,
		fc::variant &	vo )

Definition at line 414 of file variant_object.cpp.

   {
      vo = variant(var);
   }

to_variant() [43/97]

void fc::to_variant ( const params::permission_level & a, fc::variant & v )

inline

Overloaded to_variant so that permission is only present if it is set

Parameters

a
v

Definition at line 97 of file account_query_db.hpp.

                                                                         {
      if (a.permission.empty()) {
         v = a.actor.to_string();
      } else {
         v = mutable_variant_object()
            ("actor", a.actor.to_string())
            ("permission", a.permission.to_string());
      }
   }

to_variant() [44/97]

void fc::to_variant	(	const private_key &	bi,
		variant &	v )

encodes the big int as base64 string, or a number

Definition at line 353 of file pke.cpp.

  {
    v = bi.serialize();
  }

Here is the call graph for this function:

to_variant() [45/97]

void fc::to_variant	(	const public_key &	bi,
		variant &	v )

encodes the big int as base64 string, or a number

Definition at line 340 of file pke.cpp.

  {
    v = bi.serialize();
  }

Here is the call graph for this function:

to_variant() [46/97]

void fc::to_variant	(	const real128 &	var,
		variant &	vo )

Definition at line 121 of file real128.cpp.

   {
      vo = std::string(var);
   }

to_variant() [47/97]

void fc::to_variant	(	const ripemd160 &	bi,
		variant &	v )

Definition at line 103 of file ripemd160.cpp.

  {
     v = std::vector<char>( (const char*)&bi, ((const char*)&bi) + sizeof(bi) );
  }

to_variant() [48/97]

template<typename T >

void fc::to_variant	(	const safe< T > &	s,
		fc::variant &	v )

Definition at line 669 of file variant.hpp.

{ v = s.value; }

to_variant() [49/97]

void fc::to_variant	(	const sha1 &	bi,
		variant &	v )

Definition at line 89 of file sha1.cpp.

  {
     v = std::vector<char>( (const char*)&bi, ((const char*)&bi) + sizeof(bi) );
  }

to_variant() [50/97]

void fc::to_variant	(	const sha224 &	bi,
		variant &	v )

Definition at line 84 of file sha224.cpp.

  {
     v = std::vector<char>( (const char*)&bi, ((const char*)&bi) + sizeof(bi) );
  }

to_variant() [51/97]

void fc::to_variant	(	const sha256 &	bi,
		variant &	v )

Definition at line 206 of file sha256.cpp.

  {
     v = std::vector<char>( (const char*)&bi, ((const char*)&bi) + sizeof(bi) );
  }

to_variant() [52/97]

void fc::to_variant	(	const sha3 &	bi,
		variant &	v )

Definition at line 276 of file sha3.cpp.

{
    v = std::vector<char>((const char *)&bi, ((const char *)&bi) + sizeof(bi));
}

to_variant() [53/97]

void fc::to_variant	(	const sha512 &	bi,
		variant &	v )

Definition at line 91 of file sha512.cpp.

  {
     v = std::vector<char>( (const char*)&bi, ((const char*)&bi) + sizeof(bi) );
  }

to_variant() [54/97]

void fc::to_variant	(	const signed_int &	var,
		variant &	vo )

Definition at line 6 of file varint.cpp.

{ vo = var.value; }

to_variant() [55/97]

template<typename T , std::size_t S>

void fc::to_variant	(	const std::array< T, S > &	var,
		fc::variant &	vo )

Definition at line 586 of file variant.hpp.

   {
      std::vector<fc::variant> vars(S);
      for( std::size_t i = 0; i < S; ++i )
         vars[i] = fc::variant(t[i]);
      v = std::move(vars);
   }

to_variant() [56/97]

template<typename T >

void fc::to_variant	(	const std::deque< T > &	var,
		fc::variant &	vo )

Definition at line 518 of file variant.hpp.

   {
      if( t.size() > MAX_NUM_ARRAY_ELEMENTS ) throw std::range_error( "too large" );
      std::vector<fc::variant> vars(t.size());
      for( size_t i = 0; i < t.size(); ++i )
         vars[i] = fc::variant(t[i]);
      v = std::move(vars);
   }

to_variant() [57/97]

template<typename K , typename T >

void fc::to_variant	(	const std::map< K, T > &	var,
		fc::variant &	vo )

Definition at line 444 of file variant.hpp.

   {
       if( var.size() > MAX_NUM_ARRAY_ELEMENTS ) throw std::range_error( "too large" );
       std::vector< fc::variant > vars(var.size());
       size_t i = 0;
       for( auto itr = var.begin(); itr != var.end(); ++itr, ++i )
          vars[i] = fc::variant(*itr);
       vo = vars;
   }

to_variant() [58/97]

template<typename K , typename T >

void fc::to_variant	(	const std::multimap< K, T > &	var,
		fc::variant &	vo )

Definition at line 464 of file variant.hpp.

   {
       if( var.size() > MAX_NUM_ARRAY_ELEMENTS ) throw std::range_error( "too large" );
       std::vector< fc::variant > vars(var.size());
       size_t i = 0;
       for( auto itr = var.begin(); itr != var.end(); ++itr, ++i )
          vars[i] = fc::variant(*itr);
       vo = vars;
   }

to_variant() [59/97]

template<typename A , typename B >

void fc::to_variant	(	const std::pair< A, B > &	t,
		fc::variant &	v )

Definition at line 596 of file variant.hpp.

   {
      std::vector<fc::variant> vars(2);
      vars[0] = fc::variant(t.first);
      vars[1] = fc::variant(t.second);
       v = vars;
   }

to_variant() [60/97]

template<typename T >

void fc::to_variant	(	const std::set< T > &	var,
		fc::variant &	vo )

Definition at line 485 of file variant.hpp.

   {
       if( var.size() > MAX_NUM_ARRAY_ELEMENTS ) throw std::range_error( "too large" );
       std::vector<fc::variant> vars(var.size());
       size_t i = 0;
       for( auto itr = var.begin(); itr != var.end(); ++itr, ++i )
          vars[i] = fc::variant(*itr);
       vo = vars;
   }

to_variant() [61/97]

template<typename T >

void fc::to_variant	(	const std::shared_ptr< T > &	var,
		fc::variant &	vo )

Definition at line 633 of file variant.hpp.

   {
      if( var ) to_variant( *var, vo );
      else vo = nullptr;
   }

Here is the call graph for this function:

to_variant() [62/97]

void fc::to_variant	(	const std::string &	s,
		fc::variant &	v )

Definition at line 719 of file variant.cpp.

{
   v = variant( fc::string(s) );
}

to_variant() [63/97]

template<typename T >

void fc::to_variant	(	const std::unique_ptr< T > &	s,
		fc::variant &	v )

Definition at line 650 of file variant.hpp.

   {
      if( var ) to_variant( *var, vo );
      else vo = nullptr;
   }

Here is the call graph for this function:

to_variant() [64/97]

template<typename K , typename T >

void fc::to_variant	(	const std::unordered_map< K, T > &	var,
		fc::variant &	vo )

Definition at line 424 of file variant.hpp.

   {
       if( var.size() > MAX_NUM_ARRAY_ELEMENTS ) throw std::range_error( "too large" );
       std::vector< fc::variant > vars(var.size());
       size_t i = 0;
       for( auto itr = var.begin(); itr != var.end(); ++itr, ++i )
          vars[i] = fc::variant(*itr);
       vo = vars;
   }

to_variant() [65/97]

template<typename T >

void fc::to_variant	(	const std::unordered_set< T > &	var,
		fc::variant &	vo )

Definition at line 402 of file variant.hpp.

   {
       if( var.size() > MAX_NUM_ARRAY_ELEMENTS ) throw std::range_error( "too large" );
       std::vector<fc::variant> vars(var.size());
       size_t i = 0;
       for( auto itr = var.begin(); itr != var.end(); ++itr, ++i )
          vars[i] = fc::variant(*itr);
       vo = vars;
   }

to_variant() [66/97]

template<typename... T>

void fc::to_variant	(	const std::variant< T... > &	s,
		fc::variant &	v )

Definition at line 71 of file static_variant.hpp.

{
  variants vars(2);
  vars[0] = s.index();
  std::visit( from_static_variant(vars[1]), s );
  v = std::move(vars);
}

to_variant() [67/97]

void fc::to_variant	(	const std::vector< char > &	var,
		fc::variant &	vo )

Definition at line 729 of file variant.cpp.

{
   FC_ASSERT( var.size() <= MAX_SIZE_OF_BYTE_ARRAYS );
   if( var.size() )
      vo = variant(to_hex(var.data(),var.size()));
   else vo = "";
}

Here is the call graph for this function:

to_variant() [68/97]

template<typename T >

void fc::to_variant	(	const std::vector< T > &	t,
		fc::variant &	v )

Definition at line 566 of file variant.hpp.

   {
      if( t.size() > MAX_NUM_ARRAY_ELEMENTS ) throw std::range_error( "too large" );
      std::vector<fc::variant> vars(t.size());
       for( size_t i = 0; i < t.size(); ++i )
          vars[i] = fc::variant(t[i]);
       v = std::move(vars);
   }

to_variant() [69/97]

void fc::to_variant ( const sysio::chain::asset & var, fc::variant & vo )

inline

Definition at line 107 of file asset.hpp.

{ vo = var.to_string(); }

Here is the call graph for this function:

to_variant() [70/97]

template<uint16_t IntervalMs, uint64_t EpochMs>

void fc::to_variant	(	const sysio::chain::block_timestamp< IntervalMs, EpochMs > &	t,
		fc::variant &	v )

Definition at line 85 of file block_timestamp.hpp.

                                                                                        {
     to_variant( (fc::time_point)t, v);
  }

Here is the call graph for this function:

to_variant() [71/97]

void fc::to_variant	(	const sysio::chain::chain_id_type &	cid,
		fc::variant &	v )

Definition at line 14 of file chain_id_type.cpp.

                                                                     {
      to_variant( static_cast<const fc::sha256&>(cid), v);
   }

Here is the call graph for this function:

to_variant() [72/97]

template<typename T >

void fc::to_variant	(	const sysio::chain::may_not_exist< T > &	e,
		fc::variant &	v )

Definition at line 159 of file abi_def.hpp.

                                                                   {
   to_variant( e.value, v);
}

Here is the call graph for this function:

to_variant() [73/97]

void fc::to_variant	(	const sysio::chain::name &	c,
		fc::variant &	v )

Definition at line 38 of file name.cpp.

{ v = c.to_string(); }

Here is the call graph for this function:

to_variant() [74/97]

void fc::to_variant ( const sysio::chain::shared_blob & b, variant & v )

inline

Definition at line 179 of file database_utils.hpp.

                                                                 {
      v = variant(base64_encode(b.data(), b.size()));
   }

Here is the call graph for this function:

to_variant() [75/97]

void fc::to_variant	(	const sysio::chain::shared_public_key &	var,
		fc::variant &	vo )

Definition at line 4 of file authority.cpp.

                                                                          {
      vo = var.to_string();
   }

Here is the call graph for this function:

Here is the caller graph for this function:

to_variant() [76/97]

void fc::to_variant ( const sysio::chain::shared_string & s, variant & v )

inline

Definition at line 167 of file database_utils.hpp.

                                                                   {
      v = variant(std::string(s.begin(), s.end()));
   }

to_variant() [77/97]

template<typename T >

void fc::to_variant	(	const sysio::chain::shared_vector< T > &	sv,
		variant &	v )

Definition at line 201 of file database_utils.hpp.

                                                                       {
      to_variant(std::vector<T>(sv.begin(), sv.end()), v);
   }

Here is the call graph for this function:

to_variant() [78/97]

void fc::to_variant ( const sysio::chain::symbol & var, fc::variant & vo )

inline

Definition at line 172 of file symbol.hpp.

{ vo = var.to_string(); }

Here is the call graph for this function:

to_variant() [79/97]

void fc::to_variant ( const sysio::chain::symbol_code & var, fc::variant & vo )

inline

Definition at line 179 of file symbol.hpp.

                                                                           {
      vo = sysio::chain::symbol(var.value << 8).name();
   }

Here is the call graph for this function:

to_variant() [80/97]

template<typename T >

void fc::to_variant	(	const T &	o,
		variant &	v )

Definition at line 98 of file variant.hpp.

   {
      if_enum<typename fc::reflector<T>::is_enum>::to_variant( o, v );
   }

Here is the call graph for this function:

to_variant() [81/97]

void fc::to_variant	(	const time_point &	var,
		fc::variant &	vo )

Definition at line 80 of file time.cpp.

                                                       {
    v = fc::string( t );
  }

to_variant() [82/97]

void fc::to_variant	(	const time_point_sec &	var,
		fc::variant &	vo )

Definition at line 86 of file time.cpp.

                                                           {
    v = fc::string( t );
  }

to_variant() [83/97]

void fc::to_variant	(	const uint128 &	var,
		variant &	vo )

Definition at line 377 of file uint128.cpp.

{ vo = std::string(var);         }

Here is the call graph for this function:

to_variant() [84/97]

void fc::to_variant	(	const uint16_t &	var,
		fc::variant &	vo )

Definition at line 641 of file variant.cpp.

{ vo = uint64_t(var); }

to_variant() [85/97]

void fc::to_variant	(	const uint32_t &	var,
		fc::variant &	vo )

Definition at line 649 of file variant.cpp.

{ vo = uint64_t(var); }

to_variant() [86/97]

void fc::to_variant	(	const uint8_t &	var,
		fc::variant &	vo )

Definition at line 633 of file variant.cpp.

{ vo = uint64_t(var); }

to_variant() [87/97]

void fc::to_variant	(	const UInt< 16 > &	n,
		fc::variant &	v )

Definition at line 752 of file variant.cpp.

{ v = uint64_t(n); }

to_variant() [88/97]

void fc::to_variant	(	const UInt< 32 > &	n,
		fc::variant &	v )

Definition at line 756 of file variant.cpp.

{ v = uint64_t(n); }

to_variant() [89/97]

void fc::to_variant	(	const UInt< 64 > &	n,
		fc::variant &	v )

Definition at line 760 of file variant.cpp.

{ v = uint64_t(n); }

to_variant() [90/97]

void fc::to_variant	(	const UInt< 8 > &	n,
		fc::variant &	v )

Definition at line 748 of file variant.cpp.

{ v = uint64_t(n); }

to_variant() [91/97]

void fc::to_variant	(	const unsigned __int128 &	var,
		fc::variant &	vo )

Definition at line 664 of file variant.cpp.

                                                               {
   vo = boost::multiprecision::uint128_t( var ).str();
}

to_variant() [92/97]

void fc::to_variant	(	const unsigned_int &	var,
		variant &	vo )

Definition at line 8 of file varint.cpp.

{ vo = var.value; }

to_variant() [93/97]

void fc::to_variant	(	const url &	u,
		fc::variant &	v )

Definition at line 81 of file url.cpp.

  {
    v = fc::string(u);
  }

to_variant() [94/97]

void fc::to_variant	(	const variant_object &	var,
		fc::variant &	vo )

Definition at line 177 of file variant_object.cpp.

   {
      vo = variant(var);
   }

to_variant() [95/97]

void fc::to_variant	(	log_level	e,
		variant &	v )

Definition at line 109 of file log_message.cpp.

   {
      switch( e )
      {
        case log_level::all: 
           v = "all";
           return;
        case log_level::debug:
           v = "debug";
           return;
        case log_level::info:
           v = "info";
           return;
        case log_level::warn:
           v = "warn";
           return;
        case log_level::error:
           v = "error";
           return;
        case log_level::off:
           v = "off";
           return;
      }
   }

to_variant() [96/97]

void fc::to_variant	(	long long int	s,
		fc::variant &	v )

Definition at line 871 of file variant.cpp.

{ v = variant( int64_t(s) ); }

to_variant() [97/97]

void fc::to_variant	(	unsigned long long int	s,
		fc::variant &	v )

Definition at line 872 of file variant.cpp.

{ v = variant( uint64_t(s)); }

token_from_stream()

template<typename T >

variant fc::token_from_stream

(

T &

in

)

Definition at line 317 of file json.cpp.

   {
      std::stringstream ss;
      ss.exceptions( std::ifstream::badbit );
      bool received_eof = false;
      bool done = false;
 
      try
      {
        char c;
        while((c = in.peek()) && !done)
        {
           switch( c )
           {
              case 'n':
              case 'u':
              case 'l':
              case 't':
              case 'r':
              case 'e':
              case 'f':
              case 'a':
              case 's':
                 ss.put( in.get() );
                 break;
              default:
                 done = true;
                 break;
           }
        }
      }
      catch (fc::eof_exception&)
      {
        received_eof = true;
      }
      catch (const std::ios_base::failure&)
      {
        received_eof = true;
      }
 
      // we can get here either by processing a delimiter as in "null,"
      // an EOF like "null<EOF>", or an invalid token like "nullZ"
      std::string str = ss.str();
      if( str == "null" )
        return variant();
      if( str == "true" )
        return true;
      if( str == "false" )
        return false;
      else
      {
        if (received_eof)
        {
          if (str.empty())
            FC_THROW_EXCEPTION( parse_error_exception, "Unexpected EOF" );
          else
            return str;
        }
        else
        {
          // if we've reached this point, we've either seen a partial
          // token ("tru<EOF>") or something our simple parser couldn't
          // make out ("falfe")
          // A strict JSON parser would signal this as an error, but we
          // will just treat the malformed token as an un-quoted string.
          return str + stringFromToken(in);;
        }
      }
   }

Here is the call graph for this function:

Here is the caller graph for this function:

trim()

std::string fc::trim

(

const fc::string &

s

)

Definition at line 152 of file string.cpp.

  {
      return boost::algorithm::trim_copy(s);
      /*
      std::string cpy(s);
      boost::algorithm::trim(cpy);
      return cpy;
      */
  }

Here is the call graph for this function:

Here is the caller graph for this function:

trim_and_normalize_spaces()

string fc::trim_and_normalize_spaces

(

const string &

s

)

Definition at line 167 of file string.cpp.

  {
     string result = boost::algorithm::trim_copy( s );
     while( result.find( "  " ) != result.npos )
       boost::algorithm::replace_all( result, "  ", " " );
     return result;
  }

Here is the call graph for this function:

Here is the caller graph for this function:

uint128_to_float128()

void fc::uint128_to_float128 ( const sysio::chain::uint128_t & u, float128_t & f )

inline

Definition at line 125 of file database_utils.hpp.

                                                                           {
      memcpy(&f, &u, sizeof(f));
   }

Here is the call graph for this function:

Here is the caller graph for this function:

Uint128High64()

uint64_t fc::Uint128High64 ( const uint128 & x )

inline

Definition at line 51 of file city.cpp.

{ return x.high_bits(); }

Here is the call graph for this function:

Here is the caller graph for this function:

Uint128Low64()

uint64_t fc::Uint128Low64 ( const uint128 & x )

inline

Definition at line 50 of file city.cpp.

{ return x.low_bits(); }

Here is the call graph for this function:

Here is the caller graph for this function:

underflow_exception()

file_not_found_exception parse_error_exception invalid_arg_exception invalid_operation_exception key_not_found_exception bad_cast_exception out_of_range_exception canceled_exception assert_exception eof_exception unknown_host_exception null_optional udt_exception aes_exception overflow_exception fc::underflow_exception

(

divide_by_zero_exception

)

Definition at line 1 of file exception.cpp.

   {
      class exception_impl
      {
         public:
            std::string     _name;
            std::string     _what;
            int64_t         _code;
            log_messages    _elog;
      };
   }

Here is the call graph for this function:

Here is the caller graph for this function:

unique_path()

path fc::unique_path

(

)

Definition at line 365 of file filesystem.cpp.

{ return boost::filesystem::unique_path(); }

variant_from_stream()

template<typename T , json::parse_type parser_type>

variant fc::variant_from_stream	(	T &	in,
		uint32_t	max_depth )

Definition at line 389 of file json.cpp.

   {
      if( max_depth == 0 )
          FC_THROW_EXCEPTION( parse_error_exception, "Too many nested items in JSON input!" );
      skip_white_space(in);
      variant var;
      while( 1 )
      {
         signed char c = in.peek();
         switch( c )
         {
            case ' ':
            case '\t':
            case '\n':
            case '\r':
              in.get();
              continue;
            case '"':
              return stringFromStream( in );
            case '{':
               return objectFromStream<T, parser_type>( in, max_depth - 1 );
            case '[':
              return arrayFromStream<T, parser_type>( in, max_depth - 1 );
            case '-':
            case '.':
            case '0':
            case '1':
            case '2':
            case '3':
            case '4':
            case '5':
            case '6':
            case '7':
            case '8':
            case '9':
              return number_from_stream<T, parser_type>( in );
            // null, true, false, or 'warning' / string
            case 'n':
            case 't':
            case 'f':
              return token_from_stream( in );
            case 0x04: // ^D end of transmission
            case EOF:
            case '\0':
              FC_THROW_EXCEPTION( eof_exception, "unexpected end of file" );
            default:
              FC_THROW_EXCEPTION( parse_error_exception, "Unexpected char '${c}' in \"${s}\"",
                                 ("c", c)("s", stringFromToken(in)) );
         }
      }
      return variant();
   }

Here is the call graph for this function:

Here is the caller graph for this function:

zlib_compress()

string fc::zlib_compress

(

const string &

in

)

Definition at line 11 of file zlib.cpp.

  {
    string out;
    bio::filtering_ostream comp;
    comp.push(bio::zlib_compressor(bio::zlib::default_compression));
    comp.push(bio::back_inserter(out));
    bio::write(comp, in.data(), in.size());
    bio::close(comp);
    return out;
  }

Here is the caller graph for this function:

Variable Documentation

do_default_config

bool fc::do_default_config = configure_logging( logging_config::default_config() )

Definition at line 107 of file logger.cpp.

enable_record_assert_trip

bool fc::enable_record_assert_trip = false

Definition at line 325 of file exception.cpp.

git_revision_sha

const char* const fc::git_revision_sha

extern

git_revision_unix_timestamp

const uint32_t fc::git_revision_unix_timestamp

extern

hex_digits

char fc::hex_digits[] = "0123456789abcdef"

inlineconstexpr

Definition at line 11 of file utf8.cpp.

minimize_max_size

size_t fc::minimize_max_size = 1024

constexpr

Definition at line 763 of file variant.cpp.

y

uint64_t fc::y { return (x << y) | (x >> (64-y))

Definition at line 34 of file sha3.cpp.