neolib Namespace Reference

Namespaces
namespace	container
namespace	detail
namespace	ecs
namespace	event_system
namespace	json_detail
namespace	logger
namespace	math
namespace	services
namespace	stdint_suffix
namespace	string_literals
namespace	type_traits_detail
namespace	utf16
namespace	variadic
namespace	variant_visitors

Classes
struct	abstract_interface
struct	abstract_interface< string >
class	any
class	any_const_iterator
class	any_const_ref
struct	any_const_ref_bad_cast
class	any_const_ref_holder
class	any_const_ref_holder_base
class	any_iterator
class	any_predicate
class	any_ref
struct	any_ref_bad_cast
class	any_ref_holder
class	any_ref_holder_base
class	any_to_utf16_result
class	any_to_utf16_result< std::u16string >
class	application
class	application_info
class	array_tree
struct	as_setting
class	async_event_queue
class	async_task
class	async_thread
struct	bad_enum_string
struct	bad_enum_value
struct	bad_numeric_variant_cast
struct	bad_variant_access
class	basic_binary_data_packet
class	basic_binary_packet
class	basic_character_map
class	basic_character_map< wchar_t >
class	basic_cookie_ref_ptr
class	basic_data_packet
class	basic_enum
class	basic_jar
class	basic_json
class	basic_json_array
struct	basic_json_keyword
struct	basic_json_null
class	basic_json_object
class	basic_json_value
class	basic_packet_connection
class	basic_quick_string
class	basic_random
class	basic_resolver
class	basic_small_buffer_allocator
class	basic_small_buffer_allocator< small_buffer_allocator_types< T, R >, SmallBufferSize >
class	basic_string_packet
class	basic_tld_packet
class	basic_vector_jar
class	basic_xml
class	bresenham_counter
class	bresenham_counter_alt
class	callback_timer
struct	check
struct	ci_char_traits
struct	ci_equal_to
struct	ci_less
struct	comma_and_brackets_as_whitespace
struct	comma_as_whitespace
struct	comma_only_whitespace
class	const_iterator
struct	const_selector
struct	const_selector< ConstType, NonConstType, false >
struct	const_selector< ConstType, NonConstType, true >
struct	const_selector_from_pointer
struct	cookie_already_added
struct	cookie_invalid
struct	cookies_exhausted
struct	crack_key
struct	crack_key< T, typename std::void_t< typename T::key_type > >
class	custom_type
class	DefaultPacketTraits
class	deque
struct	duplicate_plugin
class	event
class	fast_vector
struct	format_result
struct	from_abstract
struct	from_abstract< false, AbstractT, Type >
struct	from_abstract< false, AbstractT, Type, Rest... >
struct	from_abstract< true, AbstractT, Type >
struct	from_abstract< true, AbstractT, Type, Rest... >
struct	from_abstract_next
struct	from_abstract_next< AbstractT, Type >
struct	from_abstract_next< AbstractT, Type, Rest >
struct	from_abstract_next< AbstractT, Type, Rest... >
class	function_task
class	generic_iterator
struct	get_setting_type
struct	get_setting_type< setting_type::Boolean >
struct	get_setting_type< setting_type::Float32 >
struct	get_setting_type< setting_type::Float64 >
struct	get_setting_type< setting_type::Int16 >
struct	get_setting_type< setting_type::Int32 >
struct	get_setting_type< setting_type::Int64 >
struct	get_setting_type< setting_type::Int8 >
struct	get_setting_type< setting_type::String >
struct	get_setting_type< setting_type::Uint16 >
struct	get_setting_type< setting_type::Uint32 >
struct	get_setting_type< setting_type::Uint64 >
struct	get_setting_type< setting_type::Uint8 >
class	gunzip
struct	has_loading_support
struct	has_saving_support
struct	has_stream_operators
class	http
class	http_packet
class	i_any
class	i_application
class	i_application_info
class	i_async_event_queue
class	i_async_service
class	i_async_task
class	i_basic_cookie_consumer
class	i_basic_enum
class	i_basic_jar
class	i_basic_packet
class	i_basic_packet_connection_owner
class	i_const_iterator
class	i_container
class	i_contiguous_random_access_container
class	i_custom_type
class	i_custom_type_factory
class	i_deque
class	i_discoverable
class	i_event
class	i_iterator
class	i_lifetime
class	i_lifetime_flag
class	i_list
struct	i_lockable
class	i_map
class	i_message_queue
class	i_multimap
class	i_multiset
class	i_object
class	i_optional
class	i_pair
class	i_plugin
class	i_plugin_manager
class	i_plugin_variant
class	i_power
class	i_program_arguments
class	i_random_access_const_iterator
class	i_random_access_container
class	i_random_access_iterator
class	i_ref_control_block
class	i_ref_ptr
class	i_reference_counted
class	i_sequence_container
class	i_set
class	i_setting
class	i_setting_constraints
class	i_setting_value
class	i_settings
class	i_shared_thread_local
	Shared thread local service. More...
class	i_slot
class	i_slot_base
class	i_string
class	i_task
class	i_thread
class	i_timer_object
class	i_timer_service
class	i_timer_subscriber
class	i_variant
class	i_vector
class	i_version
class	i_weak_ref_ptr
class	index_array_tree
class	indexitor
struct	is_optional
struct	is_optional< i_optional< T > >
struct	is_optional< optional< T > >
struct	is_variant
struct	is_variant< variant< Types... > >
class	iterator
struct	json_document_source_location
struct	json_error
struct	json_no_owning_node
struct	json_path_not_found
class	lexer
class	lexer_atom
struct	lexer_atom_match_any
class	lexer_rule
class	lexer_token
class	lifetime
class	lifetime_flag
class	list
class	map
struct	minmax
class	module
class	multimap
class	multiset
class	mutable_base
class	mutable_multiset
class	mutable_set
class	neo_pool_allocator
struct	no_pointer_value_type_cookie_lookup
struct	no_scopes
struct	nocheck
class	noncopyable
struct	null_mutex
class	oauth
class	object
class	offset_iterator
struct	offset_pointer
struct	offset_pointer< T, typename std::enable_if_t< std::is_const_v< T >, sfinae > >
struct	offset_pointer< T, typename std::enable_if_t<!std::is_const_v< T >, sfinae > >
class	openssl
class	optional
struct	optional_type
struct	optional_type< optional< T > >
struct	optional_type< std::optional< T > >
class	packet_stream
class	pair
class	plugin
class	plugin_manager
class	plugin_variant
class	power
struct	primes
class	program_arguments
class	proxy_mutex
class	queue
struct	quick_uuid_hash
class	random_access_const_iterator
class	random_access_iterator
class	random_traits
class	random_traversal
class	recursion_limiter
class	recursive_spinlock
class	red_black_tree
class	ref_control_block
class	ref_ptr
class	reference_counted
class	reserve_allocator
class	scoped_atomic_flag
class	scoped_counter
class	scoped_flag
class	scoped_multi_lock
class	scoped_object
class	scoped_optional
class	scoped_optional_if
class	scoped_pointer
class	segmented_array
class	segmented_tree
class	set
class	setting
class	setting_constraints
struct	setting_container_type
struct	setting_container_type< T, std::enable_if_t< std::is_enum_v< T >, sfinae > >
struct	setting_type_name
class	setting_value
class	settings
struct	sfinae
class	shared_thread_local
class	simple_file
class	singleton
struct	singular_iterator
class	sink
class	slot
struct	slot_proxy
struct	small_buffer
struct	small_buffer_allocator_types
class	specialized_generic_iterator
class	string
class	string_search_fsa
struct	string_span
struct	string_to_number_failure
class	switchable_mutex
class	tag_array
class	task
class	tcp_packet_stream_server
class	thread
class	thread_pool
class	timer
class	timer_object
class	timer_service
struct	unable_to_generate_uuid
struct	unknown_application_name
struct	unused_visitee
class	uri
class	uri_authority
struct	uuid
struct	variable_stack
class	variable_stack_context
struct	variadic_index
struct	variadic_index< T, T, Ts... >
struct	variadic_index< T, Tail, Ts... >
class	variant
struct	variant_type_not_convertible
struct	variant_type_not_equality_comparable
struct	variant_type_not_less_than_comparable
class	vecarray
struct	vecarray_overflow
class	vector
class	version
class	visitee
class	visitor
struct	wait_result_event
struct	wait_result_message
struct	wait_result_waitable
class	waitable
class	waitable_event
class	waitable_event_list
class	weak_ref_ptr
class	xml_cdata
class	xml_comment
class	xml_declaration
class	xml_dtd
class	xml_element
class	xml_node
class	xml_text
class	zip
class	zip_iterator
struct	zip_iterator_traits

Typedefs
template<setting_type ST>
using	setting_type_t = typename get_setting_type< ST >::type
template<typename T >
using	as_setting_t = typename as_setting< T >::type
template<typename T , std::size_t SmallBufferSize = 8u>
using	small_buffer_allocator = basic_small_buffer_allocator< small_buffer_allocator_types< T, T >, SmallBufferSize >
template<typename T , std::size_t ChunkSize = 1 * 1024 * 1024>
using	omega_pool_allocator = neo_pool_allocator< T, ChunkSize, true >
template<typename T , unsigned NextSize = 32>
using	thread_safe_pool_allocator = boost::pool_allocator< T, boost::default_user_allocator_new_delete, boost::details::pool::default_mutex, NextSize >
template<typename T , unsigned NextSize = 32>
using	pool_allocator = boost::pool_allocator< T, boost::default_user_allocator_new_delete, boost::details::pool::null_mutex, NextSize >
template<typename T , unsigned NextSize = 32>
using	thread_safe_fast_pool_allocator = boost::fast_pool_allocator< T, boost::default_user_allocator_new_delete, boost::details::pool::default_mutex, NextSize >
template<typename T , unsigned NextSize = 32>
using	fast_pool_allocator = boost::fast_pool_allocator< T, boost::default_user_allocator_new_delete, boost::details::pool::null_mutex, NextSize >
template<typename Enum >
using	enum_t = basic_enum< Enum >
template<typename ConcreteType >
using	abstract_interface_t = typename abstract_interface< ConcreteType >::type
template<typename T >
using	offset_pointer_t = typename offset_pointer< T >::pointer_type
template<typename Enum >
using	enum_enumerators_t = multimap< std::underlying_type_t< Enum >, string >
template<typename T >
using	i_enum_t = i_basic_enum< std::underlying_type_t< T > >
typedef i_basic_enum< uint8_t >	i_enum_u8
typedef i_basic_enum< uint16_t >	i_enum_u16
typedef i_basic_enum< uint32_t >	i_enum_u32
typedef i_basic_enum< uint64_t >	i_enum_u64
typedef i_basic_enum< int8_t >	i_enum_i8
typedef i_basic_enum< int16_t >	i_enum_i16
typedef i_basic_enum< int32_t >	i_enum_i32
typedef i_basic_enum< int64_t >	i_enum_i64
typedef i_enum_i32	i_enum
typedef uint32_t	cookie
typedef uint16_t	small_cookie
typedef uint64_t	large_cookie
typedef i_basic_cookie_consumer< cookie >	i_cookie_consumer
typedef i_basic_cookie_consumer< small_cookie >	i_small_cookie_consumer
template<typename T >
using	i_jar = i_basic_jar< T, i_vector< T >, cookie >
template<typename T >
using	i_small_jar = i_basic_jar< T, i_vector< T >, small_cookie >
typedef basic_cookie_ref_ptr< cookie >	cookie_ref_ptr
typedef basic_cookie_ref_ptr< small_cookie >	small_cookie_ref_ptr
template<typename T , typename MutexType = null_mutex>
using	jar = basic_jar< T, vector< T >, cookie, MutexType >
template<typename T , typename MutexType = null_mutex>
using	small_jar = basic_jar< T, vector< T >, small_cookie, MutexType >
template<typename T , typename MutexType = null_mutex>
using	vector_jar = basic_vector_jar< T, cookie, MutexType >
template<typename T , typename MutexType = null_mutex>
using	small_vector_jar = basic_vector_jar< T, small_cookie, MutexType >
typedef lifetime_flag< lifetime_state::Destroying >	destroying_flag
typedef std::optional< destroying_flag >	optional_destroying_flag
typedef lifetime_flag< lifetime_state::Destroyed >	destroyed_flag
typedef std::optional< destroyed_flag >	optional_destroyed_flag
using	spinlock = boost::fibers::detail::spinlock
template<typename T >
using	optional_t = typename optional_type< T >::type
typedef basic_quick_string< char >	quick_string
using	random = basic_random< uint32_t >
template<typename T , std::size_t N>
using	static_vector = boost::container::static_vector< T, N >
typedef std::basic_string< char, ci_char_traits< std::char_traits< char > > >	ci_string
typedef std::basic_string< char16_t, ci_char_traits< std::char_traits< char16_t > > >	ci_u16string
typedef variant< double, int32_t, uint32_t, int64_t, uint64_t >	number_t
typedef char32_t	unicode_char_t
typedef std::map< std::string::size_type, std::u16string::size_type >	utf16_to_utf8_character_map
typedef std::vector< string_span >	string_spans
template<typename T , size_t N = 64, typename Alloc = std::allocator<T>>
using	tree = segmented_tree< T, N, Alloc >
using	none_t = std::monostate
template<typename AbstractT , typename... Type>
using	from_abstract_t = typename from_abstract_next< AbstractT, Type... >::result_type
typedef basic_json< json_syntax::Standard >	json
typedef json::json_value	json_value
typedef json::json_object	json_object
typedef json::json_array	json_array
typedef json::json_double	json_double
typedef json::json_int64	json_int64
typedef json::json_uint64	json_uint64
typedef json::json_int	json_int
typedef json::json_uint	json_uint
typedef json::json_string	json_string
typedef json::json_bool	json_bool
typedef json::json_null	json_null
typedef json::json_keyword	json_keyword
typedef basic_json< json_syntax::Standard, neolib::fast_pool_allocator< json_type > >	fast_json
typedef fast_json::json_value	fast_json_value
typedef fast_json::json_object	fast_json_object
typedef fast_json::json_array	fast_json_array
typedef fast_json::json_double	fast_json_double
typedef fast_json::json_int64	fast_json_int64
typedef fast_json::json_uint64	fast_json_uint64
typedef fast_json::json_int	fast_json_int
typedef fast_json::json_uint	fast_json_uint
typedef fast_json::json_string	fast_json_string
typedef fast_json::json_bool	fast_json_bool
typedef fast_json::json_null	fast_json_null
typedef fast_json::json_keyword	fast_json_keyword
typedef basic_json< json_syntax::Relaxed >	rjson
typedef rjson::json_value	rjson_value
typedef rjson::json_object	rjson_object
typedef rjson::json_array	rjson_array
typedef rjson::json_double	rjson_double
typedef rjson::json_int64	rjson_int64
typedef rjson::json_uint64	rjson_uint64
typedef rjson::json_int	rjson_int
typedef rjson::json_uint	rjson_uint
typedef rjson::json_string	rjson_string
typedef rjson::json_bool	rjson_bool
typedef rjson::json_null	rjson_null
typedef rjson::json_keyword	rjson_keyword
typedef basic_json< json_syntax::Relaxed, neolib::fast_pool_allocator< json_type > >	fast_rjson
typedef fast_rjson::json_value	fast_rjson_value
typedef fast_rjson::json_object	fast_rjson_object
typedef fast_rjson::json_array	fast_rjson_array
typedef fast_rjson::json_double	fast_rjson_double
typedef fast_rjson::json_int64	fast_rjson_int64
typedef fast_rjson::json_uint64	fast_rjson_uint64
typedef fast_rjson::json_int	fast_rjson_int
typedef fast_rjson::json_uint	fast_rjson_uint
typedef fast_rjson::json_string	fast_rjson_string
typedef fast_rjson::json_bool	fast_rjson_bool
typedef fast_rjson::json_null	fast_rjson_null
typedef fast_rjson::json_keyword	fast_rjson_keyword
typedef basic_json< json_syntax::Functional >	fjson
typedef fjson::json_value	fjson_value
typedef fjson::json_object	fjson_object
typedef fjson::json_array	fjson_array
typedef fjson::json_double	fjson_double
typedef fjson::json_int64	fjson_int64
typedef fjson::json_uint64	fjson_uint64
typedef fjson::json_int	fjson_int
typedef fjson::json_uint	fjson_uint
typedef fjson::json_string	fjson_string
typedef fjson::json_bool	fjson_bool
typedef fjson::json_null	fjson_null
typedef fjson::json_keyword	fjson_keyword
typedef basic_json< json_syntax::Functional, neolib::fast_pool_allocator< json_type > >	fast_fjson
typedef fast_fjson::json_value	fast_fjson_value
typedef fast_fjson::json_object	fast_fjson_object
typedef fast_fjson::json_array	fast_fjson_array
typedef fast_fjson::json_double	fast_fjson_double
typedef fast_fjson::json_int64	fast_fjson_int64
typedef fast_fjson::json_uint64	fast_fjson_uint64
typedef fast_fjson::json_int	fast_fjson_int
typedef fast_fjson::json_uint	fast_fjson_uint
typedef fast_fjson::json_string	fast_fjson_string
typedef fast_fjson::json_bool	fast_fjson_bool
typedef fast_fjson::json_null	fast_fjson_null
typedef fast_fjson::json_keyword	fast_fjson_keyword
typedef basic_xml< char, pool_allocator< char > >	xml
typedef basic_xml< wchar_t, pool_allocator< char > >	wxml
typedef basic_binary_data_packet< char >	binary_data_packet
typedef basic_binary_packet< char >	binary_packet
typedef basic_data_packet< char >	data_packet
typedef packet_stream< http_packet, tcp_protocol >	http_stream
typedef i_basic_packet< char >	i_packet
typedef boost::asio::ip::tcp	tcp_protocol
typedef boost::asio::ip::udp	udp_protocol
typedef i_basic_packet_connection_owner< char >	packet_connection_owner
typedef packet_stream< binary_packet, tcp_protocol >	tcp_binary_packet_stream
typedef packet_stream< string_packet, tcp_protocol >	tcp_string_packet_stream
typedef basic_resolver< tcp_protocol >	tcp_resolver
typedef basic_resolver< udp_protocol >	udp_resolver
typedef basic_string_packet< char >	string_packet
typedef tcp_packet_stream_server< string_packet >	tcp_string_packet_stream_server
template<typename T >
using	to_const_reference_t = const std::remove_reference_t< T > &
template<typename T >
using	abstract_t = typename detail::abstract_type< T >::type
template<typename T >
using	abstract_return_t = typename detail::abstract_return_type< T >::type
template<typename T >
using	cache = std::optional< T >
typedef plugin_variant< simple_variant_type, bool, int64_t, double, string, ref_ptr< i_enum >, ref_ptr< i_custom_type > >	simple_variant
typedef std::variant< wait_result_event, wait_result_message, wait_result_waitable >	wait_result

