epee Namespace Reference

Namespaces
namespace	ado_db_helper
namespace	file_io_utils
namespace	fnv
namespace	net_utils
namespace	math_helper
namespace	misc_utils
namespace	debug
namespace	json_rpc
namespace	levin
namespace	profile_tools
namespace	reg_utils
namespace	serialization
namespace	StorageNamed
namespace	string_encoding
namespace	string_tools
namespace	tiny_ini
namespace	zlib_helper
namespace	tests

Classes
class	async_stdin_reader
class	async_console_handler
class	command_handler
class	console_handlers_binder
class	copyable_atomic
struct	to_hex
struct	from_hex
class	mlocker
struct	mlocked
class	http_server_impl_base
class	jsonrpc_server_impl_base
class	global_regexp_critical_section
struct	enableable
class	service_impl_base
class	span
	Non-owning sequence of data. Does not deep copy. More...
class	initializer
class	crypted_storage
struct	simple_event
class	critical_section
class	critical_region_t
class	critical_region
class	shared_critical_section
class	shared_guard
class	exclusive_guard
class	event
class	wipeable_string

Typedefs
template<class T, size_t N>
using	mlocked_arr = mlocked<std::array<T, N>>

Enumerations
enum	console_colors {   console_color_default , console_color_white , console_color_red , console_color_green ,   console_color_blue , console_color_cyan , console_color_magenta , console_color_yellow }

Functions
template<class t_server>
bool	empty_commands_handler (t_server *psrv, const std::string &command)
template<class t_server, class t_handler>
bool	start_default_console (t_server *ptsrv, t_handler handlr, std::function< std::string(void)> prompt, const std::string &usage="")
template<class t_server, class t_handler>
bool	start_default_console (t_server *ptsrv, t_handler handlr, const std::string &prompt, const std::string &usage="")
template<class t_server>
bool	start_default_console (t_server *ptsrv, const std::string &prompt, const std::string &usage="")
template<class t_server, class t_handler>
bool	no_srv_param_adapter (t_server *ptsrv, const std::string &cmd, t_handler handlr)
template<class t_server, class t_handler>
bool	run_default_console_handler_no_srv_param (t_server *ptsrv, t_handler handlr, std::function< std::string(void)> prompt, const std::string &usage="")
template<class t_server, class t_handler>
bool	run_default_console_handler_no_srv_param (t_server *ptsrv, t_handler handlr, const std::string &prompt, const std::string &usage="")
template<class t_server, class t_handler>
bool	start_default_console_handler_no_srv_param (t_server *ptsrv, t_handler handlr, std::function< std::string(void)> prompt, const std::string &usage="")
template<class t_server, class t_handler>
bool	start_default_console_handler_no_srv_param (t_server *ptsrv, t_handler handlr, const std::string &prompt, const std::string &usage="")
bool	is_stdout_a_tty ()
void	set_console_color (int color, bool bright)
void	reset_console_color ()
template<typename T>
T &	unwrap (mlocked< T > &src)
template<typename T>
const T &	unwrap (mlocked< T > const &src)
template<typename T>
void	serialize_default (const T &t, T v)
template<typename T>
void	serialize_default (T &t, T v)
template<typename T>
constexpr span< const typename T::value_type >	to_span (const T &src)
template<typename T>
constexpr span< typename T::value_type >	to_mut_span (T &src)
template<typename T>
constexpr bool	has_padding () noexcept
template<typename T>
span< const std::uint8_t >	to_byte_span (const span< const T > src) noexcept
template<typename T>
span< const std::uint8_t >	as_byte_span (const T &src) noexcept
template<typename T>
span< std::uint8_t >	as_mut_byte_span (T &src) noexcept
template<typename T>
span< const T >	strspan (const std::string &s) noexcept
	make a span from a std::string
template<class Type>
Type::iterator	to_nonsonst_iterator (Type &obj, typename Type::const_iterator it)
template<class Type>
Type::iterator	to_nonsonst_iterator (typename Type::iterator base_it, typename Type::const_iterator it)
const char *	get_wait_for_result_as_text (DWORD res)

Variables
unsigned int	g_test_dbg_lock_sleep = 0

Typedef Documentation

mlocked_arr

template<class T, size_t N>

using epee::mlocked_arr = mlocked<std::array<T, N>>

Definition at line 86 of file mlocker.h.

Enumeration Type Documentation

console_colors

enum epee::console_colors

Enumerator
console_color_default
console_color_white
console_color_red
console_color_green
console_color_blue
console_color_cyan
console_color_magenta
console_color_yellow

Definition at line 206 of file misc_log_ex.h.

{
  console_color_default,
  console_color_white,
  console_color_red,
  console_color_green,
  console_color_blue,
  console_color_cyan,
  console_color_magenta,
  console_color_yellow
};

Function Documentation

as_byte_span()

