nstd 命名空间参考

命名空间
namespace	detail
namespace	placeholders
namespace	traits

类
struct	_argc_placeholder
class	_const_iterator
class	_const_reverse_iterator
struct	_container_increase_step
struct	_container_npos
class	_continuous_container
class	_delegator_storage
struct	_enum_converter
struct	_integral_constant
class	_iterator
struct	_iterator_type
class	_lock_guard
struct	_optional
struct	_optional_base
class	_reverse_iterator
class	_shared_ptr
class	_spinlock
class	_string
class	_unregister_delegator
struct	_weak_flag
class	_weak_ptr
struct	_weak_semantics_supporter
class	any
struct	argc_placeholders_base
class	atomic
class	bad_any_cast
struct	bind_t
struct	byte_endian_order
struct	conditional
struct	conditional< false, T1, T2 >
struct	default_context_t
struct	default_delete
struct	enable_if
struct	enable_if< true, T >
struct	function
struct	function< R(Args...)>
struct	handle_generator_impl
struct	int_sequence
struct	int_sequence_gen
struct	int_sequence_gen< 0, Ns... >
struct	int_sequence_gen< I, Ns... >
struct	is_bool
struct	is_bool< bool >
class	map
struct	memory
struct	numeric_double_limits
struct	pair
class	parallel_map
class	parallel_set
struct	remove_const
struct	remove_const< const T >
struct	remove_cr
struct	remove_reference
struct	remove_reference< T & >
struct	remove_reference< T && >
struct	result_traits
struct	result_traits< type< F > >
class	set
struct	tuple
struct	tuple< T, TArgs... >
struct	tuple<>
struct	tuple_at
struct	tuple_at< 0, tuple< T, TArgs... > >
struct	tuple_at< N, tuple< T, TArgs... > >
struct	tuple_valid_param_count
struct	type
struct	type_id_t

类型定义
typedef nstd::atomic< bool >	atomic_bool
typedef nstd::atomic< char >	atomic_char
typedef nstd::atomic< int8_t >	atomic_schar
typedef nstd::atomic< uint8_t >	atomic_uchar
typedef nstd::atomic< int16_t >	atomic_short
typedef nstd::atomic< uint16_t >	atomic_ushort
typedef nstd::atomic< int32_t >	atomic_int
typedef nstd::atomic< uint32_t >	atomic_uint
typedef nstd::atomic< int32_t >	atomic_long
typedef nstd::atomic< uint32_t >	atomic_ulong
typedef nstd::atomic< int64_t >	atomic_llong
typedef nstd::atomic< uint64_t >	atomic_ullong
typedef struct nstd::_weak_flag	weak_flag
typedef struct nstd::_weak_semantics_supporter	weak_semantics_supporter
template<class T >
using	is_std_function = traits::_is_std_function<T>
template<class... T>
using	has_std_function = traits::_has_std_function<T...>
template<class TElement , element_malloc_fun_t< TElement > _malloc = memory::safe_malloc_container_element<TElement>, element_delete_fun_t< TElement > _delete = memory::safe_delete_container_element<TElement>>
using	continuous_container = _continuous_container<TElement, _malloc, _delete>
template<class TElement , element_malloc_fun_t< TElement > _malloc = memory::safe_malloc_container_element<TElement>, element_delete_fun_t< TElement > _delete = memory::safe_delete_container_element<TElement>>
using	vector = continuous_container<TElement, _malloc, _delete>
using	unregister_delegate_t = nstd::function<void(void)>
	!thread safe