Enumerations
enum class	power_mode { Green , Normal , Turbo }
enum class	setting_type : uint32_t {   Boolean , Int8 , Int16 , Int32 ,   Int64 , Uint8 , Uint16 , Uint32 ,   Uint64 , Float32 , Float64 , String ,   Enum , Custom }
enum class	lifetime_state { Creating , Alive , Destroying , Destroyed }
enum class	simple_variant_type : uint32_t {   Boolean , Integer , Real , String ,   Enum , CustomType }
enum class	json_syntax { Standard , StandardNoKeywords , Relaxed , Functional }
enum class	json_encoding {   Utf8 , Utf16LE , Utf16BE , Utf32LE ,   Utf32BE }
enum class	json_type {   Unknown , Object , Array , Double ,   Int64 , Uint64 , Int , Uint ,   String , Bool , Null , Keyword }
enum class	lexer_atom_function { Eat , Keep , Not , End }
enum	protocol_family { IPv4 = 0x01 , IPv6 = 0x02 , IPv4orIPv6 = IPv4 | IPv6 }
enum class	async_task_state { Init , Running , Halted , Finished }
enum class	trigger_type { Synchronous , SynchronousDontQueue , Asynchronous , AsynchronousDontQueue }
enum class	trigger_result { Unknown , Unaccepted , Accepted }
enum class	yield_type { NoYield , Yield , Sleep }
enum class	thread_state {   ReadyToStart , Starting , Started , Finished ,   Aborted , Cancelled , Error }

Functions
std::string	settings_folder (const std::string &aApplicationName, const std::string &aCompanyName)
template<typename Object >
bool	is_alive (Object &aObject)
template<typename Object , typename Handler >
auto	destroying (Object &aObject, const Handler aHandler)
template<typename Object , typename Handler >
auto	destroyed (Object &aObject, const Handler aHandler)
	define_setting_type (bool) define_setting_type(int8_t) define_setting_type(int16_t) define_setting_type(int32_t) define_setting_type(int64_t) define_setting_type(uint8_t) define_setting_type(uint16_t) define_setting_type(uint32_t) define_setting_type(uint64_t) define_setting_type(float) define_setting_type(double) define_setting_type(string) template< typename T > struct setting_type_name< T