template<typename T>

span< const std::uint8_t > epee::as_byte_span ( const T & src )

noexcept

Returns

span<const std::uint8_t> which represents the bytes at &src.

Definition at line 153 of file span.h.

  {
    static_assert(!std::is_empty<T>(), "empty types will not work -> sizeof == 1");
    static_assert(!has_padding<T>(), "source type may have padding");
    return {reinterpret_cast<const std::uint8_t*>(std::addressof(src)), sizeof(T)};
  }

Here is the call graph for this function:

Here is the caller graph for this function:

as_mut_byte_span()

template<typename T>

span< std::uint8_t > epee::as_mut_byte_span ( T & src )

noexcept

Returns

span<std::uint8_t> which represents the bytes at &src.

Definition at line 162 of file span.h.

  {
    static_assert(!std::is_empty<T>(), "empty types will not work -> sizeof == 1");
    static_assert(!has_padding<T>(), "source type may have padding");
    return {reinterpret_cast<std::uint8_t*>(std::addressof(src)), sizeof(T)};
  }

Here is the call graph for this function:

Here is the caller graph for this function:

empty_commands_handler()

template<class t_server>

bool epee::empty_commands_handler	(	t_server *	psrv,
		const std::string &	command )

Definition at line 284 of file console_handler.h.

  {
    return true;
  }

Here is the caller graph for this function:

get_wait_for_result_as_text()

const char * epee::get_wait_for_result_as_text ( DWORD res )

inline

Definition at line 210 of file winobj.h.

    {
        switch(res)
        {
        case WAIT_ABANDONED: return "WAIT_ABANDONED";
        case WAIT_TIMEOUT:  return "WAIT_TIMEOUT";
        case WAIT_OBJECT_0: return "WAIT_OBJECT_0";
        case WAIT_OBJECT_0+1: return "WAIT_OBJECT_1";
        case WAIT_OBJECT_0+2: return "WAIT_OBJECT_2";
        default:
            return "UNKNOWN CODE";
        }
        
    }

has_padding()

template<typename T>

bool epee::has_padding ( )

constexprnoexcept

Definition at line 138 of file span.h.

  {
    return !std::is_standard_layout<T>() || alignof(T) != 1;
  }

Here is the caller graph for this function:

is_stdout_a_tty()

bool epee::is_stdout_a_tty

(

)

Definition at line 323 of file mlog.cpp.

{
  static std::atomic<bool> initialized(false);
  static std::atomic<bool> is_a_tty(false);
 
  if (!initialized.load(std::memory_order_acquire))
  {
#if defined(WIN32)
    is_a_tty.store(0 != _isatty(_fileno(stdout)), std::memory_order_relaxed);
#else
    is_a_tty.store(0 != isatty(fileno(stdout)), std::memory_order_relaxed);
#endif
    initialized.store(true, std::memory_order_release);
  }
 
  return is_a_tty.load(std::memory_order_relaxed);
}

Here is the caller graph for this function:

no_srv_param_adapter()

template<class t_server, class t_handler>

bool epee::no_srv_param_adapter	(	t_server *	ptsrv,
		const std::string &	cmd,
		t_handler	handlr )

Definition at line 429 of file console_handler.h.

    {
      return handlr(cmd);
    }

Here is the caller graph for this function:

reset_console_color()

void epee::reset_console_color

(

)

Definition at line 460 of file mlog.cpp.

                           {
  if (!is_stdout_a_tty())
    return;
 
#ifdef WIN32
  HANDLE h_stdout = GetStdHandle(STD_OUTPUT_HANDLE);
  SetConsoleTextAttribute(h_stdout, FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_BLUE);
#else
  std::cout << "\033[0m";
  std::cout.flush();
#endif
}

Here is the call graph for this function:

Here is the caller graph for this function:

run_default_console_handler_no_srv_param() [1/2]

template<class t_server, class t_handler>

bool epee::run_default_console_handler_no_srv_param	(	t_server *	ptsrv,
		t_handler	handlr,
		const std::string &	prompt,
		const std::string &	usage = "" )

Definition at line 442 of file console_handler.h.

  {
    return run_default_console_handler_no_srv_param(ptsrv, handlr, [prompt](){return prompt;},usage);
  }

Here is the call graph for this function:

run_default_console_handler_no_srv_param() [2/2]

template<class t_server, class t_handler>

bool epee::run_default_console_handler_no_srv_param	(	t_server *	ptsrv,
		t_handler	handlr,
		std::function< std::string(void)>	prompt,
		const std::string &	usage = "" )

Definition at line 435 of file console_handler.h.

  {
    async_console_handler console_handler;
    return console_handler.run(ptsrv, std::bind<bool>(no_srv_param_adapter<t_server, t_handler>, std::placeholders::_1, std::placeholders::_2, handlr), prompt, usage);
  }