using	unregister_delegator_t = _unregister_delegator
template<typename t_delegator >
using	delegator_storage_t = _delegator_storage<t_delegator>
template<class TElement >
using	iterator_type = nstd::_iterator_type<TElement>
template<class TElement >
using	const_iterator = nstd::_const_iterator<TElement>
template<class TElement >
using	iterator = _iterator<TElement>
template<class TElement >
using	const_pointer = nstd::const_iterator<TElement>
template<class TElement >
using	pointer = nstd::iterator<TElement>
template<class TElement >
using	const_reverse_iterator = nstd::_const_reverse_iterator<TElement>
template<class TElement >
using	reverse_iterator = nstd::_reverse_iterator<TElement>
template<class K >
using	hash_default_hash = phmap::priv::hash_default_hash<K>
template<class K >
using	hash_default_eq = phmap::priv::hash_default_eq<K>
template<class K , class V >
using	Pair = phmap::priv::Pair<const K, V>
template<class K >
using	Allocator = phmap::priv::Allocator<K>
using	NullMutex = phmap::NullMutex
template<class TElement >
using	element_malloc_fun_t = TElement* (*)(std::size_t )
template<class TElement >
using	element_delete_fun_t = void (*)(TElement*&)
template<class T >
using	optional = _optional<T>
template<class T >
using	shared_ptr = nstd::_shared_ptr<T>
template<class T >
using	weak_ptr = nstd::_weak_ptr<T>
using	spinlock = _spinlock
using	lock_guard = _lock_guard
using	string = _string<>
using	handle_t = uint32_t
using	handle_generator = handle_generator_impl<default_context_t, def_max_handle_value::value, def_base_handle_value::value>
using	em_cove = _enum_converter
template<int32_t N>
using	sequence_t = typename int_sequence_gen<N>::type
template<typename T , T _value>
using	integral_constant = _integral_constant<T, _value>
template<bool _value>
using	bool_constant = integral_constant<bool, _value>
using	true_type = bool_constant<true>
using	false_type = bool_constant<false>
template<typename T >
using	is_standard_layout = std::is_standard_layout<T>
template<typename... T>
using	is_all_standard_layout = traits::_is_all_standard_layout<T...>
using	container_npos = _container_npos
using	container_increase_step = _container_increase_step
template<stateful_bool _value>
using	stateful_bool_constant = integral_constant<stateful_bool, _value>
using	stateful_bool_unused = stateful_bool_constant<stateful_bool::kUnused>
using	stateful_bool_true = stateful_bool_constant<stateful_bool::kTrue>
using	stateful_bool_false = stateful_bool_constant<stateful_bool::kFalse>

枚举
enum class	EM_Byte_Endian_Order { big_endian = 0 , little_endian = 1 }
enum class	stateful_bool : int32_t {   kBegin = -1 , kUnused = kBegin , kFalse = 0 , kTrue = 1 ,   kEnd }

函数
template<typename _ValueType >
_ValueType *	any_cast (any *operand)
template<typename _ValueType >
const _ValueType *	any_cast (const any *operand)
template<typename _ValueType >
_ValueType	any_cast (any &operand)
template<typename _ValueType >
_ValueType	any_cast (const any &operand)
template<typename _ValueType >
_ValueType *	UnsafeanyCast (any *operand)
template<typename _ValueType >
const _ValueType *	UnsafeanyCast (const any *operand)
template<typename R , typename C , typename... Args, typename... Params>
bind_t< R, C, R(C::*)(Args...), nstd::tuple< Params... > >	bind (R(C::*f)(Args...), C *obj, Params... params)
template<typename R , typename C , typename... Args, typename... Params>
bind_t< R, C, R(C::*)(Args...) const, nstd::tuple< Params... > >	bind (R(C::*f)(Args...) const, C *obj, Params... params)
template<class T , class... TArgs>
nstd::shared_ptr< T >	make_shared (TArgs &&... args)
template<class T1 , class T2 >
shared_ptr< T1 >	dynamic_pointer_cast (const shared_ptr< T2 > &other) noexcept
template<typename TEnum , typename TIntegral , typename nstd::enable_if< std::is_integral< TIntegral >::value, std::nullptr_t >::type = nullptr>
TEnum &	enum_cast (const TIntegral &_i_v)
template<typename TEnum >
int32_t &	enum_cast (TEnum &_e_v)
template<typename T , size_t N>
char(&	ArraySizeHelper (T(&array)[N]))[N]
template<uint32_t N, typename... TArgs>
const tuple_at< N, tuple< TArgs... > >::value_type &	tuple_get (const tuple< TArgs... > &tuple_)
template<uint32_t N, typename... TArgs>
tuple_at< N, tuple< TArgs... > >::value_type	tuple_get (tuple< TArgs... > &tuple_)
template<typename... Type>
tuple< Type... >	make_tuple (const Type &... args)
template<typename TTuple , uint32_t... Ns>
auto	extract_tuple (TTuple &tup) -> decltype(make_tuple(tuple_get< Ns >(tup)...))
template<uint32_t... Ns, typename... TArgs>
auto	extract_tuple (tuple< TArgs... > &tup) -> decltype(make_tuple(tuple_get< Ns >(tup)...))
template<class first_type , class second_type >
pair< first_type, second_type >	make_pair (const first_type &_first, const second_type &_second)

变量
constexpr std::nullopt_t	nullopt = std::nullopt

类型定义说明

Allocator

template<class K >

using nstd::Allocator = phmap::priv::Allocator<K>

atomic_bool

typedef nstd::atomic<bool> nstd::atomic_bool

atomic_char

typedef nstd::atomic<char> nstd::atomic_char

atomic_int