std::ostream &	operator<< (std::ostream &aStream, const i_version &aVersion)
std::string	to_string (const i_version &aVersion)
NEOLIB_EXPORT std::string	os_name ()
NEOLIB_EXPORT application_info	get_application_info (i_application_info const &aAppInfo)
template<typename Elem , typename Traits >
std::basic_ostream< Elem, Traits > &	operator<< (std::basic_ostream< Elem, Traits > &aStream, const version &aVersion)
template<typename T , typename U , std::size_t SmallBufferSize>
bool	operator== (const basic_small_buffer_allocator< T, SmallBufferSize > &, const basic_small_buffer_allocator< U, SmallBufferSize > &)
template<typename T , typename U , std::size_t SmallBufferSize>
bool	operator!= (const basic_small_buffer_allocator< T, SmallBufferSize > &, const basic_small_buffer_allocator< U, SmallBufferSize > &)
void	swap (any &aLhs, any &aRhs)
template<class T >
T	any_cast (const any &operand)
template<class T >
T	any_cast (any &operand)
template<class T >
T	any_cast (any &&operand)
template<class T >
const T *	any_cast (const any *operand) noexcept
template<class T >
T *	any_cast (any *operand) noexcept
template<class T >
T	unsafe_any_cast (const any &operand) noexcept
template<class T >
T	unsafe_any_cast (any &operand) noexcept
template<typename Source , typename Target >
any_const_iterator	any_const_iterator_cast (any_iterator aSource)
NEOLIB_EXPORT uint32_t	crc32 (const uint8_t *aData, uint32_t aDataLength)
template<typename T >
custom_type< T >	make_custom_type ()
template<typename T >
custom_type< T >	make_custom_type (const abstract_t< T > &aValue)
template<typename T >
T	fast_hash (const void *aInput, std::size_t aLength)
uint32_t	fast_hash (const void *aInput, std::size_t aLength)
template<typename Iterator >
specialized_generic_iterator< Iterator >	make_generic_iterator (Iterator aIterator)
template<class T >
T	any_cast (const i_any &operand)
template<class T >
T	any_cast (i_any &operand)
template<class T >
T	any_cast (i_any &&operand)
template<class T >
const T *	any_cast (const i_any *operand) noexcept
template<class T >
T *	any_cast (i_any *operand) noexcept
template<class T >
T	unsafe_any_cast (const i_any &operand) noexcept
template<class T >
T	unsafe_any_cast (i_any &operand) noexcept
template<typename T , typename ConstIteratorType , typename IteratorType >
bool	operator== (const i_container< T, ConstIteratorType, IteratorType > &lhs, const i_container< T, ConstIteratorType, IteratorType > &rhs)
template<typename T , typename ConstIteratorType , typename IteratorType >
std::partial_ordering	operator<=> (const i_container< T, ConstIteratorType, IteratorType > &lhs, const i_container< T, ConstIteratorType, IteratorType > &rhs)
bool	operator!= (const i_custom_type &lhs, const i_custom_type &rhs)
template<typename Enum >
enum_enumerators_t< Enum > const &	enum_enumerators ()
template<typename Enum >
std::string	enum_to_hex (Enum aEnumValue)
template<typename Enum , typename StringT = string>
StringT	enum_to_string (Enum aEnumerator, bool aMustEnumerate=false)
template<typename Enum >
Enum	string_to_enum (const i_string &aEnumerator)
template<typename Enum >
Enum	string_to_enum (const std::string &aEnumerator)
template<typename Enum >
std::optional< Enum >	try_string_to_enum (const i_string &aEnumerator)
template<typename Enum >
std::optional< Enum >	try_string_to_enum (const std::string &aEnumerator)
template<typename Enum , typename Char , typename Traits , typename = std::enable_if_t<std::is_enum_v<Enum>, sfinae>>
std::basic_istream< Char, Traits > &	operator>> (std::basic_istream< Char, Traits > &aInput, Enum &aEnum)
template<typename Enum , typename Char , typename Traits , typename = std::enable_if_t<std::is_enum_v<Enum>, sfinae>>
std::basic_ostream< Char, Traits > &	operator<< (std::basic_ostream< Char, Traits > &aOutput, const Enum &aEnum)
template<typename Enum , typename StringT = string>
StringT	enum_to_string (const i_enum_t< Enum > &aEnumerator, bool aMustEnumerate=false)
template<typename Enum >
std::enable_if_t< std::is_enum_v< Enum >, bool >	operator== (const i_basic_enum< std::underlying_type_t< Enum > > &lhs, Enum rhs)
template<typename Enum >
std::enable_if_t< std::is_enum_v< Enum >, bool >	operator== (Enum lhs, const i_basic_enum< std::underlying_type_t< Enum > > &rhs)
template<typename Enum >
std::enable_if_t< std::is_enum_v< Enum >, bool >	operator!= (const i_basic_enum< std::underlying_type_t< Enum > > &lhs, Enum rhs)
template<typename Enum >
std::enable_if_t< std::is_enum_v< Enum >, bool >	operator!= (Enum lhs, const i_basic_enum< std::underlying_type_t< Enum > > &rhs)
template<typename Enum >
std::enable_if_t< std::is_enum_v< Enum >, bool >	operator< (const i_basic_enum< std::underlying_type_t< Enum > > &lhs, Enum rhs)
template<typename Enum >
std::enable_if_t< std::is_enum_v< Enum >, bool >	operator< (Enum lhs, const i_basic_enum< std::underlying_type_t< Enum > > &rhs)
template<typename T , typename U , typename = std::enable_if_t<!is_optional_v<U>, sfinae>>
bool	operator== (const i_optional< T > &lhs, const U &rhs)
template<typename T , typename U , typename = std::enable_if_t<!is_optional_v<U>, sfinae>>
bool	operator== (const U &lhs, const i_optional< T > &rhs)
template<typename T , typename U , typename = std::enable_if_t<!is_optional_v<U>, sfinae>>
std::partial_ordering	operator<=> (const i_optional< T > &lhs, const U &rhs)
template<typename T , typename U , typename = std::enable_if_t<!is_optional_v<U>, sfinae>>
std::partial_ordering	operator<=> (const U &lhs, const i_optional< T > &rhs)
template<typename Interface1 , typename Interface2 >
bool	operator== (const i_ref_ptr< Interface1 > &lhs, const Interface2 *rhs) noexcept
template<typename Interface1 , typename Interface2 >
bool	operator== (const Interface2 *lhs, const i_ref_ptr< Interface1 > &rhs) noexcept
template<typename Interface1 , typename Interface2 >
bool	operator!= (const i_ref_ptr< Interface1 > &lhs, const Interface2 *rhs) noexcept
template<typename Interface1 , typename Interface2 >
bool	operator!= (const Interface2 *lhs, const i_ref_ptr< Interface1 > &rhs) noexcept
template<typename Interface1 , typename Interface2 >
bool	operator< (const i_ref_ptr< Interface1 > &lhs, const Interface2 *rhs) noexcept
template<typename Interface1 , typename Interface2 >
bool	operator< (const Interface2 *lhs, const i_ref_ptr< Interface1 > &rhs) noexcept
bool	operator== (const i_string &lhs, const i_string &rhs) noexcept
std::strong_ordering	operator<=> (const i_string &lhs, const i_string &rhs) noexcept
i_string &	operator+= (i_string &lhs, const i_string &rhs)
std::ostream &	operator<< (std::ostream &aStream, const i_string &aString)
std::istream &	operator>> (std::istream &aStream, i_string &aString)
template<typename RandomIt , typename Swapper , typename Compare >
void	intrusive_sort (RandomIt first, RandomIt last, Swapper swapper, Compare comp)
template<typename RandomIt , typename Swapper >
void	intrusive_sort (RandomIt first, RandomIt last, Swapper swapper)
template<typename InIter , typename OutIter >
OutIter	uninitialized_copy (InIter first, InIter last, OutIter result)
template<typename T >
bool	operator== (const optional< T > &lhs, const abstract_t< optional< T > > &rhs)
template<typename T >
bool	operator== (const abstract_t< optional< T > > &lhs, const optional< T > &rhs)
template<typename T >
std::partial_ordering	operator<=> (const optional< T > &lhs, const abstract_t< optional< T > > &rhs)
template<typename T >
std::partial_ordering	operator<=> (const abstract_t< optional< T > > &lhs, const optional< T > &rhs)
template<typename T , typename U , typename = std::enable_if_t<!is_optional_v<U>, sfinae>>
bool	operator== (const optional< T > &lhs, const U &rhs)
template<typename T , typename U , typename = std::enable_if_t<!is_optional_v<U>, sfinae>>
bool	operator== (const U &lhs, const optional< T > &rhs)
template<typename T , typename U , typename = std::enable_if_t<!is_optional_v<U>, sfinae>>
std::partial_ordering	operator<=> (const optional< T > &lhs, const U &rhs)
template<typename T , typename U , typename = std::enable_if_t<!is_optional_v<U>, sfinae>>
std::partial_ordering	operator<=> (const U &lhs, const optional< T > &rhs)
template<typename T , std::enable_if_t<!std::is_same_v< T, abstract_t< T > >, int > = 0>
std::partial_ordering	operator<=> (const optional< T > &lhs, const abstract_t< T > &rhs)
template<typename T , std::enable_if_t<!std::is_same_v< T, abstract_t< T > >, int > = 0>
std::partial_ordering	operator<=> (const abstract_t< T > &lhs, const optional< T > &rhs)
template<typename Elem , typename Traits , typename T >
std::basic_ostream< Elem, Traits > &	operator<< (std::basic_ostream< Elem, Traits > &aStream, optional< T > const &aOptional)
template<typename Elem , typename Traits , typename T >
std::basic_istream< Elem, Traits > &	operator>> (std::basic_istream< Elem, Traits > &aStream, optional< T > &aOptional)
template<typename T1 , typename T2 >
pair< std::decay_t< T1 >, std::decay_t< T2 > >	make_pair (T1 &&aFirst, T2 &&aSecond)
template<class charT , class Traits , class Alloc >
basic_quick_string< charT, Traits, Alloc >	operator+ (const basic_quick_string< charT, Traits, Alloc > &_Left, const basic_quick_string< charT, Traits, Alloc > &_Right)
template<class charT , class Traits , class Alloc >
std::basic_string< charT, Traits, Alloc >	operator+ (const std::basic_string< charT, Traits, Alloc > &_Left, const basic_quick_string< charT, Traits, Alloc > &_Right)
template<class charT , class Traits , class Alloc >
std::basic_string< charT, Traits, Alloc >	operator+ (const charT *_Left, const basic_quick_string< charT, Traits, Alloc > &_Right)
template<class charT , class Traits , class Alloc >
std::basic_string< charT, Traits, Alloc >	operator+ (const charT _Left, const basic_quick_string< charT, Traits, Alloc > &_Right)
template<class charT , class Traits , class Alloc >
std::basic_string< charT, Traits, Alloc >	operator+ (const basic_quick_string< charT, Traits, Alloc > &_Left, const std::basic_string< charT, Traits, Alloc > &_Right)
template<class charT , class Traits , class Alloc >
std::basic_string< charT, Traits, Alloc >	operator+ (const basic_quick_string< charT, Traits, Alloc > &_Left, const charT *_Right)
template<class charT , class Traits , class Alloc >
std::basic_string< charT, Traits, Alloc >	operator+ (const basic_quick_string< charT, Traits, Alloc > &_Left, const charT _Right)
template<typename Elem , typename Traits , typename Alloc >
std::basic_ostream< Elem, Traits > &	operator<< (std::basic_ostream< Elem, Traits > &aStream, const basic_quick_string< Elem, Traits, Alloc > &aString)
template<typename charT , typename Traits , typename Alloc >
std::size_t	hash_value (const neolib::basic_quick_string< charT, Traits, Alloc > &sv)
template<typename Interface >
bool	operator< (ref_ptr< Interface > const &lhs, ref_ptr< Interface > const &rhs) noexcept
template<typename ConcreteType , typename... Args>
ref_ptr< ConcreteType >	make_ref (Args &&... args)
template<class T , class U >
ref_ptr< T >	static_pointer_cast (ref_ptr< U > const &aOther) noexcept
template<class T , class U >
ref_ptr< T >	static_pointer_cast (ref_ptr< U > &&aOther) noexcept
template<class T , class U >
ref_ptr< T >	const_pointer_cast (ref_ptr< U > const &aOther) noexcept
template<class T , class U >
ref_ptr< T >	const_pointer_cast (ref_ptr< U > &&aOther) noexcept
template<class T , class U >
ref_ptr< T >	reinterpret_pointer_cast (ref_ptr< U > const &aOther) noexcept
template<class T , class U >
ref_ptr< T >	reinterpret_pointer_cast (ref_ptr< U > &&aOther) noexcept
template<class T , class U >
ref_ptr< T >	dynamic_pointer_cast (ref_ptr< U > const &aOther) noexcept
template<class T , class U >
ref_ptr< T >	dynamic_pointer_cast (ref_ptr< U > &&aOther) noexcept
template<class T , class U >
ref_ptr< T >	static_pointer_cast (i_ref_ptr< U > const &aOther) noexcept
template<class T , class U >
ref_ptr< T >	static_pointer_cast (i_ref_ptr< U > &&aOther) noexcept
template<class T , class U >
ref_ptr< T >	const_pointer_cast (i_ref_ptr< U > const &aOther) noexcept
template<class T , class U >
ref_ptr< T >	const_pointer_cast (i_ref_ptr< U > &&aOther) noexcept
template<class T , class U >
ref_ptr< T >	reinterpret_pointer_cast (i_ref_ptr< U > const &aOther) noexcept
template<class T , class U >
ref_ptr< T >	reinterpret_pointer_cast (i_ref_ptr< U > &&aOther) noexcept
template<class T , class U >
ref_ptr< T >	dynamic_pointer_cast (i_ref_ptr< U > const &aOther) noexcept
template<class T , class U >
ref_ptr< T >	dynamic_pointer_cast (i_ref_ptr< U > &&aOther) noexcept
template<typename T , std::size_t SegmentSize, typename Alloc >
bool	operator== (segmented_array< T, SegmentSize, Alloc > const &lhs, segmented_array< T, SegmentSize, Alloc > const &rhs)
template<typename T , std::size_t SegmentSize, typename Alloc >
bool	operator!= (segmented_array< T, SegmentSize, Alloc > const &lhs, segmented_array< T, SegmentSize, Alloc > const &rhs)
double	fake_simd_fma_4d (double x1, double x2, double y1, double y2, double z1, double z2, double w1, double w2)
void	fake_simd_mul_4d (double x1, double x2, double y1, double y2, double z1, double z2, double w1, double w2, double &a, double &b, double &c, double &d)
void	fake_simd_srand (uint32_t seed)
void	simd_srand (std::thread::id seed)
uint32_t	fake_simd_rand ()
template<typename T >
T	simd_rand (T aUpper)
bool	operator== (const string &lhs, const string &rhs) noexcept
std::strong_ordering	operator<=> (const string &lhs, const string &rhs) noexcept
bool	operator== (const string &lhs, const i_string &rhs) noexcept
std::strong_ordering	operator<=> (const string &lhs, const i_string &rhs) noexcept
bool	operator== (const i_string &lhs, const string &rhs) noexcept
std::strong_ordering	operator<=> (const i_string &lhs, const string &rhs) noexcept
string	operator+ (const string &lhs, const string &rhs)
string &	operator+= (string &lhs, const i_string &rhs)
ci_string	make_ci_string (const std::string &s)
ci_u16string	make_ci_string (const std::u16string &s)
std::string	make_string (const ci_string &s)
std::u16string	make_string (const ci_u16string &s)
bool	operator== (const ci_string &s1, const std::string &s2)
bool	operator== (const std::string &s1, const ci_string &s2)
bool	operator!= (const ci_string &s1, const std::string &s2)
bool	operator!= (const std::string &s1, const ci_string &s2)
bool	operator< (const ci_string &s1, const std::string &s2)
bool	operator< (const std::string &s1, const ci_string &s2)
template<typename CharT , typename Traits , typename Alloc >
bool	lexicographical_compare_ignoring_case (const std::basic_string< CharT, Traits, Alloc > &s1, const std::basic_string< CharT, Traits, Alloc > &s2)
template<typename CharT , typename Traits >
int32_t	string_to_int32 (const std::basic_string_view< CharT, Traits > &aStringView)
template<typename CharT , typename Traits , typename Alloc >
int32_t	string_to_int32 (const std::basic_string< CharT, Traits, Alloc > &aString, int aBase=10)
template<typename CharT , typename Traits >
int64_t	string_to_int64 (const std::basic_string_view< CharT, Traits > &aStringView)
template<typename CharT , typename Traits , typename Alloc >
int64_t	string_to_int64 (const std::basic_string< CharT, Traits, Alloc > &aString, int aBase=10)
template<typename CharT , typename Traits >
uint32_t	string_to_uint32 (const std::basic_string_view< CharT, Traits > &aStringView)
template<typename CharT , typename Traits , typename Alloc >
uint32_t	string_to_uint32 (const std::basic_string< CharT, Traits, Alloc > &aString, int aBase=10)
template<typename CharT , typename Traits >
uint64_t	string_to_uint64 (const std::basic_string_view< CharT, Traits > &aStringView)
template<typename CharT , typename Traits , typename Alloc >
uint64_t	string_to_uint64 (const std::basic_string< CharT, Traits, Alloc > &aString, int aBase=10)
template<typename CharT , typename Traits >
number_t	string_to_number (const std::basic_string_view< CharT, Traits > &aStringView)
template<typename CharT , typename Traits >
double	string_to_double (const std::basic_string_view< CharT, Traits > &aStringView)
template<typename CharT , typename Traits , typename Alloc >
double	string_to_double (const std::basic_string< CharT, Traits, Alloc > &aString)
template<typename CharT , typename Traits = std::char_traits<CharT>, typename Alloc = std::allocator<CharT>>
std::basic_string< CharT, Traits, Alloc >	int32_to_string (int32_t aint32, int aBase=10, std::size_t aWidth=0, CharT aFill='0')
template<typename CharT , typename Traits = std::char_traits<CharT>, typename Alloc = std::allocator<CharT>>
std::basic_string< CharT, Traits, Alloc >	int64_to_string (int64_t aint32, int aBase=10, std::size_t aWidth=0, CharT aFill='0')
template<typename CharT , typename Traits = std::char_traits<CharT>, typename Alloc = std::allocator<CharT>>
std::basic_string< CharT, Traits, Alloc >	uint32_to_string (uint32_t aint32, int aBase=10, std::size_t aWidth=0, CharT aFill='0')
template<typename CharT , typename Traits = std::char_traits<CharT>, typename Alloc = std::allocator<CharT>>
std::basic_string< CharT, Traits, Alloc >	uint64_to_string (uint64_t aint32, int aBase=10, std::size_t aWidth=0, CharT aFill='0')
template<typename CharT , typename Traits = std::char_traits<CharT>, typename Alloc = std::allocator<CharT>>
std::basic_string< CharT, Traits, Alloc >	double_to_string (double aDouble, std::size_t aPrecision=0, bool aFixed=true, std::size_t aWidth=0, CharT aFill='0')
std::size_t	append_utf8 (std::string &aString, unicode_char_t aCharacter)
template<bool AllowUpper128, typename CharacterMapUpdater >
std::string	utf16_to_utf8 (const std::u16string &aString, CharacterMapUpdater aCharacterMapUpdater)
template<bool AllowUpper128>
std::string	utf16_to_utf8 (const std::u16string &aString)
template<bool AllowUpper128>
std::string	utf16_to_utf8 (const std::u16string &aString, utf16_to_utf8_character_map &aCharMap)
std::string	utf16_to_utf8 (const std::u16string &aString)
std::string	utf16_to_utf8 (const std::u16string &aString, utf16_to_utf8_character_map &aCharMap)
template<typename Callback >
std::u16string	utf8_to_utf16 (const std::string &aString, Callback aCallback, bool aCodePageFallback=false)
std::u16string	utf8_to_utf16 (const std::string &aString, bool aCodePageFallback=false)
template<typename Callback >
std::u32string	utf8_to_utf32 (std::string_view const &aStringView, Callback aCallback, bool aCodePageFallback=false)
template<typename Callback >
std::u32string	utf8_to_utf32 (std::string::const_iterator aBegin, std::string::const_iterator aEnd, Callback aCallback, bool aCodePageFallback=false)
template<typename Callback >
std::u32string	utf8_to_utf32 (const std::string &aString, Callback aCallback, bool aCodePageFallback=false)
std::u32string	utf8_to_utf32 (std::string::const_iterator aBegin, std::string::const_iterator aEnd, bool aCodePageFallback=false)
std::u32string	utf8_to_utf32 (const std::string &aString, bool aCodePageFallback=false)
std::u32string	utf8_to_utf32 (const std::string_view &aStringView, bool aCodePageFallback=false)
std::string	utf32_to_utf8 (const std::u32string &aString)
bool	is_utf8_trailing (char aCharacter)
template<typename CharT , typename Traits >
bool	check_utf8 (const std::basic_string_view< CharT, Traits > &aString)
template<typename CharT , typename Traits , typename Alloc >
bool	check_utf8 (const std::basic_string< CharT, Traits, Alloc > &aString)
bool	check_utf8 (const i_string &aString)
template<typename StringT >
StringT	utf16_to_any (const std::u16string &aString)
template<>
std::u16string	utf16_to_any< std::u16string > (const std::u16string &aString)
template<typename StringT >
StringT	utf8_to_any (const std::string &aString, bool aCodePageFallback=false)
template<>
std::string	utf8_to_any< std::string > (const std::string &aString, bool)
std::u16string	any_to_utf16 (const std::string &aString, bool aCodePageFallback=false)
const std::string &	any_to_utf8 (const std::string &aString)
std::string	any_to_utf8 (const std::u16string &aString)
const std::u16string &	any_to_utf16 (const std::u16string &aString)
any_to_utf16_result< std::string >	any_to_utf16 (const std::string::value_type *aString, std::string::size_type aStringLength)
any_to_utf16_result< std::u16string >	any_to_utf16 (const std::u16string::value_type *aString, std::u16string::size_type aStringLength)
template<typename CharT , typename Traits , typename Alloc >
std::string	utf16_to_narrow (const std::basic_string< CharT, Traits, Alloc > &aWideString)
template<typename CharT , typename Traits , typename Alloc >
std::u16string	narrow_to_utf16 (const std::basic_string< CharT, Traits, Alloc > &aNarrowString)
template<typename T >
std::string	to_std_string (T const &aValue)
template<typename T >
T	from_std_string (std::string const &aValueAsString)
template<typename T >
string	to_string (T const &aValue)
template<typename T >
T	from_string (i_string const &aValueAsString)
template<typename FwdIter1 , typename FwdIter2 , typename ResultContainer >
FwdIter1	tokens (FwdIter1 aFirst, FwdIter1 aLast, FwdIter2 aDelimeterFirst, FwdIter2 aDelimiterLast, ResultContainer &aTokens, std::size_t aMaxTokens=0, bool aSkipEmptyTokens=true, bool aDelimeterIsSubsequence=false)
template<typename FwdIter , typename CharT , typename Traits , typename Alloc , typename ResultContainer >
void	tokens (FwdIter aFirst, FwdIter aLast, const std::basic_string< CharT, Traits, Alloc > &aDelimeter, ResultContainer &aTokens, std::size_t aMaxTokens=0, bool aSkipEmptyTokens=true, bool aDelimeterIsSubsequence=false)
template<typename CharT , typename Traits , typename Alloc , typename ResultContainer >
void	tokens (const std::basic_string< CharT, Traits, Alloc > &aLine, const std::basic_string< CharT, Traits, Alloc > &aDelimeter, ResultContainer &aTokens, std::size_t aMaxTokens=0, bool aSkipEmptyTokens=true, bool aDelimeterIsSubsequence=false)
template<typename FwdIter , typename CharT , typename Traits , typename Alloc >
std::vector< std::basic_string< CharT, Traits, Alloc > >	tokens (FwdIter aFirst, FwdIter aLast, const std::basic_string< CharT, Traits, Alloc > &aDelimeter, std::size_t aMaxTokens=0, bool aSkipEmptyTokens=true, bool aDelimeterIsSubsequence=false)
template<typename CharT , typename Traits , typename Alloc >
std::vector< std::basic_string< CharT, Traits, Alloc > >	tokens (const std::basic_string< CharT, Traits, Alloc > &aLine, const std::basic_string< CharT, Traits, Alloc > &aDelimeter, std::size_t aMaxTokens=0, bool aSkipEmptyTokens=true, bool aDelimeterIsSubsequence=false)
std::string	to_string (const std::pair< char const *, char const * > &aIterPair)
template<typename CharT , typename Traits , typename Alloc >
std::basic_string< CharT, Traits, Alloc >	to_lower (const std::basic_string< CharT, Traits, Alloc > &aString)
template<typename CharT >
CharT	to_lower (CharT aCharacter)
template<typename CharT , typename Traits , typename Alloc >
std::basic_string< CharT, Traits, Alloc >	to_upper (const std::basic_string< CharT, Traits, Alloc > &aString)
template<typename CharT >
CharT	to_upper (CharT aCharacter)
template<typename CharT , typename Traits , typename Alloc >
bool	replace_string (std::basic_string< CharT, Traits, Alloc > &aString, const std::basic_string< CharT, Traits, Alloc > &aSearch, const std::basic_string< CharT, Traits, Alloc > &aReplace, string_spans *aSpans, const string_span::type *aNewSpanType)
template<typename CharT , typename Traits , typename Alloc >
bool	replace_string (std::basic_string< CharT, Traits, Alloc > &aString, const std::basic_string< CharT, Traits, Alloc > &aSearch, const std::basic_string< CharT, Traits, Alloc > &aReplace)
template<typename CharT , typename Traits , typename Alloc >
bool	replace_string (std::basic_string< CharT, Traits, Alloc > &aString, const std::basic_string< CharT, Traits, Alloc > &aSearch, const std::basic_string< CharT, Traits, Alloc > &aReplace, string_spans *aSpans)
template<typename CharT , typename Traits , typename Alloc >
bool	replace_string (std::basic_string< CharT, Traits, Alloc > &aString, const std::basic_string< CharT, Traits, Alloc > &aSearch, const std::basic_string< CharT, Traits, Alloc > &aReplace, string_spans *aSpans, string_span::type aNewSpanType)
template<typename CharT , typename Traits , typename Alloc >
std::string &	remove_leading (std::basic_string< CharT, Traits, Alloc > &aString, const std::basic_string< CharT, Traits, Alloc > &aLeading)
template<typename CharT , typename Traits , typename Alloc >
std::string &	remove_trailing (std::basic_string< CharT, Traits, Alloc > &aString, const std::basic_string< CharT, Traits, Alloc > &aTrailing)
template<typename CharT , typename Traits , typename Alloc >
std::string &	remove_leading_and_trailing (std::basic_string< CharT, Traits, Alloc > &aString, const std::basic_string< CharT, Traits, Alloc > &aLeadingTrailing)
template<typename CharT >
bool	contains_character (const CharT *aSequence, CharT aCharacter)
template<typename CharT , typename Traits , typename Alloc >
std::basic_string< CharT, Traits, Alloc >::size_type	reverse_find_last_of (const std::basic_string< CharT, Traits, Alloc > &aString, const std::basic_string< CharT, Traits, Alloc > &aSequence, typename std::basic_string< CharT, Traits, Alloc >::size_type aPosition)
template<typename CharT , typename Traits , typename Alloc >
std::basic_string< CharT, Traits, Alloc >::size_type	reverse_find_first_of (const std::basic_string< CharT, Traits, Alloc > &aString, const std::basic_string< CharT, Traits, Alloc > &aSequence, typename std::basic_string< CharT, Traits, Alloc >::size_type aPosition)
std::string	parse_escapes (const std::string &aString)
std::string	parse_url_escapes (const std::string &aString)
template<typename CharT , typename Traits , typename FwdIter >
bool	do_wildcard_match (FwdIter aTextBegin, FwdIter aTextEnd, FwdIter aPatternBegin, FwdIter aPatternEnd)
template<typename CharT , typename FwdIter >
bool	wildcard_match (FwdIter aTextBegin, FwdIter aTextEnd, FwdIter aPatternBegin, FwdIter aPatternEnd)
template<typename CharT , typename Traits , typename Alloc >
bool	wildcard_match (const std::basic_string< CharT, Traits, Alloc > &aText, const std::basic_string< CharT, Traits, Alloc > &aPattern)
template<typename... Args>
format_result	format (std::string_view const &aFormat, Args &&... aArgs)
uuid	make_uuid (const std::string &aHyphenatedHexString)
NEOLIB_EXPORT uuid	generate_uuid ()
std::istream &	operator>> (std::istream &aStream, uuid &aId)
std::ostream &	operator<< (std::ostream &aStream, const uuid &aId)
std::string	uuid_to_string (const uuid &aId)
template<typename... Types>
bool	operator== (none_t const &, variant< Types... > const &rhs) noexcept
template<typename... Types>
bool	operator== (variant< Types... > const &lhs, none_t const &) noexcept
template<typename... Types>
bool	operator!= (none_t const &, variant< Types... > const &rhs) noexcept
template<typename... Types>
bool	operator!= (variant< Types... > const &lhs, none_t const &) noexcept
template<typename... Types>
bool	operator== (variant< Types... > const &lhs, variant< Types... > const &rhs) noexcept
template<typename... Types>
bool	operator!= (variant< Types... > const &lhs, variant< Types... > const &rhs) noexcept
template<typename... Types>
bool	operator< (variant< Types... > const &lhs, variant< Types... > const &rhs) noexcept
template<typename... Types>
bool	operator<= (variant< Types... > const &lhs, variant< Types... > const &rhs) noexcept
template<typename... Types>
bool	operator> (variant< Types... > const &lhs, variant< Types... > const &rhs) noexcept
template<typename... Types>
bool	operator>= (variant< Types... > const &lhs, variant< Types... > const &rhs) noexcept
template<typename... Types>
auto	operator<=> (variant< Types... > const &lhs, variant< Types... > const &rhs) noexcept
template<typename T , typename Variant >
auto &	static_variant_cast (const Variant &var)
template<typename T , typename Variant >
auto &	static_variant_cast (Variant &var)
template<typename T , typename Variant >
T	static_numeric_variant_cast (const Variant &var)
template<typename T , typename Variant >
T	static_numeric_variant_cast (Variant &var)
template<typename T , typename Variant , std::size_t index = 0>
constexpr std::size_t	variant_index_of ()
std::string	win32_get_last_error_as_string ()
template<typename... Iterators>
zip_iterator< Iterators... >	make_zip_iterator (Iterators &&... iterators)
NEOLIB_EXPORT std::string	tidy_path (std::string aPath)
NEOLIB_EXPORT std::wstring	tidy_path (std::wstring aPath)
NEOLIB_EXPORT std::string	convert_path (const std::wstring &aString)
NEOLIB_EXPORT std::wstring	convert_path (const std::string &aString)
NEOLIB_EXPORT const std::string &	create_path (const std::string &aPath)
NEOLIB_EXPORT const std::wstring &	create_path (const std::wstring &aPath)
NEOLIB_EXPORT std::string	create_file (const std::string &aFileName)
NEOLIB_EXPORT void	create_file (const std::wstring &aFileName)
NEOLIB_EXPORT bool	file_exists (const std::string &aPath)
NEOLIB_EXPORT bool	file_exists (const std::wstring &aPath)
NEOLIB_EXPORT std::time_t	file_date (const std::string &aPath)
NEOLIB_EXPORT std::time_t	file_date (const std::wstring &aPath)
NEOLIB_EXPORT std::string	file_ext (const std::string &aPath)
NEOLIB_EXPORT std::wstring	file_ext (const std::wstring &aPath)
NEOLIB_EXPORT bool	can_read_file (const std::string &aPath)
NEOLIB_EXPORT bool	can_read_file (const std::wstring &aPath)
NEOLIB_EXPORT unsigned long	file_size (const std::string &aPath)
NEOLIB_EXPORT unsigned long	file_size (const std::wstring &aPath)
NEOLIB_EXPORT unsigned long long	large_file_size (const std::string &aPath)
NEOLIB_EXPORT unsigned long long	large_file_size (const std::wstring &aPath)
NEOLIB_EXPORT int	large_file_seek (FILE *aStream, long long aOffset, int aOrigin)
NEOLIB_EXPORT bool	move_file (const std::string &aPathFrom, const std::string &aPathTo)
NEOLIB_EXPORT std::string	program_file ()
NEOLIB_EXPORT std::string	program_directory ()
NEOLIB_EXPORT std::string	user_documents_directory ()
NEOLIB_EXPORT std::string	user_settings_directory ()
template<class Elem , class Traits >
void	hex_dump (const void *aData, std::size_t aLength, std::basic_ostream< Elem, Traits > &aStream, std::size_t aWidth=16)
std::string	to_string (json_type aType)
template<json_syntax Syntax>
constexpr const char *	document_type ()
bool	operator== (const lexer_atom_match_any &, const lexer_atom_match_any &)
std::size_t	hash_value (const lexer_atom_match_any &)
template<typename T , typename Token , typename Scope , typename CharT >
bool	holds_alternative (const lexer_atom< Token, Scope, CharT > &aAtom)
template<typename CharType , size_t ReceiveBufferSize>
const basic_packet_connection< CharType, tcp_protocol, ReceiveBufferSize >::socket_type &	do_socket (const basic_packet_connection< CharType, tcp_protocol, ReceiveBufferSize > &aConnection)
template<typename CharType , size_t ReceiveBufferSize>
basic_packet_connection< CharType, tcp_protocol, ReceiveBufferSize >::socket_type &	do_socket (basic_packet_connection< CharType, tcp_protocol, ReceiveBufferSize > &aConnection)
template<typename CharType , size_t ReceiveBufferSize>
const basic_packet_connection< CharType, udp_protocol, ReceiveBufferSize >::socket_type &	do_socket (const basic_packet_connection< CharType, udp_protocol, ReceiveBufferSize > &aConnection)
template<typename CharType , size_t ReceiveBufferSize>
basic_packet_connection< CharType, udp_protocol, ReceiveBufferSize >::socket_type &	do_socket (basic_packet_connection< CharType, udp_protocol, ReceiveBufferSize > &aConnection)
template<typename Protocol >
protocol_family	to_protocol_family (Protocol aProtocol)
template<typename Protocol >
Protocol	to_protocol (protocol_family aProtocolFamily)
template<typename Elem , typename Traits >
std::basic_ostream< Elem, Traits > &	operator<< (std::basic_ostream< Elem, Traits > &aStream, const uri_authority &aUriAuthority)
template<typename Elem , typename Traits >
std::basic_ostream< Elem, Traits > &	operator<< (std::basic_ostream< Elem, Traits > &aStream, const uri &aUri)
template<typename T >
to_const_reference_t< T >	to_const (T &&object)
template<typename T , typename = std::enable_if_t<detail::abstract_type<T>::value, sfinae>>
const abstract_t< T > &	to_abstract (const T &aArgument)
template<typename T , typename = std::enable_if_t<detail::abstract_type<T>::value, sfinae>>
abstract_t< T > &	to_abstract (T &aArgument)
template<typename T1 , typename T2 >
const abstract_t< pair< T1, T2 > > &	to_abstract (const std::pair< T1, pair< T1, T2 > > &aArgument)
template<typename T1 , typename T2 >
abstract_t< neolib::pair< T1, T2 > > &	to_abstract (std::pair< T1, pair< T1, T2 > > &aArgument)
template<typename T >
void	clear_cache (cache< T > &aCachedVariable)
template<typename T , typename Id , typename... Types>
T	get_as (const i_plugin_variant< Id, Types... > &aVariant)
simple_variant	from_string (std::string const &aString, simple_variant_type aType)
std::string	to_string (simple_variant const &aVariant)
switchable_mutex &	event_mutex ()
bool	event_consumed (trigger_result aTriggerResult)
template<typename Container >
void	parallel_apply (thread_pool &aThreadPool, Container &aContainer, std::function< void(typename Container::value_type &aElement)> aFunction, std::size_t aMinimumParallelismCount=0)