Here is the call graph for this function:

Here is the caller graph for this function:

serialize_default() [1/2]

template<typename T>

void epee::serialize_default ( const T & t, T v )

inline

Definition at line 75 of file keyvalue_serialization.h.

{ }

serialize_default() [2/2]

template<typename T>

void epee::serialize_default ( T & t, T v )

inline

Definition at line 76 of file keyvalue_serialization.h.

{ t = v; }

set_console_color()

void epee::set_console_color	(	int	color,
		bool	bright )

Definition at line 341 of file mlog.cpp.

{
  if (!is_stdout_a_tty())
    return;
 
  switch(color)
  {
  case console_color_default:
    {
#ifdef WIN32
      HANDLE h_stdout = GetStdHandle(STD_OUTPUT_HANDLE);
      SetConsoleTextAttribute(h_stdout, FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_BLUE| (bright ? FOREGROUND_INTENSITY:0));
#else
      if(bright)
        std::cout << "\033[1;37m";
      else
        std::cout << "\033[0m";
#endif
    }
    break;
  case console_color_white:
    {
#ifdef WIN32
      HANDLE h_stdout = GetStdHandle(STD_OUTPUT_HANDLE);
      SetConsoleTextAttribute(h_stdout, FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_BLUE | (bright ? FOREGROUND_INTENSITY:0));
#else
      if(bright)
        std::cout << "\033[1;37m";
      else
        std::cout << "\033[0;37m";
#endif
    }
    break;
  case console_color_red:
    {
#ifdef WIN32
      HANDLE h_stdout = GetStdHandle(STD_OUTPUT_HANDLE);
      SetConsoleTextAttribute(h_stdout, FOREGROUND_RED | (bright ? FOREGROUND_INTENSITY:0));
#else
      if(bright)
        std::cout << "\033[1;31m";
      else
        std::cout << "\033[0;31m";
#endif
    }
    break;
  case console_color_green:
    {
#ifdef WIN32
      HANDLE h_stdout = GetStdHandle(STD_OUTPUT_HANDLE);
      SetConsoleTextAttribute(h_stdout, FOREGROUND_GREEN | (bright ? FOREGROUND_INTENSITY:0));
#else
      if(bright)
        std::cout << "\033[1;32m";
      else
        std::cout << "\033[0;32m";
#endif
    }
    break;
 
  case console_color_blue:
    {
#ifdef WIN32
      HANDLE h_stdout = GetStdHandle(STD_OUTPUT_HANDLE);
      SetConsoleTextAttribute(h_stdout, FOREGROUND_BLUE | FOREGROUND_INTENSITY);//(bright ? FOREGROUND_INTENSITY:0));
#else
      if(bright)
        std::cout << "\033[1;34m";
      else
        std::cout << "\033[0;34m";
#endif
    }
    break;
 
  case console_color_cyan:
    {
#ifdef WIN32
      HANDLE h_stdout = GetStdHandle(STD_OUTPUT_HANDLE);
      SetConsoleTextAttribute(h_stdout, FOREGROUND_GREEN | FOREGROUND_BLUE | (bright ? FOREGROUND_INTENSITY:0));
#else
      if(bright)
        std::cout << "\033[1;36m";
      else
        std::cout << "\033[0;36m";
#endif
    }
    break;
 
  case console_color_magenta:
    {
#ifdef WIN32
      HANDLE h_stdout = GetStdHandle(STD_OUTPUT_HANDLE);
      SetConsoleTextAttribute(h_stdout, FOREGROUND_BLUE | FOREGROUND_RED | (bright ? FOREGROUND_INTENSITY:0));
#else
      if(bright)
        std::cout << "\033[1;35m";
      else
        std::cout << "\033[0;35m";
#endif
    }
    break;
 
  case console_color_yellow:
    {
#ifdef WIN32
      HANDLE h_stdout = GetStdHandle(STD_OUTPUT_HANDLE);
      SetConsoleTextAttribute(h_stdout, FOREGROUND_RED | FOREGROUND_GREEN | (bright ? FOREGROUND_INTENSITY:0));
#else
      if(bright)
        std::cout << "\033[1;33m";
      else
        std::cout << "\033[0;33m";
#endif
    }
    break;
 
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

start_default_console() [1/3]

template<class t_server>

bool epee::start_default_console	(	t_server *	ptsrv,
		const std::string &	prompt,
		const std::string &	usage = "" )

Definition at line 423 of file console_handler.h.

  {
    return start_default_console(ptsrv, empty_commands_handler<t_server>, prompt, usage);
  }

Here is the call graph for this function:

start_default_console() [2/3]

template<class t_server, class t_handler>

bool epee::start_default_console	(	t_server *	ptsrv,
		t_handler	handlr,
		const std::string &	prompt,
		const std::string &	usage = "" )

Definition at line 417 of file console_handler.h.

  {
    return start_default_console(ptsrv, handlr, [prompt](){ return prompt; }, usage);
  }

Here is the call graph for this function:

start_default_console() [3/3]

template<class t_server, class t_handler>

bool epee::start_default_console	(	t_server *	ptsrv,
		t_handler	handlr,
		std::function< std::string(void)>	prompt,
		const std::string &	usage = "" )

Definition at line 409 of file console_handler.h.

  {
    std::shared_ptr<async_console_handler> console_handler = std::make_shared<async_console_handler>();
    boost::thread([=](){console_handler->run<t_server, t_handler>(ptsrv, handlr, prompt, usage);}).detach();
    return true;
  }

Here is the caller graph for this function:

start_default_console_handler_no_srv_param() [1/2]

template<class t_server, class t_handler>

bool epee::start_default_console_handler_no_srv_param	(	t_server *	ptsrv,
		t_handler	handlr,
		const std::string &	prompt,
		const std::string &	usage = "" )

Definition at line 455 of file console_handler.h.

  {
    return start_default_console_handler_no_srv_param(ptsrv, handlr, [prompt](){return prompt;}, usage);
  }

Here is the call graph for this function:

start_default_console_handler_no_srv_param() [2/2]

template<class t_server, class t_handler>

bool epee::start_default_console_handler_no_srv_param	(	t_server *	ptsrv,
		t_handler	handlr,
		std::function< std::string(void)>	prompt,
		const std::string &	usage = "" )

Definition at line 448 of file console_handler.h.

  {
    boost::thread( boost::bind(run_default_console_handler_no_srv_param<t_server, t_handler>, ptsrv, handlr, prompt, usage) );
    return true;
  }

Here is the call graph for this function:

Here is the caller graph for this function:

strspan()

template<typename T>

span< const T > epee::strspan ( const std::string & s )

noexcept

make a span from a std::string

Definition at line 171 of file span.h.

  {
    static_assert(std::is_same<T, char>() || std::is_same<T, unsigned char>() || std::is_same<T, int8_t>() || std::is_same<T, uint8_t>(), "Unexpected type");
    return {reinterpret_cast<const T*>(s.data()), s.size()};
  }

Here is the caller graph for this function:

to_byte_span()

template<typename T>

span< const std::uint8_t > epee::to_byte_span ( const span< const T > src )

noexcept

Returns

Cast data from src as span<const std::uint8_t>.

Definition at line 145 of file span.h.

  {
    static_assert(!has_padding<T>(), "source type may have padding");
    return {reinterpret_cast<const std::uint8_t*>(src.data()), src.size_bytes()}; 
  }

Here is the call graph for this function:

Here is the caller graph for this function:

to_mut_span()

template<typename T>

span< typename T::value_type > epee::to_mut_span ( T & src )

constexpr

Returns

span<T::value_type> from a STL compatible src.

Definition at line 131 of file span.h.

  {
    // compiler provides diagnostic if size() is not size_t.
    return {src.data(), src.size()};
  }

Here is the caller graph for this function:

to_nonsonst_iterator() [1/2]

template<class Type>

Type::iterator epee::to_nonsonst_iterator	(	Type &	obj,
		typename Type::const_iterator	it )

Definition at line 36 of file to_nonconst_iterator.h.

{
    typename Type::difference_type dist =  std::distance(static_cast<typename Type::const_iterator>(obj.begin()), it);
    typename Type::iterator res_it = obj.begin()+dist;
    return res_it;
}

to_nonsonst_iterator() [2/2]

template<class Type>

Type::iterator epee::to_nonsonst_iterator	(	typename Type::iterator	base_it,
		typename Type::const_iterator	it )

Definition at line 45 of file to_nonconst_iterator.h.

{
    typename Type::difference_type dist =  std::distance(static_cast<typename Type::const_iterator>(base_it), it);
    typename Type::iterator res_it = base_it+dist;
    return res_it;
}

to_span()

template<typename T>

span< const typename T::value_type > epee::to_span ( const T & src )

constexpr

Returns

span<const T::value_type> from a STL compatible src.

Definition at line 123 of file span.h.

  {
    // compiler provides diagnostic if size() is not size_t.
    return {src.data(), src.size()};
  }

Here is the caller graph for this function:

unwrap() [1/2]

template<typename T>

T & epee::unwrap

(

mlocked< T > &

src

)

Definition at line 80 of file mlocker.h.

{ return src; }

Here is the caller graph for this function:

unwrap() [2/2]

template<typename T>

const T & epee::unwrap

(

mlocked< T > const &

src

)

Definition at line 83 of file mlocker.h.

{ return src; }

Variable Documentation

g_test_dbg_lock_sleep

unsigned int epee::g_test_dbg_lock_sleep = 0

Definition at line 48 of file wallet_manager.cpp.