typedef nstd::atomic<int32_t> nstd::atomic_int

atomic_llong

typedef nstd::atomic<int64_t> nstd::atomic_llong

atomic_long

typedef nstd::atomic<int32_t> nstd::atomic_long

atomic_schar

typedef nstd::atomic<int8_t> nstd::atomic_schar

atomic_short

typedef nstd::atomic<int16_t> nstd::atomic_short

atomic_uchar

typedef nstd::atomic<uint8_t> nstd::atomic_uchar

atomic_uint

typedef nstd::atomic<uint32_t> nstd::atomic_uint

atomic_ullong

typedef nstd::atomic<uint64_t> nstd::atomic_ullong

atomic_ulong

typedef nstd::atomic<uint32_t> nstd::atomic_ulong

atomic_ushort

typedef nstd::atomic<uint16_t> nstd::atomic_ushort

bool_constant

template<bool _value>

using nstd::bool_constant = integral_constant<bool, _value>

const_iterator

template<class TElement >

using nstd::const_iterator = nstd::_const_iterator<TElement>

const_pointer

template<class TElement >

using nstd::const_pointer = nstd::const_iterator<TElement>

const_reverse_iterator

template<class TElement >

using nstd::const_reverse_iterator = nstd::_const_reverse_iterator<TElement>

container_increase_step

using nstd::container_increase_step = _container_increase_step

container_npos

using nstd::container_npos = _container_npos

continuous_container

template<class TElement , element_malloc_fun_t< TElement > _malloc = memory::safe_malloc_container_element<TElement>, element_delete_fun_t< TElement > _delete = memory::safe_delete_container_element<TElement>>

using nstd::continuous_container = _continuous_container<TElement, _malloc, _delete>

delegator_storage_t

template<typename t_delegator >

using nstd::delegator_storage_t = _delegator_storage<t_delegator>

element_delete_fun_t

template<class TElement >

using nstd::element_delete_fun_t = void (*)(TElement*&)

element_malloc_fun_t

template<class TElement >

using nstd::element_malloc_fun_t = TElement* (*)(std::size_t )

em_cove

using nstd::em_cove = _enum_converter

false_type

using nstd::false_type = bool_constant<false>

handle_generator

using nstd::handle_generator = handle_generator_impl<default_context_t, def_max_handle_value::value, def_base_handle_value::value>

handle_t

using nstd::handle_t = uint32_t

has_std_function

template<class... T>

using nstd::has_std_function = traits::_has_std_function<T...>

hash_default_eq

template<class K >

using nstd::hash_default_eq = phmap::priv::hash_default_eq<K>

hash_default_hash

template<class K >

using nstd::hash_default_hash = phmap::priv::hash_default_hash<K>

integral_constant

template<typename T , T _value>

using nstd::integral_constant = _integral_constant<T, _value>

is_all_standard_layout

template<typename... T>

using nstd::is_all_standard_layout = traits::_is_all_standard_layout<T...>

is_standard_layout

template<typename T >

using nstd::is_standard_layout = std::is_standard_layout<T>

is_std_function

template<class T >

using nstd::is_std_function = traits::_is_std_function<T>

iterator

template<class TElement >

using nstd::iterator = _iterator<TElement>

iterator_type

template<class TElement >

using nstd::iterator_type = nstd::_iterator_type<TElement>

lock_guard

using nstd::lock_guard = _lock_guard

NullMutex

typedef phmap::NullMutex nstd::NullMutex = phmap::NullMutex

optional

template<class T >

using nstd::optional = _optional<T>

Pair

template<class K , class V >

using nstd::Pair = phmap::priv::Pair<const K, V>

pointer

template<class TElement >

using nstd::pointer = nstd::iterator<TElement>

reverse_iterator

template<class TElement >

using nstd::reverse_iterator = nstd::_reverse_iterator<TElement>

sequence_t

template<int32_t N>

using nstd::sequence_t = typename int_sequence_gen<N>::type

shared_ptr

template<class T >

using nstd::shared_ptr = nstd::_shared_ptr<T>

spinlock

using nstd::spinlock = _spinlock

stateful_bool_constant

template<stateful_bool _value>

using nstd::stateful_bool_constant = integral_constant<stateful_bool, _value>

stateful_bool_false

using nstd::stateful_bool_false = stateful_bool_constant<stateful_bool::kFalse>

stateful_bool_true

using nstd::stateful_bool_true = stateful_bool_constant<stateful_bool::kTrue>

stateful_bool_unused

using nstd::stateful_bool_unused = stateful_bool_constant<stateful_bool::kUnused>

string

using nstd::string = _string<>