Variables
template<typename T , typename = sfinae>
constexpr setting_type	setting_type_v = setting_type::Custom
template<>
constexpr setting_type	setting_type_v< bool > = setting_type::Boolean
template<>
constexpr setting_type	setting_type_v< int8_t > = setting_type::Int8
template<>
constexpr setting_type	setting_type_v< int16_t > = setting_type::Int16
template<>
constexpr setting_type	setting_type_v< int32_t > = setting_type::Int32
template<>
constexpr setting_type	setting_type_v< int64_t > = setting_type::Int64
template<>
constexpr setting_type	setting_type_v< uint8_t > = setting_type::Uint8
template<>
constexpr setting_type	setting_type_v< uint16_t > = setting_type::Uint16
template<>
constexpr setting_type	setting_type_v< uint32_t > = setting_type::Uint32
template<>
constexpr setting_type	setting_type_v< uint64_t > = setting_type::Uint64
template<>
constexpr setting_type	setting_type_v< float > = setting_type::Float32
template<>
constexpr setting_type	setting_type_v< double > = setting_type::Float64
template<>
constexpr setting_type	setting_type_v< string > = setting_type::String
template<typename T >
const string	setting_type_name_v = setting_type_name<T>::name()
template<typename T >
constexpr bool	is_variant_v = is_variant<T>::value
template<typename T >
const std::string	custom_type_name_v = T::type_name
template<class CookieType >
constexpr CookieType	invalid_cookie = static_cast<CookieType>(~CookieType{})
template<typename T >
constexpr bool	is_optional_v = is_optional<T>::value
const char	INVALID_CHAR8 = '?'
const unicode_char_t	INVALID_CHAR32 = static_cast<unicode_char_t>(0xFFFD)
const none_t	none
template<typename AbstractT , typename Type >
constexpr bool	is_variant_convertible_v = std::is_base_of_v<AbstractT, Type> && std::is_abstract_v<AbstractT>
template<typename T >
bool constexpr	vecarray_trivial_v = std::is_trivial_v<T>
template<typename T , typename... Ts>
constexpr std::size_t	index_of_v = variadic_index<T, Ts...>::value
constexpr auto	invalid = std::nullopt

Typedef Documentation

abstract_interface_t

template<typename ConcreteType >

using neolib::abstract_interface_t = typedef typename abstract_interface<ConcreteType>::type

Definition at line 52 of file fwd_abstract.hpp.

abstract_return_t

template<typename T >

using neolib::abstract_return_t = typedef typename detail::abstract_return_type<T>::type

Definition at line 213 of file neolib.hpp.

abstract_t

template<typename T >

using neolib::abstract_t = typedef typename detail::abstract_type<T>::type

Definition at line 178 of file neolib.hpp.

as_setting_t

template<typename T >

using neolib::as_setting_t = typedef typename as_setting<T>::type

Definition at line 61 of file i_settings.hpp.

binary_data_packet

typedef basic_binary_data_packet<char> neolib::binary_data_packet

Definition at line 113 of file binary_data_packet.hpp.

binary_packet

typedef basic_binary_packet<char> neolib::binary_packet

Definition at line 141 of file binary_packet.hpp.

cache

template<typename T >

using neolib::cache = typedef std::optional<T>

Definition at line 216 of file neolib.hpp.

ci_string

typedef std::basic_string<char, ci_char_traits<std::char_traits<char> > > neolib::ci_string

Definition at line 89 of file string_ci.hpp.

ci_u16string

typedef std::basic_string<char16_t, ci_char_traits<std::char_traits<char16_t> > > neolib::ci_u16string

Definition at line 90 of file string_ci.hpp.

cookie

typedef uint32_t neolib::cookie

Definition at line 44 of file i_jar.hpp.

cookie_ref_ptr

typedef basic_cookie_ref_ptr<cookie> neolib::cookie_ref_ptr

Definition at line 732 of file jar.hpp.

data_packet

typedef basic_data_packet< char > neolib::data_packet

Definition at line 124 of file data_packet.hpp.

destroyed_flag

typedef lifetime_flag<lifetime_state::Destroyed> neolib::destroyed_flag

Definition at line 77 of file lifetime.hpp.

destroying_flag

typedef lifetime_flag<lifetime_state::Destroying> neolib::destroying_flag

Definition at line 75 of file lifetime.hpp.

enum_enumerators_t

template<typename Enum >

using neolib::enum_enumerators_t = typedef multimap<std::underlying_type_t<Enum>, string>

Definition at line 47 of file i_enum.hpp.

enum_t

template<typename Enum >

using neolib::enum_t = typedef basic_enum<Enum>

Definition at line 128 of file enum.hpp.

fast_fjson

typedef basic_json<json_syntax::Functional, neolib::fast_pool_allocator<json_type> > neolib::fast_fjson

Definition at line 1078 of file json.hpp.

fast_fjson_array

typedef fast_fjson::json_array neolib::fast_fjson_array

Definition at line 1081 of file json.hpp.

fast_fjson_bool

typedef fast_fjson::json_bool neolib::fast_fjson_bool

Definition at line 1088 of file json.hpp.

fast_fjson_double

typedef fast_fjson::json_double neolib::fast_fjson_double

Definition at line 1082 of file json.hpp.

fast_fjson_int

typedef fast_fjson::json_int neolib::fast_fjson_int

Definition at line 1085 of file json.hpp.

fast_fjson_int64

typedef fast_fjson::json_int64 neolib::fast_fjson_int64

Definition at line 1083 of file json.hpp.

fast_fjson_keyword

typedef fast_fjson::json_keyword neolib::fast_fjson_keyword

Definition at line 1090 of file json.hpp.

fast_fjson_null

typedef fast_fjson::json_null neolib::fast_fjson_null

Definition at line 1089 of file json.hpp.

fast_fjson_object

typedef fast_fjson::json_object neolib::fast_fjson_object

Definition at line 1080 of file json.hpp.

fast_fjson_string

typedef fast_fjson::json_string neolib::fast_fjson_string

Definition at line 1087 of file json.hpp.

fast_fjson_uint

typedef fast_fjson::json_uint neolib::fast_fjson_uint

Definition at line 1086 of file json.hpp.

fast_fjson_uint64

typedef fast_fjson::json_uint64 neolib::fast_fjson_uint64

Definition at line 1084 of file json.hpp.

fast_fjson_value

typedef fast_fjson::json_value neolib::fast_fjson_value

Definition at line 1079 of file json.hpp.

fast_json

typedef basic_json<json_syntax::Standard, neolib::fast_pool_allocator<json_type> > neolib::fast_json

Definition at line 1022 of file json.hpp.

fast_json_array

typedef fast_json::json_array neolib::fast_json_array

Definition at line 1025 of file json.hpp.

fast_json_bool

typedef fast_json::json_bool neolib::fast_json_bool

Definition at line 1032 of file json.hpp.

fast_json_double

typedef fast_json::json_double neolib::fast_json_double

Definition at line 1026 of file json.hpp.

fast_json_int

typedef fast_json::json_int neolib::fast_json_int

Definition at line 1029 of file json.hpp.

fast_json_int64

typedef fast_json::json_int64 neolib::fast_json_int64

Definition at line 1027 of file json.hpp.

fast_json_keyword

typedef fast_json::json_keyword neolib::fast_json_keyword

Definition at line 1034 of file json.hpp.

fast_json_null

typedef fast_json::json_null neolib::fast_json_null

Definition at line 1033 of file json.hpp.

fast_json_object

typedef fast_json::json_object neolib::fast_json_object

Definition at line 1024 of file json.hpp.

fast_json_string

typedef fast_json::json_string neolib::fast_json_string

Definition at line 1031 of file json.hpp.

fast_json_uint

typedef fast_json::json_uint neolib::fast_json_uint

Definition at line 1030 of file json.hpp.

fast_json_uint64

typedef fast_json::json_uint64 neolib::fast_json_uint64

Definition at line 1028 of file json.hpp.

fast_json_value

typedef fast_json::json_value neolib::fast_json_value

Definition at line 1023 of file json.hpp.

fast_pool_allocator

template<typename T , unsigned NextSize = 32>

using neolib::fast_pool_allocator = typedef boost::fast_pool_allocator<T, boost::default_user_allocator_new_delete, boost::details::pool::null_mutex, NextSize>

Definition at line 573 of file allocator.hpp.

fast_rjson

typedef basic_json<json_syntax::Relaxed, neolib::fast_pool_allocator<json_type> > neolib::fast_rjson

Definition at line 1050 of file json.hpp.

fast_rjson_array

typedef fast_rjson::json_array neolib::fast_rjson_array

Definition at line 1053 of file json.hpp.

fast_rjson_bool

typedef fast_rjson::json_bool neolib::fast_rjson_bool

Definition at line 1060 of file json.hpp.

fast_rjson_double

typedef fast_rjson::json_double neolib::fast_rjson_double

Definition at line 1054 of file json.hpp.

fast_rjson_int

typedef fast_rjson::json_int neolib::fast_rjson_int

Definition at line 1057 of file json.hpp.

fast_rjson_int64

typedef fast_rjson::json_int64 neolib::fast_rjson_int64

Definition at line 1055 of file json.hpp.

fast_rjson_keyword

typedef fast_rjson::json_keyword neolib::fast_rjson_keyword

Definition at line 1062 of file json.hpp.

fast_rjson_null

typedef fast_rjson::json_null neolib::fast_rjson_null

Definition at line 1061 of file json.hpp.

fast_rjson_object

typedef fast_rjson::json_object neolib::fast_rjson_object

Definition at line 1052 of file json.hpp.

fast_rjson_string

typedef fast_rjson::json_string neolib::fast_rjson_string

Definition at line 1059 of file json.hpp.

fast_rjson_uint

typedef fast_rjson::json_uint neolib::fast_rjson_uint

Definition at line 1058 of file json.hpp.

fast_rjson_uint64

typedef fast_rjson::json_uint64 neolib::fast_rjson_uint64

Definition at line 1056 of file json.hpp.

fast_rjson_value

typedef fast_rjson::json_value neolib::fast_rjson_value

Definition at line 1051 of file json.hpp.

fjson

typedef basic_json<json_syntax::Functional> neolib::fjson

Definition at line 1064 of file json.hpp.

fjson_array

typedef fjson::json_array neolib::fjson_array

Definition at line 1067 of file json.hpp.

fjson_bool

typedef fjson::json_bool neolib::fjson_bool

Definition at line 1074 of file json.hpp.

fjson_double

typedef fjson::json_double neolib::fjson_double

Definition at line 1068 of file json.hpp.

fjson_int

typedef fjson::json_int neolib::fjson_int

Definition at line 1071 of file json.hpp.

fjson_int64

typedef fjson::json_int64 neolib::fjson_int64

Definition at line 1069 of file json.hpp.

fjson_keyword

typedef fjson::json_keyword neolib::fjson_keyword

Definition at line 1076 of file json.hpp.

fjson_null

typedef fjson::json_null neolib::fjson_null

Definition at line 1075 of file json.hpp.

fjson_object

typedef fjson::json_object neolib::fjson_object

Definition at line 1066 of file json.hpp.

fjson_string

typedef fjson::json_string neolib::fjson_string

Definition at line 1073 of file json.hpp.

fjson_uint

typedef fjson::json_uint neolib::fjson_uint

Definition at line 1072 of file json.hpp.

fjson_uint64

typedef fjson::json_uint64 neolib::fjson_uint64

Definition at line 1070 of file json.hpp.

fjson_value

typedef fjson::json_value neolib::fjson_value

Definition at line 1065 of file json.hpp.

from_abstract_t

template<typename AbstractT , typename... Type>

using neolib::from_abstract_t = typedef typename from_abstract_next<AbstractT, Type...>::result_type

Definition at line 134 of file variant.hpp.

http_stream

typedef packet_stream<http_packet, tcp_protocol> neolib::http_stream

Definition at line 68 of file http.hpp.

i_cookie_consumer

typedef i_basic_cookie_consumer<cookie> neolib::i_cookie_consumer

Definition at line 66 of file i_jar.hpp.

i_enum

typedef i_enum_i32 neolib::i_enum

Definition at line 265 of file i_enum.hpp.

i_enum_i16

typedef i_basic_enum<int16_t> neolib::i_enum_i16

Definition at line 261 of file i_enum.hpp.

i_enum_i32

typedef i_basic_enum<int32_t> neolib::i_enum_i32

Definition at line 262 of file i_enum.hpp.

i_enum_i64

typedef i_basic_enum<int64_t> neolib::i_enum_i64

Definition at line 263 of file i_enum.hpp.

i_enum_i8

typedef i_basic_enum<int8_t> neolib::i_enum_i8

Definition at line 260 of file i_enum.hpp.

i_enum_t

template<typename T >

using neolib::i_enum_t = typedef i_basic_enum<std::underlying_type_t<T> >

Definition at line 211 of file i_enum.hpp.

i_enum_u16

typedef i_basic_enum<uint16_t> neolib::i_enum_u16

Definition at line 256 of file i_enum.hpp.

i_enum_u32

typedef i_basic_enum<uint32_t> neolib::i_enum_u32

Definition at line 257 of file i_enum.hpp.

i_enum_u64

typedef i_basic_enum<uint64_t> neolib::i_enum_u64

Definition at line 258 of file i_enum.hpp.

i_enum_u8

typedef i_basic_enum<uint8_t> neolib::i_enum_u8

Definition at line 255 of file i_enum.hpp.

i_jar

template<typename T >

using neolib::i_jar = typedef i_basic_jar<T, i_vector<T>, cookie>

Definition at line 122 of file i_jar.hpp.

i_packet

typedef i_basic_packet<char> neolib::i_packet

Definition at line 81 of file i_packet.hpp.

i_small_cookie_consumer

typedef i_basic_cookie_consumer<small_cookie> neolib::i_small_cookie_consumer

Definition at line 67 of file i_jar.hpp.

i_small_jar

template<typename T >

using neolib::i_small_jar = typedef i_basic_jar<T, i_vector<T>, small_cookie>

Definition at line 124 of file i_jar.hpp.

jar

template<typename T , typename MutexType = null_mutex>

using neolib::jar = typedef basic_jar<T, vector<T>, cookie, MutexType>

Definition at line 736 of file jar.hpp.

json

typedef basic_json<json_syntax::Standard> neolib::json

Definition at line 1008 of file json.hpp.

json_array

typedef json::json_array neolib::json_array

Definition at line 1011 of file json.hpp.

json_bool

typedef json::json_bool neolib::json_bool

Definition at line 1018 of file json.hpp.

json_double

typedef json::json_double neolib::json_double

Definition at line 1012 of file json.hpp.

json_int

typedef json::json_int neolib::json_int

Definition at line 1015 of file json.hpp.

json_int64

typedef json::json_int64 neolib::json_int64

Definition at line 1013 of file json.hpp.

json_keyword

typedef json::json_keyword neolib::json_keyword

Definition at line 1020 of file json.hpp.

json_null

typedef json::json_null neolib::json_null

Definition at line 1019 of file json.hpp.

json_object

typedef json::json_object neolib::json_object

Definition at line 1010 of file json.hpp.

json_string

typedef json::json_string neolib::json_string

Definition at line 1017 of file json.hpp.

json_uint

typedef json::json_uint neolib::json_uint

Definition at line 1016 of file json.hpp.

json_uint64

typedef json::json_uint64 neolib::json_uint64

Definition at line 1014 of file json.hpp.

json_value

typedef json::json_value neolib::json_value

Definition at line 1009 of file json.hpp.

large_cookie

typedef uint64_t neolib::large_cookie

Definition at line 46 of file i_jar.hpp.

none_t

using neolib::none_t = typedef std::monostate

Definition at line 110 of file variant.hpp.

number_t

typedef variant<double, int32_t, uint32_t, int64_t, uint64_t> neolib::number_t

Definition at line 115 of file string_numeric.hpp.

offset_pointer_t

template<typename T >

using neolib::offset_pointer_t = typedef typename offset_pointer<T>::pointer_type

Definition at line 50 of file i_contiguous_random_access_container.hpp.

omega_pool_allocator

template<typename T , std::size_t ChunkSize = 1 * 1024 * 1024>

using neolib::omega_pool_allocator = typedef neo_pool_allocator<T, ChunkSize, true>

Definition at line 563 of file allocator.hpp.

optional_destroyed_flag

typedef std::optional<destroyed_flag> neolib::optional_destroyed_flag

Definition at line 78 of file lifetime.hpp.

optional_destroying_flag

typedef std::optional<destroying_flag> neolib::optional_destroying_flag

Definition at line 76 of file lifetime.hpp.

optional_t

template<typename T >

using neolib::optional_t = typedef typename optional_type<T>::type

Definition at line 336 of file optional.hpp.

packet_connection_owner

typedef i_basic_packet_connection_owner<char> neolib::packet_connection_owner

Definition at line 77 of file packet_connection.hpp.

pool_allocator

template<typename T , unsigned NextSize = 32>

using neolib::pool_allocator = typedef boost::pool_allocator<T, boost::default_user_allocator_new_delete, boost::details::pool::null_mutex, NextSize>

Definition at line 568 of file allocator.hpp.

quick_string

typedef basic_quick_string<char> neolib::quick_string

Definition at line 734 of file quick_string.hpp.

random

using neolib::random = typedef basic_random<uint32_t>

Definition at line 171 of file random.hpp.

rjson

typedef basic_json<json_syntax::Relaxed> neolib::rjson

Definition at line 1036 of file json.hpp.

rjson_array

typedef rjson::json_array neolib::rjson_array

Definition at line 1039 of file json.hpp.

rjson_bool

typedef rjson::json_bool neolib::rjson_bool

Definition at line 1046 of file json.hpp.

rjson_double

typedef rjson::json_double neolib::rjson_double

Definition at line 1040 of file json.hpp.

rjson_int

typedef rjson::json_int neolib::rjson_int

Definition at line 1043 of file json.hpp.

rjson_int64

typedef rjson::json_int64 neolib::rjson_int64

Definition at line 1041 of file json.hpp.

rjson_keyword

typedef rjson::json_keyword neolib::rjson_keyword

Definition at line 1048 of file json.hpp.

rjson_null

typedef rjson::json_null neolib::rjson_null

Definition at line 1047 of file json.hpp.

rjson_object

typedef rjson::json_object neolib::rjson_object

Definition at line 1038 of file json.hpp.

rjson_string

typedef rjson::json_string neolib::rjson_string

Definition at line 1045 of file json.hpp.

rjson_uint

typedef rjson::json_uint neolib::rjson_uint

Definition at line 1044 of file json.hpp.

rjson_uint64

typedef rjson::json_uint64 neolib::rjson_uint64

Definition at line 1042 of file json.hpp.

rjson_value

typedef rjson::json_value neolib::rjson_value

Definition at line 1037 of file json.hpp.

setting_type_t

template<setting_type ST>

using neolib::setting_type_t = typedef typename get_setting_type<ST>::type

Definition at line 76 of file i_setting_value.hpp.

simple_variant

typedef plugin_variant<simple_variant_type, bool, int64_t, double, string, ref_ptr<i_enum>, ref_ptr<i_custom_type> > neolib::simple_variant

Definition at line 51 of file simple_variant.hpp.

small_buffer_allocator

template<typename T , std::size_t SmallBufferSize = 8u>

using neolib::small_buffer_allocator = typedef basic_small_buffer_allocator<small_buffer_allocator_types<T, T>, SmallBufferSize>

Definition at line 559 of file allocator.hpp.

small_cookie

typedef uint16_t neolib::small_cookie

Definition at line 45 of file i_jar.hpp.

small_cookie_ref_ptr

typedef basic_cookie_ref_ptr<small_cookie> neolib::small_cookie_ref_ptr

Definition at line 733 of file jar.hpp.

small_jar

template<typename T , typename MutexType = null_mutex>

using neolib::small_jar = typedef basic_jar<T, vector<T>, small_cookie, MutexType>

Definition at line 738 of file jar.hpp.

small_vector_jar

template<typename T , typename MutexType = null_mutex>

using neolib::small_vector_jar = typedef basic_vector_jar<T, small_cookie, MutexType>

Definition at line 743 of file jar.hpp.

spinlock

using neolib::spinlock = typedef boost::fibers::detail::spinlock

Definition at line 110 of file mutex.hpp.

static_vector

template<typename T , std::size_t N>

using neolib::static_vector = typedef boost::container::static_vector<T, N>

Definition at line 44 of file static_vector.hpp.

string_packet

typedef basic_string_packet<char> neolib::string_packet

Definition at line 168 of file string_packet.hpp.

string_spans

typedef std::vector<string_span> neolib::string_spans

Definition at line 236 of file string_utils.hpp.

tcp_binary_packet_stream

typedef packet_stream<binary_packet, tcp_protocol> neolib::tcp_binary_packet_stream

Definition at line 200 of file packet_stream.hpp.

tcp_protocol

typedef boost::asio::ip::tcp neolib::tcp_protocol

Definition at line 56 of file packet_connection.hpp.

tcp_resolver

typedef basic_resolver<tcp_protocol> neolib::tcp_resolver

Definition at line 221 of file resolver.hpp.

tcp_string_packet_stream

typedef packet_stream<string_packet, tcp_protocol> neolib::tcp_string_packet_stream

Definition at line 201 of file packet_stream.hpp.

tcp_string_packet_stream_server

typedef tcp_packet_stream_server<string_packet> neolib::tcp_string_packet_stream_server

Definition at line 222 of file tcp_packet_stream_server.hpp.

thread_safe_fast_pool_allocator

template<typename T , unsigned NextSize = 32>

using neolib::thread_safe_fast_pool_allocator = typedef boost::fast_pool_allocator<T, boost::default_user_allocator_new_delete, boost::details::pool::default_mutex, NextSize>

Definition at line 571 of file allocator.hpp.

thread_safe_pool_allocator

template<typename T , unsigned NextSize = 32>

using neolib::thread_safe_pool_allocator = typedef boost::pool_allocator<T, boost::default_user_allocator_new_delete, boost::details::pool::default_mutex, NextSize>

Definition at line 566 of file allocator.hpp.

to_const_reference_t

template<typename T >

using neolib::to_const_reference_t = typedef const std::remove_reference_t<T>&

Definition at line 111 of file neolib.hpp.

tree

template<typename T , size_t N = 64, typename Alloc = std::allocator<T>>

using neolib::tree = typedef segmented_tree<T, N, Alloc>

Definition at line 44 of file tree.hpp.

udp_protocol

typedef boost::asio::ip::udp neolib::udp_protocol

Definition at line 57 of file packet_connection.hpp.

udp_resolver

typedef basic_resolver<udp_protocol> neolib::udp_resolver

Definition at line 222 of file resolver.hpp.

unicode_char_t

typedef char32_t neolib::unicode_char_t

Definition at line 68 of file string_utf.hpp.

utf16_to_utf8_character_map

typedef std::map<std::string::size_type, std::u16string::size_type> neolib::utf16_to_utf8_character_map

Definition at line 123 of file string_utf.hpp.

vector_jar

template<typename T , typename MutexType = null_mutex>

using neolib::vector_jar = typedef basic_vector_jar<T, cookie, MutexType>

Definition at line 741 of file jar.hpp.

wait_result

typedef std::variant<wait_result_event, wait_result_message, wait_result_waitable> neolib::wait_result

Definition at line 85 of file waitable_event.hpp.

wxml

typedef basic_xml<wchar_t, pool_allocator<char> > neolib::wxml

Definition at line 554 of file xml.hpp.

xml

typedef basic_xml<char, pool_allocator<char> > neolib::xml

Definition at line 553 of file xml.hpp.

Enumeration Type Documentation

async_task_state

enum class neolib::async_task_state

strong

Enumerator
Init
Running
Halted
Finished

Definition at line 72 of file async_task.hpp.

json_encoding

enum class neolib::json_encoding

strong

Enumerator
Utf8
Utf16LE
Utf16BE
Utf32LE
Utf32BE

Definition at line 72 of file json.hpp.

json_syntax

enum class neolib::json_syntax

strong

Enumerator
Standard
StandardNoKeywords
Relaxed
Functional

Definition at line 64 of file json.hpp.

json_type

enum class neolib::json_type

strong

Enumerator
Unknown
Object
Array
Double
Int64
Uint64
Int
Uint
String
Bool
Null
Keyword

Definition at line 93 of file json.hpp.

lexer_atom_function

enum class neolib::lexer_atom_function

strong

Enumerator
Eat
Keep
Not
End

Definition at line 63 of file lexer.hpp.

lifetime_state

enum class neolib::lifetime_state

strong

Enumerator
Creating
Alive
Destroying
Destroyed

Definition at line 60 of file i_lifetime.hpp.

power_mode

enum class neolib::power_mode

strong

Enumerator
Green
Normal
Turbo

Definition at line 45 of file i_power.hpp.

protocol_family

enum neolib::protocol_family

Enumerator
IPv4
IPv6
IPv4orIPv6

Definition at line 51 of file resolver.hpp.

setting_type

enum class neolib::setting_type : uint32_t

strong

Enumerator
Boolean
Int8
Int16
Int32
Int64
Uint8
Uint16
Uint32
Uint64
Float32
Float64
String
Enum
Custom

Definition at line 44 of file i_setting_value.hpp.

simple_variant_type

enum class neolib::simple_variant_type : uint32_t

strong

Enumerator
Boolean
Integer
Real
String
Enum
CustomType

Definition at line 49 of file i_simple_variant.hpp.

thread_state

enum class neolib::thread_state

strong

Enumerator
ReadyToStart
Starting
Started
Finished
Aborted
Cancelled
Error

Definition at line 49 of file i_thread.hpp.

trigger_result

enum class neolib::trigger_result

strong

Enumerator
Unknown
Unaccepted
Accepted

Definition at line 108 of file i_event.hpp.

trigger_type

enum class neolib::trigger_type

strong

Enumerator
Synchronous
SynchronousDontQueue
Asynchronous
AsynchronousDontQueue

Definition at line 100 of file i_event.hpp.

yield_type

enum class neolib::yield_type

strong

Enumerator
NoYield
Yield
Sleep

Definition at line 42 of file i_thread.hpp.

Function Documentation

any_cast() [1/10]

template<class T >

T neolib::any_cast ( any &&  operand )

inline

Definition at line 277 of file any.hpp.

any_cast() [2/10]

template<class T >

T neolib::any_cast ( any &  operand )

inline

Definition at line 272 of file any.hpp.

any_cast() [3/10]

template<class T >

T * neolib::any_cast ( any *  operand )

inlinenoexcept

Definition at line 287 of file any.hpp.

any_cast() [4/10]

template<class T >

T neolib::any_cast ( const any &  operand )

inline

Definition at line 267 of file any.hpp.

any_cast() [5/10]

template<class T >

const T * neolib::any_cast ( const any *  operand )

inlinenoexcept

Definition at line 282 of file any.hpp.

any_cast() [6/10]

template<class T >

T neolib::any_cast ( const i_any &  operand )

inline

Definition at line 81 of file i_any.hpp.

any_cast() [7/10]

template<class T >

const T * neolib::any_cast ( const i_any *  operand )

inlinenoexcept

Definition at line 96 of file i_any.hpp.

any_cast() [8/10]

template<class T >

T neolib::any_cast ( i_any &&  operand )

inline

Definition at line 91 of file i_any.hpp.

any_cast() [9/10]

template<class T >

T neolib::any_cast ( i_any &  operand )

inline

Definition at line 86 of file i_any.hpp.

any_cast() [10/10]

template<class T >

T * neolib::any_cast ( i_any *  operand )

inlinenoexcept

Definition at line 101 of file i_any.hpp.

any_const_iterator_cast()

template<typename Source , typename Target >

any_const_iterator neolib::any_const_iterator_cast

(

any_iterator

aSource

)

Definition at line 360 of file any_iterator.hpp.

any_to_utf16() [1/4]

std::u16string neolib::any_to_utf16 ( const std::string &  aString, bool  aCodePageFallback = false  )

inline

Definition at line 466 of file string_utf.hpp.

any_to_utf16() [2/4]

any_to_utf16_result< std::string > neolib::any_to_utf16 ( const std::string::value_type *  aString, std::string::size_type  aStringLength  )

inline

Definition at line 530 of file string_utf.hpp.

any_to_utf16() [3/4]

const std::u16string & neolib::any_to_utf16 ( const std::u16string &  aString )

inline

Definition at line 481 of file string_utf.hpp.

any_to_utf16() [4/4]

any_to_utf16_result< std::u16string > neolib::any_to_utf16 ( const std::u16string::value_type *  aString, std::u16string::size_type  aStringLength  )

inline

Definition at line 535 of file string_utf.hpp.

any_to_utf8() [1/2]

const std::string & neolib::any_to_utf8 ( const std::string &  aString )

inline

Definition at line 471 of file string_utf.hpp.

any_to_utf8() [2/2]

std::string neolib::any_to_utf8 ( const std::u16string &  aString )

inline

Definition at line 476 of file string_utf.hpp.

append_utf8()

std::size_t neolib::append_utf8 ( std::string &  aString, unicode_char_t  aCharacter  )

inline

Definition at line 88 of file string_utf.hpp.

can_read_file() [1/2]

NEOLIB_EXPORT bool neolib::can_read_file

(

const std::string &

aPath

)

can_read_file() [2/2]

NEOLIB_EXPORT bool neolib::can_read_file

(

const std::wstring &

aPath

)

check_utf8() [1/3]

bool neolib::check_utf8 ( const i_string &  aString )

inline

Definition at line 437 of file string_utf.hpp.

check_utf8() [2/3]

template<typename CharT , typename Traits , typename Alloc >

bool neolib::check_utf8 ( const std::basic_string< CharT, Traits, Alloc > &  aString )

inline

Definition at line 432 of file string_utf.hpp.

check_utf8() [3/3]

template<typename CharT , typename Traits >

bool neolib::check_utf8 ( const std::basic_string_view< CharT, Traits > &  aString )

inline

Definition at line 402 of file string_utf.hpp.

clear_cache()

template<typename T >

void neolib::clear_cache ( cache< T > &  aCachedVariable )

inline

Definition at line 221 of file neolib.hpp.

const_pointer_cast() [1/4]

template<class T , class U >

ref_ptr< T > neolib::const_pointer_cast ( i_ref_ptr< U > &&  aOther )

noexcept

Definition at line 700 of file reference_counted.hpp.

const_pointer_cast() [2/4]

template<class T , class U >

ref_ptr< T > neolib::const_pointer_cast ( i_ref_ptr< U > const &  aOther )

noexcept

Definition at line 693 of file reference_counted.hpp.

const_pointer_cast() [3/4]

template<class T , class U >

ref_ptr< T > neolib::const_pointer_cast ( ref_ptr< U > &&  aOther )

noexcept

Definition at line 640 of file reference_counted.hpp.

const_pointer_cast() [4/4]

template<class T , class U >

ref_ptr< T > neolib::const_pointer_cast ( ref_ptr< U > const &  aOther )

noexcept

Definition at line 633 of file reference_counted.hpp.

contains_character()

template<typename CharT >

bool neolib::contains_character ( const CharT *  aSequence, CharT  aCharacter  )

inline

Definition at line 332 of file string_utils.hpp.

convert_path() [1/2]

NEOLIB_EXPORT std::wstring neolib::convert_path

(

const std::string &

aString

)

convert_path() [2/2]

NEOLIB_EXPORT std::string neolib::convert_path

(

const std::wstring &

aString

)

crc32()

NEOLIB_EXPORT uint32_t neolib::crc32	(	const uint8_t *	aData,
		uint32_t	aDataLength
	)

create_file() [1/2]

NEOLIB_EXPORT std::string neolib::create_file

(

const std::string &

aFileName

)

create_file() [2/2]

NEOLIB_EXPORT void neolib::create_file

(

const std::wstring &

aFileName

)

create_path() [1/2]

NEOLIB_EXPORT const std::string & neolib::create_path

(

const std::string &

aPath

)

create_path() [2/2]

NEOLIB_EXPORT const std::wstring & neolib::create_path

(

const std::wstring &

aPath

)

define_setting_type()

neolib::define_setting_type

(

bool

)

destroyed()

template<typename Object , typename Handler >

auto neolib::destroyed ( Object &  aObject, const Handler  aHandler  )

inline

Definition at line 73 of file i_object.hpp.

destroying()

template<typename Object , typename Handler >

auto neolib::destroying ( Object &  aObject, const Handler  aHandler  )

inline

Definition at line 64 of file i_object.hpp.

do_socket() [1/4]

template<typename CharType , size_t ReceiveBufferSize>

basic_packet_connection< CharType, tcp_protocol, ReceiveBufferSize >::socket_type & neolib::do_socket ( basic_packet_connection< CharType, tcp_protocol, ReceiveBufferSize > &  aConnection )

inline

Definition at line 648 of file packet_connection.hpp.

do_socket() [2/4]

template<typename CharType , size_t ReceiveBufferSize>

basic_packet_connection< CharType, udp_protocol, ReceiveBufferSize >::socket_type & neolib::do_socket ( basic_packet_connection< CharType, udp_protocol, ReceiveBufferSize > &  aConnection )

inline

Definition at line 663 of file packet_connection.hpp.

do_socket() [3/4]

template<typename CharType , size_t ReceiveBufferSize>

const basic_packet_connection< CharType, tcp_protocol, ReceiveBufferSize >::socket_type & neolib::do_socket ( const basic_packet_connection< CharType, tcp_protocol, ReceiveBufferSize > &  aConnection )

inline

Definition at line 632 of file packet_connection.hpp.

do_socket() [4/4]

template<typename CharType , size_t ReceiveBufferSize>

const basic_packet_connection< CharType, udp_protocol, ReceiveBufferSize >::socket_type & neolib::do_socket ( const basic_packet_connection< CharType, udp_protocol, ReceiveBufferSize > &  aConnection )

inline

Definition at line 654 of file packet_connection.hpp.

do_wildcard_match()

template<typename CharT , typename Traits , typename FwdIter >

bool neolib::do_wildcard_match ( FwdIter  aTextBegin, FwdIter  aTextEnd, FwdIter  aPatternBegin, FwdIter  aPatternEnd  )

inline

Definition at line 424 of file string_utils.hpp.

document_type()

template<json_syntax Syntax>

constexpr const char * neolib::document_type ( )

inlineconstexpr

Definition at line 1115 of file json.inl.

double_to_string()

template<typename CharT , typename Traits = std::char_traits<CharT>, typename Alloc = std::allocator<CharT>>

std::basic_string< CharT, Traits, Alloc > neolib::double_to_string ( double  aDouble, std::size_t  aPrecision = 0, bool  aFixed = true, std::size_t  aWidth = 0, CharT  aFill = '0'  )

inline

Definition at line 234 of file string_numeric.hpp.

dynamic_pointer_cast() [1/4]

template<class T , class U >

ref_ptr< T > neolib::dynamic_pointer_cast ( i_ref_ptr< U > &&  aOther )

noexcept

Definition at line 730 of file reference_counted.hpp.

dynamic_pointer_cast() [2/4]

template<class T , class U >

ref_ptr< T > neolib::dynamic_pointer_cast ( i_ref_ptr< U > const &  aOther )

noexcept

Definition at line 721 of file reference_counted.hpp.

dynamic_pointer_cast() [3/4]

template<class T , class U >

ref_ptr< T > neolib::dynamic_pointer_cast ( ref_ptr< U > &&  aOther )

noexcept

Definition at line 670 of file reference_counted.hpp.

dynamic_pointer_cast() [4/4]

template<class T , class U >

ref_ptr< T > neolib::dynamic_pointer_cast ( ref_ptr< U > const &  aOther )

noexcept

Definition at line 661 of file reference_counted.hpp.

enum_enumerators()

template<typename Enum >

enum_enumerators_t< Enum > const & neolib::enum_enumerators

(

)

enum_to_hex()

template<typename Enum >

std::string neolib::enum_to_hex ( Enum  aEnumValue )

inline

Definition at line 70 of file i_enum.hpp.

enum_to_string() [1/2]

template<typename Enum , typename StringT = string>

StringT neolib::enum_to_string ( const i_enum_t< Enum > &  aEnumerator, bool  aMustEnumerate = false  )

inline

Definition at line 214 of file i_enum.hpp.

enum_to_string() [2/2]

template<typename Enum , typename StringT = string>

StringT neolib::enum_to_string ( Enum  aEnumerator, bool  aMustEnumerate = false  )

inline

Definition at line 78 of file i_enum.hpp.

event_consumed()

bool neolib::event_consumed ( trigger_result  aTriggerResult )

inline

Definition at line 115 of file i_event.hpp.

event_mutex()

switchable_mutex & neolib::event_mutex ( )

inline

Definition at line 46 of file i_event.hpp.

fake_simd_fma_4d()

double neolib::fake_simd_fma_4d ( double  x1, double  x2, double  y1, double  y2, double  z1, double  z2, double  w1, double  w2  )

inline

Definition at line 92 of file simd.hpp.

fake_simd_mul_4d()

void neolib::fake_simd_mul_4d ( double  x1, double  x2, double  y1, double  y2, double  z1, double  z2, double  w1, double  w2, double &  a, double &  b, double &  c, double &  d  )

inline