true_type

using nstd::true_type = bool_constant<true>

unregister_delegate_t

using nstd::unregister_delegate_t = nstd::function<void(void)>

!thread safe

unregister_delegator_t

using nstd::unregister_delegator_t = _unregister_delegator

vector

template<class TElement , element_malloc_fun_t< TElement > _malloc = memory::safe_malloc_container_element<TElement>, element_delete_fun_t< TElement > _delete = memory::safe_delete_container_element<TElement>>

using nstd::vector = continuous_container<TElement, _malloc, _delete>

weak_flag

typedef struct nstd::_weak_flag nstd::weak_flag

weak_ptr

template<class T >

using nstd::weak_ptr = nstd::_weak_ptr<T>

weak_semantics_supporter

typedef struct nstd::_weak_semantics_supporter nstd::weak_semantics_supporter

枚举类型说明

EM_Byte_Endian_Order

enum class nstd::EM_Byte_Endian_Order

strong

枚举值
big_endian
little_endian

stateful_bool

enum class nstd::stateful_bool : int32_t

strong

枚举值
kBegin
kUnused
kFalse
kTrue
kEnd

函数说明

any_cast() [1/4]

template<typename _ValueType >

_ValueType nstd::any_cast

(

any &

operand

)

any_cast() [2/4]

template<typename _ValueType >

_ValueType * nstd::any_cast

(

any *

operand

)

any_cast() [3/4]

template<typename _ValueType >

_ValueType nstd::any_cast ( const any & operand )

inline

any_cast() [4/4]

template<typename _ValueType >

const _ValueType * nstd::any_cast ( const any * operand )

inline

ArraySizeHelper()

template<typename T , size_t N>

char(& nstd::ArraySizeHelper

(

T(&)

array[N]

)

)[N]

bind() [1/2]

template<typename R , typename C , typename... Args, typename... Params>

bind_t< R, C, R(C::*)(Args...) const, nstd::tuple< Params... > > nstd::bind	(	R(C::*)(Args...) const	f,
		C *	obj,
		Params...	params )

bind() [2/2]

template<typename R , typename C , typename... Args, typename... Params>

bind_t< R, C, R(C::*)(Args...), nstd::tuple< Params... > > nstd::bind	(	R(C::*)(Args...)	f,
		C *	obj,
		Params...	params )

dynamic_pointer_cast()

template<class T1 , class T2 >

shared_ptr< T1 > nstd::dynamic_pointer_cast ( const shared_ptr< T2 > & other )

noexcept

enum_cast() [1/2]

template<typename TEnum , typename TIntegral , typename nstd::enable_if< std::is_integral< TIntegral >::value, std::nullptr_t >::type = nullptr>

TEnum & nstd::enum_cast

(

const TIntegral &

_i_v

)

enum_cast() [2/2]

template<typename TEnum >

int32_t & nstd::enum_cast

(

TEnum &

_e_v

)

extract_tuple() [1/2]

template<typename TTuple , uint32_t... Ns>

auto nstd::extract_tuple

(

TTuple &

tup

)

-> decltype(make_tuple(tuple_get<Ns>(tup)...))

extract_tuple() [2/2]

template<uint32_t... Ns, typename... TArgs>

auto nstd::extract_tuple

(

tuple< TArgs... > &

tup

)

-> decltype(make_tuple(tuple_get<Ns>(tup)...))

make_pair()

template<class first_type , class second_type >

pair< first_type, second_type > nstd::make_pair	(	const first_type &	_first,
		const second_type &	_second )

make_shared()

template<class T , class... TArgs>

nstd::shared_ptr< T > nstd::make_shared

(

TArgs &&...

args

)

make_tuple()

template<typename... Type>

tuple< Type... > nstd::make_tuple

(

const Type &...

args

)

tuple_get() [1/2]

template<uint32_t N, typename... TArgs>

const tuple_at< N, tuple< TArgs... > >::value_type & nstd::tuple_get

(

const tuple< TArgs... > &

tuple_

)

tuple_get() [2/2]

template<uint32_t N, typename... TArgs>

tuple_at< N, tuple< TArgs... > >::value_type nstd::tuple_get

(

tuple< TArgs... > &

tuple_

)

UnsafeanyCast() [1/2]

template<typename _ValueType >

_ValueType * nstd::UnsafeanyCast ( any * operand )

inline

UnsafeanyCast() [2/2]

template<typename _ValueType >

const _ValueType * nstd::UnsafeanyCast ( const any * operand )

inline

变量说明

nullopt

constexpr std::nullopt_t nstd::nullopt = std::nullopt

inlineconstexpr