Definition at line 124 of file simd.hpp.

fake_simd_rand()

uint32_t neolib::fake_simd_rand ( )

inline

Definition at line 263 of file simd.hpp.

fake_simd_srand()

void neolib::fake_simd_srand ( uint32_t  seed )

inline

Definition at line 190 of file simd.hpp.

fast_hash() [1/2]

template<typename T >

T neolib::fast_hash ( const void *  aInput, std::size_t  aLength  )

inline

Definition at line 79 of file fast_hash.hpp.

fast_hash() [2/2]

uint32_t neolib::fast_hash ( const void *  aInput, std::size_t  aLength  )

inline

Definition at line 84 of file fast_hash.hpp.

file_date() [1/2]

NEOLIB_EXPORT std::time_t neolib::file_date

(

const std::string &

aPath

)

file_date() [2/2]

NEOLIB_EXPORT std::time_t neolib::file_date

(

const std::wstring &

aPath

)

file_exists() [1/2]

NEOLIB_EXPORT bool neolib::file_exists

(

const std::string &

aPath

)

file_exists() [2/2]

NEOLIB_EXPORT bool neolib::file_exists

(

const std::wstring &

aPath

)

file_ext() [1/2]

NEOLIB_EXPORT std::string neolib::file_ext

(

const std::string &

aPath

)

file_ext() [2/2]

NEOLIB_EXPORT std::wstring neolib::file_ext

(

const std::wstring &

aPath

)

file_size() [1/2]

NEOLIB_EXPORT unsigned long neolib::file_size

(

const std::string &

aPath

)

file_size() [2/2]

NEOLIB_EXPORT unsigned long neolib::file_size

(

const std::wstring &

aPath

)

format()

template<typename... Args>

format_result neolib::format ( std::string_view const &  aFormat, Args &&...  aArgs  )

inline

Definition at line 536 of file string_utils.hpp.

from_std_string()

template<typename T >

T neolib::from_std_string ( std::string const &  aValueAsString )

inline

Definition at line 102 of file string_utils.hpp.

from_string() [1/2]

template<typename T >

T neolib::from_string ( i_string const &  aValueAsString )

inline

Definition at line 118 of file string_utils.hpp.

from_string() [2/2]

simple_variant neolib::from_string ( std::string const &  aString, simple_variant_type  aType  )

inline

Definition at line 53 of file simple_variant.hpp.

generate_uuid()

NEOLIB_EXPORT uuid neolib::generate_uuid

(

)

get_application_info()

NEOLIB_EXPORT application_info neolib::get_application_info

(

i_application_info const &

aAppInfo

)

get_as()

template<typename T , typename Id , typename... Types>

T neolib::get_as ( const i_plugin_variant< Id, Types... > &  aVariant )

inline

Definition at line 215 of file i_plugin_variant.hpp.

hash_value() [1/2]

std::size_t neolib::hash_value ( const lexer_atom_match_any &  )

inline

Definition at line 58 of file lexer.hpp.

hash_value() [2/2]

template<typename charT , typename Traits , typename Alloc >

std::size_t neolib::hash_value ( const neolib::basic_quick_string< charT, Traits, Alloc > &  sv )

inline

Definition at line 737 of file quick_string.hpp.

hex_dump()

template<class Elem , class Traits >

void neolib::hex_dump ( const void *  aData, std::size_t  aLength, std::basic_ostream< Elem, Traits > &  aStream, std::size_t  aWidth = 16  )

inline

Definition at line 45 of file hexdump.hpp.

holds_alternative()

template<typename T , typename Token , typename Scope , typename CharT >

bool neolib::holds_alternative ( const lexer_atom< Token, Scope, CharT > &  aAtom )

inline

Definition at line 213 of file lexer.hpp.

int32_to_string()

template<typename CharT , typename Traits = std::char_traits<CharT>, typename Alloc = std::allocator<CharT>>

std::basic_string< CharT, Traits, Alloc > neolib::int32_to_string ( int32_t  aint32, int  aBase = 10, std::size_t  aWidth = 0, CharT  aFill = '0'  )

inline

Definition at line 167 of file string_numeric.hpp.

int64_to_string()

template<typename CharT , typename Traits = std::char_traits<CharT>, typename Alloc = std::allocator<CharT>>

std::basic_string< CharT, Traits, Alloc > neolib::int64_to_string ( int64_t  aint32, int  aBase = 10, std::size_t  aWidth = 0, CharT  aFill = '0'  )

inline

Definition at line 182 of file string_numeric.hpp.

intrusive_sort() [1/2]

template<typename RandomIt , typename Swapper >

void neolib::intrusive_sort ( RandomIt  first, RandomIt  last, Swapper  swapper  )

inline

Definition at line 160 of file intrusive_sort.hpp.

intrusive_sort() [2/2]

template<typename RandomIt , typename Swapper , typename Compare >

void neolib::intrusive_sort ( RandomIt  first, RandomIt  last, Swapper  swapper, Compare  comp  )

inline

Definition at line 150 of file intrusive_sort.hpp.

is_alive()

template<typename Object >

bool neolib::is_alive ( Object &  aObject )

inline

Definition at line 55 of file i_object.hpp.

is_utf8_trailing()

bool neolib::is_utf8_trailing ( char  aCharacter )

inline

Definition at line 396 of file string_utf.hpp.

large_file_seek()

NEOLIB_EXPORT int neolib::large_file_seek	(	FILE *	aStream,
		long long	aOffset,
		int	aOrigin
	)

large_file_size() [1/2]

NEOLIB_EXPORT unsigned long long neolib::large_file_size

(

const std::string &

aPath

)

large_file_size() [2/2]

NEOLIB_EXPORT unsigned long long neolib::large_file_size

(

const std::wstring &

aPath

)

lexicographical_compare_ignoring_case()

template<typename CharT , typename Traits , typename Alloc >

bool neolib::lexicographical_compare_ignoring_case ( const std::basic_string< CharT, Traits, Alloc > &  s1, const std::basic_string< CharT, Traits, Alloc > &  s2  )

inline

Definition at line 136 of file string_ci.hpp.

make_ci_string() [1/2]

ci_string neolib::make_ci_string ( const std::string &  s )

inline

Definition at line 92 of file string_ci.hpp.

make_ci_string() [2/2]

ci_u16string neolib::make_ci_string ( const std::u16string &  s )

inline

Definition at line 96 of file string_ci.hpp.

make_custom_type() [1/2]

template<typename T >

custom_type< T > neolib::make_custom_type

(

)

Definition at line 121 of file custom_type.hpp.

make_custom_type() [2/2]

template<typename T >

custom_type< T > neolib::make_custom_type

(

const abstract_t< T > &

aValue

)

Definition at line 127 of file custom_type.hpp.

make_generic_iterator()

template<typename Iterator >

specialized_generic_iterator< Iterator > neolib::make_generic_iterator ( Iterator  aIterator )

inline

Definition at line 357 of file generic_iterator.hpp.

make_pair()

template<typename T1 , typename T2 >

pair< std::decay_t< T1 >, std::decay_t< T2 > > neolib::make_pair ( T1 &&  aFirst, T2 &&  aSecond  )

inline

Definition at line 106 of file pair.hpp.

make_ref()

template<typename ConcreteType , typename... Args>

ref_ptr< ConcreteType > neolib::make_ref ( Args &&...  args )

inline

Definition at line 613 of file reference_counted.hpp.

make_string() [1/2]

std::string neolib::make_string ( const ci_string &  s )

inline

Definition at line 101 of file string_ci.hpp.

make_string() [2/2]

std::u16string neolib::make_string ( const ci_u16string &  s )

inline

Definition at line 105 of file string_ci.hpp.

make_uuid()

uuid neolib::make_uuid ( const std::string &  aHyphenatedHexString )

inline

Definition at line 62 of file uuid.hpp.

make_zip_iterator()

template<typename... Iterators>

zip_iterator< Iterators... > neolib::make_zip_iterator ( Iterators &&...  iterators )

inline

Definition at line 199 of file zip_iterator.hpp.

move_file()

NEOLIB_EXPORT bool neolib::move_file	(	const std::string &	aPathFrom,
		const std::string &	aPathTo
	)

narrow_to_utf16()

template<typename CharT , typename Traits , typename Alloc >

std::u16string neolib::narrow_to_utf16 ( const std::basic_string< CharT, Traits, Alloc > &  aNarrowString )

inline

Definition at line 550 of file string_utf.hpp.

operator!=() [1/12]

template<typename T , typename U , std::size_t SmallBufferSize>

bool neolib::operator!= ( const basic_small_buffer_allocator< T, SmallBufferSize > &  , const basic_small_buffer_allocator< U, SmallBufferSize > &    )

inline

Definition at line 553 of file allocator.hpp.

operator!=() [2/12]

bool neolib::operator!= ( const ci_string &  s1, const std::string &  s2  )

inline

Definition at line 118 of file string_ci.hpp.

operator!=() [3/12]

template<typename Enum >

std::enable_if_t< std::is_enum_v< Enum >, bool > neolib::operator!= ( const i_basic_enum< std::underlying_type_t< Enum > > &  lhs, Enum  rhs  )

inline

Definition at line 232 of file i_enum.hpp.

operator!=() [4/12]

bool neolib::operator!= ( const i_custom_type &  lhs, const i_custom_type &  rhs  )

inline

Definition at line 91 of file i_custom_type.hpp.

operator!=() [5/12]

template<typename Interface1 , typename Interface2 >

bool neolib::operator!= ( const i_ref_ptr< Interface1 > &  lhs, const Interface2 *  rhs  )

inlinenoexcept

Definition at line 130 of file i_reference_counted.hpp.

operator!=() [6/12]

template<typename Interface1 , typename Interface2 >

bool neolib::operator!= ( const Interface2 *  lhs, const i_ref_ptr< Interface1 > &  rhs  )

inlinenoexcept

Definition at line 136 of file i_reference_counted.hpp.

operator!=() [7/12]

bool neolib::operator!= ( const std::string &  s1, const ci_string &  s2  )

inline

Definition at line 122 of file string_ci.hpp.

operator!=() [8/12]

template<typename Enum >

std::enable_if_t< std::is_enum_v< Enum >, bool > neolib::operator!= ( Enum  lhs, const i_basic_enum< std::underlying_type_t< Enum > > &  rhs  )

inline

Definition at line 238 of file i_enum.hpp.

operator!=() [9/12]

template<typename... Types>

bool neolib::operator!= ( none_t const &  , variant< Types... > const &  rhs  )

inlinenoexcept

Definition at line 283 of file variant.hpp.

operator!=() [10/12]

template<typename T , std::size_t SegmentSize, typename Alloc >

bool neolib::operator!= ( segmented_array< T, SegmentSize, Alloc > const &  lhs, segmented_array< T, SegmentSize, Alloc > const &  rhs  )

inline

Definition at line 797 of file segmented_array.hpp.

operator!=() [11/12]

template<typename... Types>

bool neolib::operator!= ( variant< Types... > const &  lhs, none_t const &    )

inlinenoexcept

Definition at line 289 of file variant.hpp.

operator!=() [12/12]

template<typename... Types>

bool neolib::operator!= ( variant< Types... > const &  lhs, variant< Types... > const &  rhs  )

inlinenoexcept

Definition at line 301 of file variant.hpp.

operator+() [1/8]

template<class charT , class Traits , class Alloc >

basic_quick_string< charT, Traits, Alloc > neolib::operator+ ( const basic_quick_string< charT, Traits, Alloc > &  _Left, const basic_quick_string< charT, Traits, Alloc > &  _Right  )

inline

Definition at line 623 of file quick_string.hpp.

operator+() [2/8]

template<class charT , class Traits , class Alloc >

std::basic_string< charT, Traits, Alloc > neolib::operator+ ( const basic_quick_string< charT, Traits, Alloc > &  _Left, const charT *  _Right  )

inline

Definition at line 673 of file quick_string.hpp.

operator+() [3/8]

template<class charT , class Traits , class Alloc >

std::basic_string< charT, Traits, Alloc > neolib::operator+ ( const basic_quick_string< charT, Traits, Alloc > &  _Left, const charT  _Right  )

inline

Definition at line 683 of file quick_string.hpp.

operator+() [4/8]

template<class charT , class Traits , class Alloc >

std::basic_string< charT, Traits, Alloc > neolib::operator+ ( const basic_quick_string< charT, Traits, Alloc > &  _Left, const std::basic_string< charT, Traits, Alloc > &  _Right  )

inline

Definition at line 663 of file quick_string.hpp.

operator+() [5/8]

template<class charT , class Traits , class Alloc >

std::basic_string< charT, Traits, Alloc > neolib::operator+ ( const charT *  _Left, const basic_quick_string< charT, Traits, Alloc > &  _Right  )

inline

Definition at line 643 of file quick_string.hpp.

operator+() [6/8]

template<class charT , class Traits , class Alloc >

std::basic_string< charT, Traits, Alloc > neolib::operator+ ( const charT  _Left, const basic_quick_string< charT, Traits, Alloc > &  _Right  )

inline

Definition at line 653 of file quick_string.hpp.

operator+() [7/8]

template<class charT , class Traits , class Alloc >

std::basic_string< charT, Traits, Alloc > neolib::operator+ ( const std::basic_string< charT, Traits, Alloc > &  _Left, const basic_quick_string< charT, Traits, Alloc > &  _Right  )

inline

Definition at line 633 of file quick_string.hpp.

operator+() [8/8]

string neolib::operator+ ( const string &  lhs, const string &  rhs  )

inline

Definition at line 178 of file string.hpp.

operator+=() [1/2]

i_string & neolib::operator+= ( i_string &  lhs, const i_string &  rhs  )

inline

Definition at line 89 of file i_string.hpp.

operator+=() [2/2]

string & neolib::operator+= ( string &  lhs, const i_string &  rhs  )

inline

Definition at line 183 of file string.hpp.

operator<() [1/8]

bool neolib::operator< ( const ci_string &  s1, const std::string &  s2  )

inline

Definition at line 126 of file string_ci.hpp.

operator<() [2/8]

template<typename Enum >

std::enable_if_t< std::is_enum_v< Enum >, bool > neolib::operator< ( const i_basic_enum< std::underlying_type_t< Enum > > &  lhs, Enum  rhs  )

inline

Definition at line 238 of file i_enum.hpp.

operator<() [3/8]

template<typename Interface1 , typename Interface2 >

bool neolib::operator< ( const i_ref_ptr< Interface1 > &  lhs, const Interface2 *  rhs  )

inlinenoexcept

Definition at line 142 of file i_reference_counted.hpp.

operator<() [4/8]

template<typename Interface1 , typename Interface2 >

bool neolib::operator< ( const Interface2 *  lhs, const i_ref_ptr< Interface1 > &  rhs  )

inlinenoexcept

Definition at line 148 of file i_reference_counted.hpp.

operator<() [5/8]

bool neolib::operator< ( const std::string &  s1, const ci_string &  s2  )

inline

Definition at line 130 of file string_ci.hpp.

operator<() [6/8]

template<typename Enum >

std::enable_if_t< std::is_enum_v< Enum >, bool > neolib::operator< ( Enum  lhs, const i_basic_enum< std::underlying_type_t< Enum > > &  rhs  )

inline

Definition at line 238 of file i_enum.hpp.

operator<() [7/8]

template<typename Interface >

bool neolib::operator< ( ref_ptr< Interface > const &  lhs, ref_ptr< Interface > const &  rhs  )

inlinenoexcept

Definition at line 600 of file reference_counted.hpp.

operator<() [8/8]

template<typename... Types>

bool neolib::operator< ( variant< Types... > const &  lhs, variant< Types... > const &  rhs  )

inlinenoexcept

Definition at line 307 of file variant.hpp.

operator<<() [1/9]

template<typename Enum , typename Char , typename Traits , typename = std::enable_if_t<std::is_enum_v<Enum>, sfinae>>

std::basic_ostream< Char, Traits > & neolib::operator<< ( std::basic_ostream< Char, Traits > &  aOutput, const Enum &  aEnum  )

inline

Definition at line 127 of file i_enum.hpp.

operator<<() [2/9]

template<typename Elem , typename Traits , typename Alloc >

std::basic_ostream< Elem, Traits > & neolib::operator<< ( std::basic_ostream< Elem, Traits > &  aStream, const basic_quick_string< Elem, Traits, Alloc > &  aString  )

inline

Definition at line 683 of file quick_string.hpp.

operator<<() [3/9]

template<typename Elem , typename Traits >

std::basic_ostream< Elem, Traits > & neolib::operator<< ( std::basic_ostream< Elem, Traits > &  aStream, const uri &  aUri  )

inline

Definition at line 44 of file uri.hpp.

operator<<() [4/9]

template<typename Elem , typename Traits >

std::basic_ostream< Elem, Traits > & neolib::operator<< ( std::basic_ostream< Elem, Traits > &  aStream, const uri_authority &  aUriAuthority  )

inline

Definition at line 44 of file uri.hpp.

operator<<() [5/9]

template<typename Elem , typename Traits >

std::basic_ostream< Elem, Traits > & neolib::operator<< ( std::basic_ostream< Elem, Traits > &  aStream, const version &  aVersion  )

inline

Definition at line 1 of file version.hpp.

operator<<() [6/9]

template<typename Elem , typename Traits , typename T >

std::basic_ostream< Elem, Traits > & neolib::operator<< ( std::basic_ostream< Elem, Traits > &  aStream, optional< T > const &  aOptional  )

inline

Definition at line 320 of file optional.hpp.

operator<<() [7/9]

std::ostream & neolib::operator<< ( std::ostream &  aStream, const i_string &  aString  )

inline

Definition at line 111 of file i_string.hpp.

operator<<() [8/9]

std::ostream & neolib::operator<< ( std::ostream &  aStream, const i_version &  aVersion  )

inline

Definition at line 56 of file i_version.hpp.

operator<<() [9/9]

std::ostream & neolib::operator<< ( std::ostream &  aStream, const uuid &  aId  )

inline

Definition at line 87 of file uuid.hpp.

operator<=()

template<typename... Types>

bool neolib::operator<= ( variant< Types... > const &  lhs, variant< Types... > const &  rhs  )

inlinenoexcept

Definition at line 313 of file variant.hpp.

operator<=>() [1/14]

template<typename T >

std::partial_ordering neolib::operator<=> ( const abstract_t< optional< T > > &  lhs, const optional< T > &  rhs  )

inline

Definition at line 265 of file optional.hpp.

operator<=>() [2/14]

template<typename T , std::enable_if_t<!std::is_same_v< T, abstract_t< T > >, int > = 0>

std::partial_ordering neolib::operator<=> ( const abstract_t< T > &  lhs, const optional< T > &  rhs  )

inline

Definition at line 320 of file optional.hpp.

operator<=>() [3/14]

template<typename T , typename ConstIteratorType , typename IteratorType >

std::partial_ordering neolib::operator<=> ( const i_container< T, ConstIteratorType, IteratorType > &  lhs, const i_container< T, ConstIteratorType, IteratorType > &  rhs  )

inline

Definition at line 104 of file i_container.hpp.

operator<=>() [4/14]

template<typename T , typename U , typename = std::enable_if_t<!is_optional_v<U>, sfinae>>

std::partial_ordering neolib::operator<=> ( const i_optional< T > &  lhs, const U &  rhs  )

inline

Definition at line 136 of file i_optional.hpp.

operator<=>() [5/14]

std::strong_ordering neolib::operator<=> ( const i_string &  lhs, const i_string &  rhs  )

inlinenoexcept

Definition at line 84 of file i_string.hpp.

operator<=>() [6/14]

std::strong_ordering neolib::operator<=> ( const i_string &  lhs, const string &  rhs  )

inlinenoexcept

Definition at line 173 of file string.hpp.

operator<=>() [7/14]

template<typename T >

std::partial_ordering neolib::operator<=> ( const optional< T > &  lhs, const abstract_t< optional< T > > &  rhs  )

inline

Definition at line 253 of file optional.hpp.

operator<=>() [8/14]

template<typename T , std::enable_if_t<!std::is_same_v< T, abstract_t< T > >, int > = 0>

std::partial_ordering neolib::operator<=> ( const optional< T > &  lhs, const abstract_t< T > &  rhs  )

inline

Definition at line 311 of file optional.hpp.

operator<=>() [9/14]

template<typename T , typename U , typename = std::enable_if_t<!is_optional_v<U>, sfinae>>

std::partial_ordering neolib::operator<=> ( const optional< T > &  lhs, const U &  rhs  )

inline

Definition at line 293 of file optional.hpp.

operator<=>() [10/14]

std::strong_ordering neolib::operator<=> ( const string &  lhs, const i_string &  rhs  )

inlinenoexcept

Definition at line 163 of file string.hpp.

operator<=>() [11/14]

std::strong_ordering neolib::operator<=> ( const string &  lhs, const string &  rhs  )

inlinenoexcept

Definition at line 153 of file string.hpp.

operator<=>() [12/14]

template<typename T , typename U , typename = std::enable_if_t<!is_optional_v<U>, sfinae>>

std::partial_ordering neolib::operator<=> ( const U &  lhs, const i_optional< T > &  rhs  )

inline

Definition at line 144 of file i_optional.hpp.

operator<=>() [13/14]

template<typename T , typename U , typename = std::enable_if_t<!is_optional_v<U>, sfinae>>

std::partial_ordering neolib::operator<=> ( const U &  lhs, const optional< T > &  rhs  )

inline

Definition at line 302 of file optional.hpp.

operator<=>() [14/14]

template<typename... Types>

auto neolib::operator<=> ( variant< Types... > const &  lhs, variant< Types... > const &  rhs  )

inlinenoexcept

Definition at line 331 of file variant.hpp.

operator==() [1/23]

template<typename T >

bool neolib::operator== ( const abstract_t< optional< T > > &  lhs, const optional< T > &  rhs  )

inline

Definition at line 243 of file optional.hpp.

operator==() [2/23]

template<typename T , typename U , std::size_t SmallBufferSize>

bool neolib::operator== ( const basic_small_buffer_allocator< T, SmallBufferSize > &  , const basic_small_buffer_allocator< U, SmallBufferSize > &    )

inline

Definition at line 547 of file allocator.hpp.

operator==() [3/23]

bool neolib::operator== ( const ci_string &  s1, const std::string &  s2  )

inline

Definition at line 110 of file string_ci.hpp.

operator==() [4/23]

template<typename Enum >

std::enable_if_t< std::is_enum_v< Enum >, bool > neolib::operator== ( const i_basic_enum< std::underlying_type_t< Enum > > &  lhs, Enum  rhs  )

inline

Definition at line 220 of file i_enum.hpp.

operator==() [5/23]

template<typename T , typename ConstIteratorType , typename IteratorType >

bool neolib::operator== ( const i_container< T, ConstIteratorType, IteratorType > &  lhs, const i_container< T, ConstIteratorType, IteratorType > &  rhs  )

inline

Definition at line 98 of file i_container.hpp.

operator==() [6/23]

template<typename T , typename U , typename = std::enable_if_t<!is_optional_v<U>, sfinae>>

bool neolib::operator== ( const i_optional< T > &  lhs, const U &  rhs  )

inline

Definition at line 120 of file i_optional.hpp.

operator==() [7/23]

template<typename Interface1 , typename Interface2 >

bool neolib::operator== ( const i_ref_ptr< Interface1 > &  lhs, const Interface2 *  rhs  )

inlinenoexcept

Definition at line 118 of file i_reference_counted.hpp.

operator==() [8/23]

bool neolib::operator== ( const i_string &  lhs, const i_string &  rhs  )

inlinenoexcept

Definition at line 79 of file i_string.hpp.

operator==() [9/23]

bool neolib::operator== ( const i_string &  lhs, const string &  rhs  )

inlinenoexcept

Definition at line 168 of file string.hpp.

operator==() [10/23]

template<typename Interface1 , typename Interface2 >

bool neolib::operator== ( const Interface2 *  lhs, const i_ref_ptr< Interface1 > &  rhs  )

inlinenoexcept

Definition at line 124 of file i_reference_counted.hpp.

operator==() [11/23]

bool neolib::operator== ( const lexer_atom_match_any &  , const lexer_atom_match_any &    )

inline

Definition at line 53 of file lexer.hpp.

operator==() [12/23]

template<typename T >

bool neolib::operator== ( const optional< T > &  lhs, const abstract_t< optional< T > > &  rhs  )

inline

Definition at line 233 of file optional.hpp.

operator==() [13/23]

template<typename T , typename U , typename = std::enable_if_t<!is_optional_v<U>, sfinae>>

bool neolib::operator== ( const optional< T > &  lhs, const U &  rhs  )

inline

Definition at line 277 of file optional.hpp.

operator==() [14/23]

bool neolib::operator== ( const std::string &  s1, const ci_string &  s2  )

inline

Definition at line 114 of file string_ci.hpp.

operator==() [15/23]

bool neolib::operator== ( const string &  lhs, const i_string &  rhs  )

inlinenoexcept

Definition at line 158 of file string.hpp.

operator==() [16/23]

bool neolib::operator== ( const string &  lhs, const string &  rhs  )

inlinenoexcept

Definition at line 148 of file string.hpp.

operator==() [17/23]

template<typename T , typename U , typename = std::enable_if_t<!is_optional_v<U>, sfinae>>

bool neolib::operator== ( const U &  lhs, const i_optional< T > &  rhs  )

inline

Definition at line 128 of file i_optional.hpp.

operator==() [18/23]

template<typename T , typename U , typename = std::enable_if_t<!is_optional_v<U>, sfinae>>

bool neolib::operator== ( const U &  lhs, const optional< T > &  rhs  )

inline

Definition at line 285 of file optional.hpp.

operator==() [19/23]

template<typename Enum >

std::enable_if_t< std::is_enum_v< Enum >, bool > neolib::operator== ( Enum  lhs, const i_basic_enum< std::underlying_type_t< Enum > > &  rhs  )

inline

Definition at line 226 of file i_enum.hpp.

operator==() [20/23]

template<typename... Types>

bool neolib::operator== ( none_t const &  , variant< Types... > const &  rhs  )

inlinenoexcept

Definition at line 271 of file variant.hpp.

operator==() [21/23]

template<typename T , std::size_t SegmentSize, typename Alloc >

bool neolib::operator== ( segmented_array< T, SegmentSize, Alloc > const &  lhs, segmented_array< T, SegmentSize, Alloc > const &  rhs  )

inline

Definition at line 791 of file segmented_array.hpp.

operator==() [22/23]

template<typename... Types>

bool neolib::operator== ( variant< Types... > const &  lhs, none_t const &    )

inlinenoexcept

Definition at line 277 of file variant.hpp.

operator==() [23/23]

template<typename... Types>

bool neolib::operator== ( variant< Types... > const &  lhs, variant< Types... > const &  rhs  )

inlinenoexcept

Definition at line 295 of file variant.hpp.

operator>()

template<typename... Types>

bool neolib::operator> ( variant< Types... > const &  lhs, variant< Types... > const &  rhs  )

inlinenoexcept

Definition at line 319 of file variant.hpp.

operator>=()

template<typename... Types>

bool neolib::operator>= ( variant< Types... > const &  lhs, variant< Types... > const &  rhs  )

inlinenoexcept

Definition at line 325 of file variant.hpp.

operator>>() [1/4]

template<typename Enum , typename Char , typename Traits , typename = std::enable_if_t<std::is_enum_v<Enum>, sfinae>>

std::basic_istream< Char, Traits > & neolib::operator>> ( std::basic_istream< Char, Traits > &  aInput, Enum &  aEnum  )

inline

Definition at line 127 of file i_enum.hpp.

operator>>() [2/4]

template<typename Elem , typename Traits , typename T >

std::basic_istream< Elem, Traits > & neolib::operator>> ( std::basic_istream< Elem, Traits > &  aStream, optional< T > &  aOptional  )

inline

Definition at line 349 of file optional.hpp.

operator>>() [3/4]

std::istream & neolib::operator>> ( std::istream &  aStream, i_string &  aString  )

inline

Definition at line 117 of file i_string.hpp.

operator>>() [4/4]

std::istream & neolib::operator>> ( std::istream &  aStream, uuid &  aId  )

inline

Definition at line 79 of file uuid.hpp.

os_name()

NEOLIB_EXPORT std::string neolib::os_name

(

)

parallel_apply()

template<typename Container >

void neolib::parallel_apply ( thread_pool &  aThreadPool, Container &  aContainer, std::function< void(typename Container::value_type &aElement)>  aFunction, std::size_t  aMinimumParallelismCount = 0  )

inline

Definition at line 114 of file thread_pool.hpp.

parse_escapes()

std::string neolib::parse_escapes ( const std::string &  aString )

inline

Definition at line 376 of file string_utils.hpp.

parse_url_escapes()

std::string neolib::parse_url_escapes ( const std::string &  aString )

inline

Definition at line 389 of file string_utils.hpp.

program_directory()

NEOLIB_EXPORT std::string neolib::program_directory

(

)

program_file()

NEOLIB_EXPORT std::string neolib::program_file

(

)

reinterpret_pointer_cast() [1/4]

template<class T , class U >

ref_ptr< T > neolib::reinterpret_pointer_cast ( i_ref_ptr< U > &&  aOther )

noexcept

Definition at line 714 of file reference_counted.hpp.

reinterpret_pointer_cast() [2/4]

template<class T , class U >

ref_ptr< T > neolib::reinterpret_pointer_cast ( i_ref_ptr< U > const &  aOther )

noexcept

Definition at line 707 of file reference_counted.hpp.

reinterpret_pointer_cast() [3/4]

template<class T , class U >

ref_ptr< T > neolib::reinterpret_pointer_cast ( ref_ptr< U > &&  aOther )

noexcept

Definition at line 654 of file reference_counted.hpp.

reinterpret_pointer_cast() [4/4]

template<class T , class U >

ref_ptr< T > neolib::reinterpret_pointer_cast ( ref_ptr< U > const &  aOther )

noexcept

Definition at line 647 of file reference_counted.hpp.

remove_leading()

template<typename CharT , typename Traits , typename Alloc >

std::string & neolib::remove_leading ( std::basic_string< CharT, Traits, Alloc > &  aString, const std::basic_string< CharT, Traits, Alloc > &  aLeading  )

inline

Definition at line 302 of file string_utils.hpp.

remove_leading_and_trailing()

template<typename CharT , typename Traits , typename Alloc >

std::string & neolib::remove_leading_and_trailing ( std::basic_string< CharT, Traits, Alloc > &  aString, const std::basic_string< CharT, Traits, Alloc > &  aLeadingTrailing  )

inline

Definition at line 324 of file string_utils.hpp.

remove_trailing()

template<typename CharT , typename Traits , typename Alloc >

std::string & neolib::remove_trailing ( std::basic_string< CharT, Traits, Alloc > &  aString, const std::basic_string< CharT, Traits, Alloc > &  aTrailing  )

inline

Definition at line 313 of file string_utils.hpp.

replace_string() [1/4]

template<typename CharT , typename Traits , typename Alloc >

bool neolib::replace_string ( std::basic_string< CharT, Traits, Alloc > &  aString, const std::basic_string< CharT, Traits, Alloc > &  aSearch, const std::basic_string< CharT, Traits, Alloc > &  aReplace  )

inline

Definition at line 284 of file string_utils.hpp.

replace_string() [2/4]

template<typename CharT , typename Traits , typename Alloc >

bool neolib::replace_string ( std::basic_string< CharT, Traits, Alloc > &  aString, const std::basic_string< CharT, Traits, Alloc > &  aSearch, const std::basic_string< CharT, Traits, Alloc > &  aReplace, string_spans *  aSpans  )

inline

Definition at line 290 of file string_utils.hpp.

replace_string() [3/4]

template<typename CharT , typename Traits , typename Alloc >

bool neolib::replace_string ( std::basic_string< CharT, Traits, Alloc > &  aString, const std::basic_string< CharT, Traits, Alloc > &  aSearch, const std::basic_string< CharT, Traits, Alloc > &  aReplace, string_spans *  aSpans, const string_span::type *  aNewSpanType  )

inline

Definition at line 239 of file string_utils.hpp.

replace_string() [4/4]

template<typename CharT , typename Traits , typename Alloc >

bool neolib::replace_string ( std::basic_string< CharT, Traits, Alloc > &  aString, const std::basic_string< CharT, Traits, Alloc > &  aSearch, const std::basic_string< CharT, Traits, Alloc > &  aReplace, string_spans *  aSpans, string_span::type  aNewSpanType  )

inline

Definition at line 296 of file string_utils.hpp.

reverse_find_first_of()

template<typename CharT , typename Traits , typename Alloc >

std::basic_string< CharT, Traits, Alloc >::size_type neolib::reverse_find_first_of ( const std::basic_string< CharT, Traits, Alloc > &  aString, const std::basic_string< CharT, Traits, Alloc > &  aSequence, typename std::basic_string< CharT, Traits, Alloc >::size_type  aPosition  )

inline

Definition at line 359 of file string_utils.hpp.

reverse_find_last_of()

template<typename CharT , typename Traits , typename Alloc >

std::basic_string< CharT, Traits, Alloc >::size_type neolib::reverse_find_last_of ( const std::basic_string< CharT, Traits, Alloc > &  aString, const std::basic_string< CharT, Traits, Alloc > &  aSequence, typename std::basic_string< CharT, Traits, Alloc >::size_type  aPosition  )

inline

Definition at line 338 of file string_utils.hpp.

settings_folder()

std::string neolib::settings_folder	(	const std::string &	aApplicationName,
		const std::string &	aCompanyName
	)

simd_rand()

template<typename T >

T neolib::simd_rand ( T  aUpper )

inline

Definition at line 289 of file simd.hpp.

simd_srand()

void neolib::simd_srand ( std::thread::id  seed )

inline

Definition at line 209 of file simd.hpp.

static_numeric_variant_cast() [1/2]

template<typename T , typename Variant >

T neolib::static_numeric_variant_cast ( const Variant &  var )

inline

Definition at line 353 of file variant.hpp.

static_numeric_variant_cast() [2/2]

template<typename T , typename Variant >

T neolib::static_numeric_variant_cast ( Variant &  var )

inline

Definition at line 369 of file variant.hpp.

static_pointer_cast() [1/4]

template<class T , class U >

ref_ptr< T > neolib::static_pointer_cast ( i_ref_ptr< U > &&  aOther )

noexcept

Definition at line 686 of file reference_counted.hpp.

static_pointer_cast() [2/4]

template<class T , class U >

ref_ptr< T > neolib::static_pointer_cast ( i_ref_ptr< U > const &  aOther )

noexcept

Definition at line 679 of file reference_counted.hpp.

static_pointer_cast() [3/4]

template<class T , class U >

ref_ptr< T > neolib::static_pointer_cast ( ref_ptr< U > &&  aOther )

noexcept

Definition at line 626 of file reference_counted.hpp.

static_pointer_cast() [4/4]

template<class T , class U >

ref_ptr< T > neolib::static_pointer_cast ( ref_ptr< U > const &  aOther )

noexcept

Definition at line 619 of file reference_counted.hpp.

static_variant_cast() [1/2]

template<typename T , typename Variant >

auto & neolib::static_variant_cast ( const Variant &  var )

inline

Definition at line 338 of file variant.hpp.

static_variant_cast() [2/2]

template<typename T , typename Variant >

auto & neolib::static_variant_cast ( Variant &  var )

inline

Definition at line 345 of file variant.hpp.

string_to_double() [1/2]

template<typename CharT , typename Traits , typename Alloc >

double neolib::string_to_double ( const std::basic_string< CharT, Traits, Alloc > &  aString )

inline

Definition at line 161 of file string_numeric.hpp.

string_to_double() [2/2]

template<typename CharT , typename Traits >

double neolib::string_to_double ( const std::basic_string_view< CharT, Traits > &  aStringView )

inline

Definition at line 152 of file string_numeric.hpp.

string_to_enum() [1/2]

template<typename Enum >

Enum neolib::string_to_enum ( const i_string &  aEnumerator )

inline

Definition at line 97 of file i_enum.hpp.

string_to_enum() [2/2]

template<typename Enum >

Enum neolib::string_to_enum ( const std::string &  aEnumerator )

inline

Definition at line 106 of file i_enum.hpp.

string_to_int32() [1/2]

template<typename CharT , typename Traits , typename Alloc >

int32_t neolib::string_to_int32 ( const std::basic_string< CharT, Traits, Alloc > &  aString, int  aBase = 10  )

inline

Definition at line 57 of file string_numeric.hpp.

string_to_int32() [2/2]

template<typename CharT , typename Traits >

int32_t neolib::string_to_int32 ( const std::basic_string_view< CharT, Traits > &  aStringView )

inline

Definition at line 48 of file string_numeric.hpp.

string_to_int64() [1/2]

template<typename CharT , typename Traits , typename Alloc >

int64_t neolib::string_to_int64 ( const std::basic_string< CharT, Traits, Alloc > &  aString, int  aBase = 10  )

inline

Definition at line 74 of file string_numeric.hpp.

string_to_int64() [2/2]

template<typename CharT , typename Traits >

int64_t neolib::string_to_int64 ( const std::basic_string_view< CharT, Traits > &  aStringView )

inline

Definition at line 65 of file string_numeric.hpp.

string_to_number()

template<typename CharT , typename Traits >

number_t neolib::string_to_number ( const std::basic_string_view< CharT, Traits > &  aStringView )

inline

Definition at line 120 of file string_numeric.hpp.

string_to_uint32() [1/2]

template<typename CharT , typename Traits , typename Alloc >

uint32_t neolib::string_to_uint32 ( const std::basic_string< CharT, Traits, Alloc > &  aString, int  aBase = 10  )

inline

Definition at line 91 of file string_numeric.hpp.

string_to_uint32() [2/2]

template<typename CharT , typename Traits >

uint32_t neolib::string_to_uint32 ( const std::basic_string_view< CharT, Traits > &  aStringView )

inline

Definition at line 82 of file string_numeric.hpp.

string_to_uint64() [1/2]

template<typename CharT , typename Traits , typename Alloc >

uint64_t neolib::string_to_uint64 ( const std::basic_string< CharT, Traits, Alloc > &  aString, int  aBase = 10  )

inline

Definition at line 108 of file string_numeric.hpp.

string_to_uint64() [2/2]

template<typename CharT , typename Traits >

uint64_t neolib::string_to_uint64 ( const std::basic_string_view< CharT, Traits > &  aStringView )

inline

Definition at line 99 of file string_numeric.hpp.

swap()

void neolib::swap ( any &  aLhs, any &  aRhs  )

inline

Definition at line 261 of file any.hpp.

tidy_path() [1/2]

NEOLIB_EXPORT std::string neolib::tidy_path

(

std::string

aPath

)

tidy_path() [2/2]

NEOLIB_EXPORT std::wstring neolib::tidy_path

(

std::wstring

aPath

)

to_abstract() [1/4]

template<typename T1 , typename T2 >

const abstract_t< pair< T1, T2 > > & neolib::to_abstract ( const std::pair< T1, pair< T1, T2 > > &  aArgument )

inline

Definition at line 193 of file neolib.hpp.

to_abstract() [2/4]

template<typename T , typename = std::enable_if_t<detail::abstract_type<T>::value, sfinae>>

const abstract_t< T > & neolib::to_abstract ( const T &  aArgument )

inline

Definition at line 181 of file neolib.hpp.

to_abstract() [3/4]

template<typename T1 , typename T2 >

abstract_t< neolib::pair< T1, T2 > > & neolib::to_abstract ( std::pair< T1, pair< T1, T2 > > &  aArgument )

inline

Definition at line 199 of file neolib.hpp.

to_abstract() [4/4]

template<typename T , typename = std::enable_if_t<detail::abstract_type<T>::value, sfinae>>

abstract_t< T > & neolib::to_abstract ( T &  aArgument )

inline

Definition at line 187 of file neolib.hpp.

to_const()

template<typename T >

to_const_reference_t< T > neolib::to_const ( T &&  object )

inline

Definition at line 113 of file neolib.hpp.

to_lower() [1/2]

template<typename CharT >

CharT neolib::to_lower ( CharT  aCharacter )

inline

Definition at line 208 of file string_utils.hpp.

to_lower() [2/2]

template<typename CharT , typename Traits , typename Alloc >

std::basic_string< CharT, Traits, Alloc > neolib::to_lower ( const std::basic_string< CharT, Traits, Alloc > &  aString )

inline

Definition at line 200 of file string_utils.hpp.

to_protocol()

template<typename Protocol >

Protocol neolib::to_protocol ( protocol_family  aProtocolFamily )

inline

Definition at line 68 of file resolver.hpp.

to_protocol_family()

template<typename Protocol >

protocol_family neolib::to_protocol_family ( Protocol  aProtocol )

inline

Definition at line 59 of file resolver.hpp.

to_std_string()

template<typename T >

std::string neolib::to_std_string ( T const &  aValue )

inline

Definition at line 94 of file string_utils.hpp.

to_string() [1/5]

std::string neolib::to_string ( const i_version &  aVersion )

inline

Definition at line 66 of file i_version.hpp.

to_string() [2/5]

std::string neolib::to_string ( const std::pair< char const *, char const * > &  aIterPair )

inline

Definition at line 194 of file string_utils.hpp.

to_string() [3/5]

std::string neolib::to_string ( json_type  aType )

inline

Definition at line 109 of file json.hpp.

to_string() [4/5]

std::string neolib::to_string ( simple_variant const &  aVariant )

inline

Definition at line 73 of file simple_variant.hpp.

to_string() [5/5]

template<typename T >

string neolib::to_string ( T const &  aValue )

inline

Definition at line 112 of file string_utils.hpp.

to_upper() [1/2]

template<typename CharT >

CharT neolib::to_upper ( CharT  aCharacter )

inline

Definition at line 222 of file string_utils.hpp.

to_upper() [2/2]

template<typename CharT , typename Traits , typename Alloc >

std::basic_string< CharT, Traits, Alloc > neolib::to_upper ( const std::basic_string< CharT, Traits, Alloc > &  aString )

inline

Definition at line 214 of file string_utils.hpp.

tokens() [1/5]

template<typename CharT , typename Traits , typename Alloc , typename ResultContainer >

void neolib::tokens ( const std::basic_string< CharT, Traits, Alloc > &  aLine, const std::basic_string< CharT, Traits, Alloc > &  aDelimeter, ResultContainer &  aTokens, std::size_t  aMaxTokens = 0, bool  aSkipEmptyTokens = true, bool  aDelimeterIsSubsequence = false  )

inline

Definition at line 173 of file string_utils.hpp.

tokens() [2/5]

template<typename CharT , typename Traits , typename Alloc >

std::vector< std::basic_string< CharT, Traits, Alloc > > neolib::tokens ( const std::basic_string< CharT, Traits, Alloc > &  aLine, const std::basic_string< CharT, Traits, Alloc > &  aDelimeter, std::size_t  aMaxTokens = 0, bool  aSkipEmptyTokens = true, bool  aDelimeterIsSubsequence = false  )

inline

Definition at line 187 of file string_utils.hpp.

tokens() [3/5]

template<typename FwdIter , typename CharT , typename Traits , typename Alloc , typename ResultContainer >

void neolib::tokens ( FwdIter  aFirst, FwdIter  aLast, const std::basic_string< CharT, Traits, Alloc > &  aDelimeter, ResultContainer &  aTokens, std::size_t  aMaxTokens = 0, bool  aSkipEmptyTokens = true, bool  aDelimeterIsSubsequence = false  )

inline

Definition at line 167 of file string_utils.hpp.

tokens() [4/5]

template<typename FwdIter , typename CharT , typename Traits , typename Alloc >

std::vector< std::basic_string< CharT, Traits, Alloc > > neolib::tokens ( FwdIter  aFirst, FwdIter  aLast, const std::basic_string< CharT, Traits, Alloc > &  aDelimeter, std::size_t  aMaxTokens = 0, bool  aSkipEmptyTokens = true, bool  aDelimeterIsSubsequence = false  )

inline

Definition at line 179 of file string_utils.hpp.

tokens() [5/5]

template<typename FwdIter1 , typename FwdIter2 , typename ResultContainer >

FwdIter1 neolib::tokens ( FwdIter1  aFirst, FwdIter1  aLast, FwdIter2  aDelimeterFirst, FwdIter2  aDelimiterLast, ResultContainer &  aTokens, std::size_t  aMaxTokens = 0, bool  aSkipEmptyTokens = true, bool  aDelimeterIsSubsequence = false  )

inline

Definition at line 124 of file string_utils.hpp.

try_string_to_enum() [1/2]

template<typename Enum >

std::optional< Enum > neolib::try_string_to_enum ( const i_string &  aEnumerator )

inline

Definition at line 112 of file i_enum.hpp.

try_string_to_enum() [2/2]

template<typename Enum >

std::optional< Enum > neolib::try_string_to_enum ( const std::string &  aEnumerator )

inline

Definition at line 121 of file i_enum.hpp.

uint32_to_string()

template<typename CharT , typename Traits = std::char_traits<CharT>, typename Alloc = std::allocator<CharT>>

std::basic_string< CharT, Traits, Alloc > neolib::uint32_to_string ( uint32_t  aint32, int  aBase = 10, std::size_t  aWidth = 0, CharT  aFill = '0'  )

inline

Definition at line 204 of file string_numeric.hpp.

uint64_to_string()

template<typename CharT , typename Traits = std::char_traits<CharT>, typename Alloc = std::allocator<CharT>>

std::basic_string< CharT, Traits, Alloc > neolib::uint64_to_string ( uint64_t  aint32, int  aBase = 10, std::size_t  aWidth = 0, CharT  aFill = '0'  )

inline

Definition at line 219 of file string_numeric.hpp.

uninitialized_copy()

template<typename InIter , typename OutIter >

OutIter neolib::uninitialized_copy ( InIter  first, InIter  last, OutIter  result  )

inline

Definition at line 82 of file memory.hpp.

unsafe_any_cast() [1/4]

template<class T >

T neolib::unsafe_any_cast ( any &  operand )

inlinenoexcept

Definition at line 297 of file any.hpp.

unsafe_any_cast() [2/4]

template<class T >

T neolib::unsafe_any_cast ( const any &  operand )

inlinenoexcept

Definition at line 292 of file any.hpp.

unsafe_any_cast() [3/4]

template<class T >

T neolib::unsafe_any_cast ( const i_any &  operand )

inlinenoexcept

Definition at line 106 of file i_any.hpp.

unsafe_any_cast() [4/4]

template<class T >

T neolib::unsafe_any_cast ( i_any &  operand )

inlinenoexcept

Definition at line 111 of file i_any.hpp.

user_documents_directory()

NEOLIB_EXPORT std::string neolib::user_documents_directory

(

)

user_settings_directory()

NEOLIB_EXPORT std::string neolib::user_settings_directory

(

)

utf16_to_any()

template<typename StringT >

StringT neolib::utf16_to_any ( const std::u16string &  aString )

inline

Definition at line 443 of file string_utf.hpp.

utf16_to_any< std::u16string >()

template<>

std::u16string neolib::utf16_to_any< std::u16string > ( const std::u16string &  aString )

inline

Definition at line 449 of file string_utf.hpp.

utf16_to_narrow()

template<typename CharT , typename Traits , typename Alloc >

std::string neolib::utf16_to_narrow ( const std::basic_string< CharT, Traits, Alloc > &  aWideString )

inline

Definition at line 541 of file string_utf.hpp.

utf16_to_utf8() [1/5]

template<bool AllowUpper128>

std::string neolib::utf16_to_utf8 ( const std::u16string &  aString )

inline

Definition at line 197 of file string_utf.hpp.

utf16_to_utf8() [2/5]

std::string neolib::utf16_to_utf8 ( const std::u16string &  aString )

inline

Definition at line 208 of file string_utf.hpp.

utf16_to_utf8() [3/5]

template<bool AllowUpper128, typename CharacterMapUpdater >

std::string neolib::utf16_to_utf8 ( const std::u16string &  aString, CharacterMapUpdater  aCharacterMapUpdater  )

inline

Definition at line 152 of file string_utf.hpp.

utf16_to_utf8() [4/5]

template<bool AllowUpper128>

std::string neolib::utf16_to_utf8 ( const std::u16string &  aString, utf16_to_utf8_character_map &  aCharMap  )

inline

Definition at line 203 of file string_utf.hpp.

utf16_to_utf8() [5/5]

std::string neolib::utf16_to_utf8 ( const std::u16string &  aString, utf16_to_utf8_character_map &  aCharMap  )

inline

Definition at line 213 of file string_utf.hpp.

utf32_to_utf8()

std::string neolib::utf32_to_utf8 ( const std::u32string &  aString )

inline

Definition at line 388 of file string_utf.hpp.

utf8_to_any()

template<typename StringT >

StringT neolib::utf8_to_any ( const std::string &  aString, bool  aCodePageFallback = false  )

inline

Definition at line 455 of file string_utf.hpp.

utf8_to_any< std::string >()

template<>

std::string neolib::utf8_to_any< std::string > ( const std::string &  aString, bool    )

inline

Definition at line 461 of file string_utf.hpp.

utf8_to_utf16() [1/2]

std::u16string neolib::utf8_to_utf16 ( const std::string &  aString, bool  aCodePageFallback = false  )

inline

Definition at line 310 of file string_utf.hpp.

utf8_to_utf16() [2/2]

template<typename Callback >

std::u16string neolib::utf8_to_utf16 ( const std::string &  aString, Callback  aCallback, bool  aCodePageFallback = false  )

inline

Definition at line 260 of file string_utf.hpp.

utf8_to_utf32() [1/6]

std::u32string neolib::utf8_to_utf32 ( const std::string &  aString, bool  aCodePageFallback = false  )

inline

Definition at line 378 of file string_utf.hpp.

utf8_to_utf32() [2/6]

template<typename Callback >

std::u32string neolib::utf8_to_utf32 ( const std::string &  aString, Callback  aCallback, bool  aCodePageFallback = false  )

inline

Definition at line 368 of file string_utf.hpp.

utf8_to_utf32() [3/6]

std::u32string neolib::utf8_to_utf32 ( const std::string_view &  aStringView, bool  aCodePageFallback = false  )

inline

Definition at line 383 of file string_utf.hpp.

utf8_to_utf32() [4/6]

std::u32string neolib::utf8_to_utf32 ( std::string::const_iterator  aBegin, std::string::const_iterator  aEnd, bool  aCodePageFallback = false  )

inline

Definition at line 373 of file string_utf.hpp.

utf8_to_utf32() [5/6]

template<typename Callback >

std::u32string neolib::utf8_to_utf32 ( std::string::const_iterator  aBegin, std::string::const_iterator  aEnd, Callback  aCallback, bool  aCodePageFallback = false  )

inline

Todo:

use std::string_view ctor that takes iterators when LLVM libcxx fixes its C++20 non-conformance

Definition at line 359 of file string_utf.hpp.

utf8_to_utf32() [6/6]

template<typename Callback >

std::u32string neolib::utf8_to_utf32 ( std::string_view const &  aStringView, Callback  aCallback, bool  aCodePageFallback = false  )

inline

Definition at line 316 of file string_utf.hpp.

uuid_to_string()

std::string neolib::uuid_to_string ( const uuid &  aId )

inline

Definition at line 101 of file uuid.hpp.

variant_index_of()

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

constexpr std::size_t neolib::variant_index_of ( )

constexpr

Definition at line 383 of file variant.hpp.

wildcard_match() [1/2]

template<typename CharT , typename Traits , typename Alloc >

bool neolib::wildcard_match ( const std::basic_string< CharT, Traits, Alloc > &  aText, const std::basic_string< CharT, Traits, Alloc > &  aPattern  )

inline

Definition at line 457 of file string_utils.hpp.

wildcard_match() [2/2]

template<typename CharT , typename FwdIter >

bool neolib::wildcard_match ( FwdIter  aTextBegin, FwdIter  aTextEnd, FwdIter  aPatternBegin, FwdIter  aPatternEnd  )

inline

Definition at line 451 of file string_utils.hpp.

win32_get_last_error_as_string()

std::string neolib::win32_get_last_error_as_string

(

)

Variable Documentation

custom_type_name_v

template<typename T >

const std::string neolib::custom_type_name_v = T::type_name

Definition at line 118 of file custom_type.hpp.

index_of_v

template<typename T , typename... Ts>

constexpr std::size_t neolib::index_of_v = variadic_index<T, Ts...>::value

constexpr

Definition at line 128 of file neolib.hpp.

invalid

constexpr auto neolib::invalid = std::nullopt

inlineconstexpr

Definition at line 218 of file neolib.hpp.

INVALID_CHAR32

const unicode_char_t neolib::INVALID_CHAR32 = static_cast<unicode_char_t>(0xFFFD)

Definition at line 70 of file string_utf.hpp.

INVALID_CHAR8

const char neolib::INVALID_CHAR8 = '?'

Definition at line 69 of file string_utf.hpp.

invalid_cookie

template<class CookieType >

constexpr CookieType neolib::invalid_cookie = static_cast<CookieType>(~CookieType{})

constexpr

Definition at line 49 of file i_jar.hpp.

is_optional_v

template<typename T >

constexpr bool neolib::is_optional_v = is_optional<T>::value

constexpr

Definition at line 54 of file i_optional.hpp.

is_variant_convertible_v

template<typename AbstractT , typename Type >

constexpr bool neolib::is_variant_convertible_v = std::is_base_of_v<AbstractT, Type> && std::is_abstract_v<AbstractT>

constexpr

Definition at line 114 of file variant.hpp.

is_variant_v

template<typename T >

constexpr bool neolib::is_variant_v = is_variant<T>::value

constexpr

Definition at line 55 of file any.hpp.

none

const none_t neolib::none

Definition at line 111 of file variant.hpp.

setting_type_name_v

template<typename T >

const string neolib::setting_type_name_v = setting_type_name<T>::name()

Definition at line 113 of file i_setting_value.hpp.

setting_type_v

template<typename T , typename = sfinae>

constexpr setting_type neolib::setting_type_v = setting_type::Custom

constexpr

Definition at line 78 of file i_setting_value.hpp.

setting_type_v< bool >

template<>

constexpr setting_type neolib::setting_type_v< bool > = setting_type::Boolean

constexpr

Definition at line 79 of file i_setting_value.hpp.

setting_type_v< double >

template<>

constexpr setting_type neolib::setting_type_v< double > = setting_type::Float64

constexpr

Definition at line 89 of file i_setting_value.hpp.

setting_type_v< float >

template<>

constexpr setting_type neolib::setting_type_v< float > = setting_type::Float32

constexpr

Definition at line 88 of file i_setting_value.hpp.

setting_type_v< int16_t >

template<>

constexpr setting_type neolib::setting_type_v< int16_t > = setting_type::Int16

constexpr

Definition at line 81 of file i_setting_value.hpp.

setting_type_v< int32_t >

template<>

constexpr setting_type neolib::setting_type_v< int32_t > = setting_type::Int32

constexpr

Definition at line 82 of file i_setting_value.hpp.

setting_type_v< int64_t >

template<>

constexpr setting_type neolib::setting_type_v< int64_t > = setting_type::Int64

constexpr

Definition at line 83 of file i_setting_value.hpp.

setting_type_v< int8_t >

template<>

constexpr setting_type neolib::setting_type_v< int8_t > = setting_type::Int8

constexpr

Definition at line 80 of file i_setting_value.hpp.

setting_type_v< string >

template<>

constexpr setting_type neolib::setting_type_v< string > = setting_type::String

constexpr

Definition at line 90 of file i_setting_value.hpp.

setting_type_v< uint16_t >

template<>

constexpr setting_type neolib::setting_type_v< uint16_t > = setting_type::Uint16

constexpr

Definition at line 85 of file i_setting_value.hpp.

setting_type_v< uint32_t >

template<>

constexpr setting_type neolib::setting_type_v< uint32_t > = setting_type::Uint32

constexpr

Definition at line 86 of file i_setting_value.hpp.

setting_type_v< uint64_t >

template<>

constexpr setting_type neolib::setting_type_v< uint64_t > = setting_type::Uint64

constexpr

Definition at line 87 of file i_setting_value.hpp.

setting_type_v< uint8_t >

template<>

constexpr setting_type neolib::setting_type_v< uint8_t > = setting_type::Uint8

constexpr

Definition at line 84 of file i_setting_value.hpp.

vecarray_trivial_v

template<typename T >

bool constexpr neolib::vecarray_trivial_v = std::is_trivial_v<T>

constexpr

Definition at line 75 of file vecarray.hpp.