Namespaces
	internal

Classes
class	basic_any
	An Any class represents a general type and is capable of storing any type. More...

struct	array_traits

class	basic_array_iterator
	Helper class for array iterators. More...

class	basic_array
	Lightweight c++11 array implementation. More...

class	basic_atomic_queue
	A basic lockfree atomic queue. More...

class	basic_light_map
	Lightweight c++11 dictionary map implementation. More...

class	basic_binary_queue_iterator

class	basic_binary_queue
	This queue can only hold one item. If sucessive push operations are called, that item is overwritten with whatever the last item was. More...

class	basic_deque_iterator

class	basic_deque
	A basic wrapper for the MiniLib deque's as Template deque. More...

class	basic_fixed_array
	A standard container for storing a fixed size sequence of elements. More...

class	basic_fixed_sorted_vector

struct	fixed_vector_storage

class	basic_fixed_vector

class	list_node_iterator

class	basic_list

class	basic_multimap
	A sorted associative container that may container multiple entries for each key. More...

class	basic_node_itarrator

class	basic_node_itarrator_res

class	basic_node

struct	basic_pair

class	basic_queue_iterator

class	basic_queue
	A basic wrapper for the MiniLib queue's as Template queue. More...

struct	rb_tree_node

class	base_rb_tree

class	basic_shared_list
	A simple list of shared_ptr items. More...

class	basic_sorted_vector

class	basic_stack

struct	basic_triple

class	basic_tuple

struct	basic_vector_storage

class	basic_vector

class	basic_ring_buffer_iterator
	ring_buffer_iterator More...

class	basic_ring_buffer
	A basic ring buffer with iterator. More...

Typedefs
template<typename T , class TAllocator = memory::default_allocator, class TDeleter = mn::memory::default_delete<T, TAllocator>>
using	array = basic_array< T, TAllocator, TDeleter >

template<class T , mn::size_t TMAXITEMS = 64>
using	atomic_queue = basic_atomic_queue< T, TMAXITEMS >

template<class TKey , class TValue >
using	map = basic_light_map< TKey, TValue >
	A standard map container for storing a fixed size pairs. More...

template<class T , mn::size_t TITEMSIZE = sizeof(T)>
using	biqueue = basic_binary_queue< T >

template<class T , mn::size_t TMAXITEMS, mn::size_t TITEMSIZE = sizeof(T)>
using	deque = basic_deque< T, TMAXITEMS, TITEMSIZE >

template<typename T , size_t N>
using	fixed_array = basic_fixed_array< T, N >

template<typename T , int TCapacity>
using	fixed_vector = basic_fixed_vector< T, TCapacity, mn::memory::default_allocator_t >

template<typename T , class TAllocator = memory::default_allocator, class TDeleter = memory::default_delete<T,TAllocator>>
using	list = basic_list< T, TAllocator, TDeleter >
	List type witch allocated in global heap. More...

template<typename TKEY , typename TVAL , class TAllocator >
using	multimap = basic_multimap< TKEY, TVAL, TAllocator >

template<typename T >
using	node = basic_node< T >
	Node type witch allocated in global heap. More...

template<typename TFIRST , typename TSECOND >
using	pair = basic_pair< TFIRST, TSECOND >

template<class T , mn::size_t TMAXITEMS, mn::size_t TITEMSIZE = sizeof(T)>
using	queue = basic_queue< T, TMAXITEMS, TITEMSIZE >

template<typename TKey , class TAllocator = memory::default_allocator>
using	rb_tree = base_rb_tree< internal::rb_tree_traits< TKey >, TAllocator >

template<typename T , typename TLockType = mn::mutex_t>
using	shared_ptr_list = basic_shared_list< T, TLockType >

template<typename TKey , typename TValue , class TCompare = mn::less<TKey>>
using	sorted_vector = basic_sorted_vector< TKey, TValue, mn::memory::default_allocator_t, TCompare >

using	stack_t = basic_stack< MN_THREAD_CONFIG_STACK_TYPE >

using	uint8_stack_t = basic_stack< uint8_t >

using	uint16_stack_t = basic_stack< uint16_t >

using	uint32_stack_t = basic_stack< uint32_t >

using	uint64_stack_t = basic_stack< uint64_t >

using	int8_stack_t = basic_stack< int8_t >

using	int16_stack_t = basic_stack< int16_t >

using	int32_stack_t = basic_stack< int32_t >

using	int64_stack_t = basic_stack< int64_t >

using	string_stack_t = basic_stack< const char * >

using	float_stack_t = basic_stack< float >

template<typename TFIRST , typename TSECOND , typename TTHIRD >
using	triple = basic_triple< TFIRST, TSECOND, TTHIRD >

template<size_t N, typename T >
using	tuple = basic_tuple

template<typename T , class TAllocator = mn::memory::default_allocator, class TStorage = basic_vector_storage<T, TAllocator>>
using	vector = basic_vector< T, mn::memory::default_allocator >

template<class T , size_t TCAPACITY = 100, typename TLOCK = LockType_t>
using	ringbuffer_t = basic_ring_buffer< T, TCAPACITY, TLOCK >

Enumerations
enum class	rb_tree_color { red , black }

Functions
void	swap (basic_any &x, basic_any &y) noexcept

template<class T , class ... Args>
basic_any	make_any (Args &&...args)

template<class T >
const T *	any_cast (const basic_any *other) noexcept

template<class T >
T *	any_cast (basic_any *other) noexcept

template<typename T , class TAllocator , class TDeleter >
bool	operator== (const basic_array< T, TAllocator, TDeleter > &a, const basic_array< T, TAllocator, TDeleter > &b)

template<typename T , class TAllocator , class TDeleter >
bool	operator!= (const basic_array< T, TAllocator, TDeleter > &a, const basic_array< T, TAllocator, TDeleter > &b)

template<typename T , class TAllocator , class TDeleter >
bool	operator< (const basic_array< T, TAllocator, TDeleter > &a, const basic_array< T, TAllocator, TDeleter > &b)

template<typename T , class TAllocator , class TDeleter >
bool	operator<= (const basic_array< T, TAllocator, TDeleter > &a, const basic_array< T, TAllocator, TDeleter > &b)

template<typename T , class TAllocator , class TDeleter >
bool	operator> (const basic_array< T, TAllocator, TDeleter > &a, const basic_array< T, TAllocator, TDeleter > &b)

template<typename T , class TAllocator , class TDeleter >
bool	operator>= (const basic_array< T, TAllocator, TDeleter > &a, const basic_array< T, TAllocator, TDeleter > &b)

template<typename T , class TAllocator , class TDeleter >
void	swap (basic_array< T, TAllocator, TDeleter > &a, basic_array< T, TAllocator, TDeleter > &b)

template<typename T , class TAllocator , class TDeleter >
void	fill (basic_array< T, TAllocator, TDeleter > &a, const int val)

template<typename T , class TAllocator , class TDeleter >
void	zero (basic_array< T, TAllocator, TDeleter > &a)

template<class T , mn::size_t TITEMSIZE>
void	swap (basic_binary_queue< T, TITEMSIZE > &a, basic_binary_queue< T, TITEMSIZE > &b)

template<class T , mn::size_t TMAXITEMS, mn::size_t TITEMSIZE>
void	swap (basic_deque< T, TMAXITEMS, TITEMSIZE > &a, basic_deque< T, TMAXITEMS, TITEMSIZE > &b)

template<typename T , size_t N>
bool	operator== (const basic_fixed_array< T, N > &a, const basic_fixed_array< T, N > &b)

template<typename T , size_t N>
bool	operator!= (const basic_fixed_array< T, N > &a, const basic_fixed_array< T, N > &b)

template<typename T , size_t N>
bool	operator< (const basic_fixed_array< T, N > &a, const basic_fixed_array< T, N > &b)

template<typename T , size_t N>
bool	operator<= (const basic_fixed_array< T, N > &a, const basic_fixed_array< T, N > &b)

template<typename T , size_t N>
bool	operator> (const basic_fixed_array< T, N > &a, const basic_fixed_array< T, N > &b)

template<typename T , size_t N>
bool	operator>= (const basic_fixed_array< T, N > &a, const basic_fixed_array< T, N > &b)

template<typename T , size_t N>
void	swap (basic_fixed_array< T, N > &a, basic_fixed_array< T, N > &b)

template<typename T , size_t N>
void	fill (basic_fixed_array< T, N > &a, const int val)

template<typename T , size_t N>
void	zero (basic_fixed_array< T, N > &a)

template<typename T >
void	swap (basic_node< T > &a, basic_node< T > &b)

template<typename TFIRST , typename TSECOND >
basic_pair< TFIRST, TSECOND >	make_pair (const TFIRST &a, const TSECOND &b)

template<typename ForwardIterator , typename TComp >
constexpr basic_pair< ForwardIterator, ForwardIterator >	equal_range (ForwardIterator first, ForwardIterator last, const TComp &value)

template<class T , mn::size_t TMAXITEMS, mn::size_t TITEMSIZE>
void	swap (basic_queue< T, TMAXITEMS, TITEMSIZE > &a, basic_queue< T, TMAXITEMS, TITEMSIZE > &b)

template<typename TVALUE >
void	swap (rb_tree_node< TVALUE > &a, rb_tree_node< TVALUE > &b)

template<typename TFIRST , typename TSECOND , typename TTHIRD >
triple< TFIRST, TSECOND, TTHIRD >	make_triple (const TFIRST &a, const TSECOND &b, const TTHIRD &c)

template<size_t N, typename T , typename U >
bool	operator== (const basic_basic_tuple< N, T > &a, const basic_basic_tuple< N, U > &b)

template<size_t N, typename T , typename U >
bool	operator!= (const basic_basic_tuple< N, T > &a, const basic_basic_tuple< N, U > &b)

template<size_t N, typename T , typename U >
bool	operator< (const basic_tuple< N, T > &a, const basic_tuple< N, U > &b)

template<size_t N, typename T , typename U >
bool	operator> (const basic_tuple< N, T > &a, const basic_tuple< N, U > &b)

template<size_t N, typename T , typename U >
bool	operator<= (const basic_tuple< N, T > &a, const basic_tuple< N, U > &b)

template<size_t N, typename T , typename U >
bool	operator>= (const basic_tuple< N, T > &a, const basic_tuple< N, U > &b)

template<size_t N, typename T , typename U >
basic_tuple< N, T > &	operator+= (basic_tuple< N, T > &a, const basic_tuple< N, U > &b)

template<size_t N, typename T , typename U >
basic_tuple< N, T > &	operator-= (basic_tuple< N, T > &a, const basic_tuple< N, U > &b)

template<size_t N, typename T , typename U >
basic_tuple< N, T > &	operator*= (basic_tuple< N, T > &a, const basic_tuple< N, U > &b)

template<size_t N, typename T , typename U >
basic_tuple< N, T > &	operator/= (basic_tuple< N, T > &a, const basic_tuple< N, U > &b)

template<size_t N, typename T , typename U >
basic_tuple< N, T >	operator+ (const basic_tuple< N, T > &a, const basic_tuple< N, U > &b)

template<size_t N, typename T , typename U >
basic_tuple< N, T >	operator- (const basic_tuple< N, T > &a, const basic_tuple< N, U > &b)

template<size_t N, typename T , typename U >
basic_tuple< N, T >	operator* (const basic_tuple< N, T > &a, const basic_tuple< N, U > &b)

template<size_t N, typename T , typename U >
basic_tuple< N, T >	operator/ (const basic_tuple< N, T > &a, const basic_tuple< N, U > &b)

template<typename T , class TAllocator = mn::memory::default_allocator, class TStorage = basic_vector_storage<T, TAllocator>>
void	swap (basic_vector< T, TAllocator, TStorage > &a, basic_vector< T, TAllocator, TStorage > &b)

template<typename T , int calc = 0, class TAllocator = mn::memory::default_allocator, class TStorage = basic_vector_storage<T, TAllocator>>
basic_vector< T, TAllocator, TStorage >	operator+ (const basic_vector< T, TAllocator, TStorage > &a, const basic_vector< T, TAllocator, TStorage > &b)

template<typename T , int calc = 0, class TAllocator = mn::memory::default_allocator, class TStorage = basic_vector_storage<T, TAllocator>>
basic_vector< T, TAllocator, TStorage >	operator+ (const basic_vector< T, TAllocator, TStorage > &a, const T &b)

template<typename T , int calc = 0, class TAllocator = mn::memory::default_allocator, class TStorage = basic_vector_storage<T, TAllocator>>
basic_vector< T, TAllocator, TStorage >	operator+ (const T &a, const basic_vector< T, TAllocator, TStorage > &b)

template<typename T , int calc = 0, class TAllocator = mn::memory::default_allocator, class TStorage = basic_vector_storage<T, TAllocator>>
basic_vector< T, TAllocator, TStorage >	operator- (const basic_vector< T, TAllocator, TStorage > &a, const basic_vector< T, TAllocator, TStorage > &b)

template<typename T , int calc = 0, class TAllocator = mn::memory::default_allocator, class TStorage = basic_vector_storage<T, TAllocator>>
basic_vector< T, TAllocator, TStorage >	operator- (const basic_vector< T, TAllocator, TStorage > &a)

template<typename T , int calc = 0, class TAllocator = mn::memory::default_allocator, class TStorage = basic_vector_storage<T, TAllocator>>
basic_vector< T, TAllocator, TStorage >	operator- (const basic_vector< T, TAllocator, TStorage > &a, const T &b)

template<typename T , int calc = 0, class TAllocator = mn::memory::default_allocator, class TStorage = basic_vector_storage<T, TAllocator>>
basic_vector< T, TAllocator, TStorage >	operator- (const T &a, const basic_vector< T, TAllocator, TStorage > &b)

template<typename T , int calc = 0, class TAllocator = mn::memory::default_allocator, class TStorage = basic_vector_storage<T, TAllocator>>
basic_vector< T, TAllocator, TStorage >	operator* (const basic_vector< T, TAllocator, TStorage > &a, const basic_vector< T, TAllocator, TStorage > &b)

template<typename T , int calc = 0, class TAllocator = mn::memory::default_allocator, class TStorage = basic_vector_storage<T, TAllocator>>
basic_vector< T, TAllocator, TStorage >	operator* (const basic_vector< T, TAllocator, TStorage > &a, const T &b)

template<typename T , int calc = 0, class TAllocator = mn::memory::default_allocator, class TStorage = basic_vector_storage<T, TAllocator>>
basic_vector< T, TAllocator, TStorage >	operator* (const T &a, const basic_vector< T, TAllocator, TStorage > &b)

template<typename T , int calc = 0, class TAllocator = mn::memory::default_allocator, class TStorage = basic_vector_storage<T, TAllocator>>
basic_vector< T, TAllocator, TStorage >	operator/ (const basic_vector< T, TAllocator, TStorage > &a, const basic_vector< T, TAllocator, TStorage > &b)

template<typename T , int calc = 0, class TAllocator = mn::memory::default_allocator, class TStorage = basic_vector_storage<T, TAllocator>>
basic_vector< T, TAllocator, TStorage >	operator/ (const basic_vector< T, TAllocator, TStorage > &a, const T &b)

template<typename T , int calc = 0, class TAllocator = mn::memory::default_allocator, class TStorage = basic_vector_storage<T, TAllocator>>
basic_vector< T, TAllocator, TStorage >	operator/ (const T &a, const basic_vector< T, TAllocator, TStorage > &b)

template<typename T , class TAllocator = mn::memory::default_allocator, class TStorage = basic_vector_storage<T, TAllocator>>
basic_vector< T, TAllocator, TStorage >	scale (const basic_vector< T, TAllocator, TStorage > &v, const T s)

Variables
template<class TTreeTraits , class TAllocator >
base_rb_tree< TTreeTraits, TAllocator >::node_type base_rb_tree< TTreeTraits, TAllocator >::ms_sentinel &	base_rb_tree

Typedef Documentation

◆ array

template<typename T , class TAllocator = memory::default_allocator, class TDeleter = mn::memory::default_delete<T, TAllocator>>

using mn::container::array = typedef basic_array<T, TAllocator, TDeleter>

◆ atomic_queue

template<class T , mn::size_t TMAXITEMS = 64>

using mn::container::atomic_queue = typedef basic_atomic_queue<T, TMAXITEMS>

◆ biqueue

template<class T , mn::size_t TITEMSIZE = sizeof(T)>

using mn::container::biqueue = typedef basic_binary_queue<T>

◆ deque

template<class T , mn::size_t TMAXITEMS, mn::size_t TITEMSIZE = sizeof(T)>

using mn::container::deque = typedef basic_deque<T, TMAXITEMS, TITEMSIZE>

◆ fixed_array

template<typename T , size_t N>

using mn::container::fixed_array = typedef basic_fixed_array<T, N>

◆ fixed_vector

template<typename T , int TCapacity>

using mn::container::fixed_vector = typedef basic_fixed_vector<T, TCapacity, mn::memory::default_allocator_t>

◆ float_stack_t

using mn::container::float_stack_t = typedef basic_stack<float>

◆ int16_stack_t

using mn::container::int16_stack_t = typedef basic_stack<int16_t>

◆ int32_stack_t

using mn::container::int32_stack_t = typedef basic_stack<int32_t>

◆ int64_stack_t

using mn::container::int64_stack_t = typedef basic_stack<int64_t>

◆ int8_stack_t

using mn::container::int8_stack_t = typedef basic_stack<int8_t>

◆ list

template<typename T , class TAllocator = memory::default_allocator, class TDeleter = memory::default_delete<T,TAllocator>>

using mn::container::list = typedef basic_list<T, TAllocator, TDeleter >

List type witch allocated in global heap.

Template Parameters

T	The holding type for the value
TAllocator	The using allocator

◆ map

template<class TKey , class TValue >

using mn::container::map = typedef basic_light_map< TKey, TValue >

A standard map container for storing a fixed size pairs.

Template Parameters

TKey	The type for the key.
TValue	The type for the value.
N	Number of elements.

◆ multimap

template<typename TKEY , typename TVAL , class TAllocator >

using mn::container::multimap = typedef basic_multimap<TKEY, TVAL, TAllocator>

◆ node

template<typename T >

using mn::container::node = typedef basic_node<T>

Node type witch allocated in global heap.

◆ pair

template<typename TFIRST , typename TSECOND >

using mn::container::pair = typedef basic_pair<TFIRST, TSECOND>

◆ queue

template<class T , mn::size_t TMAXITEMS, mn::size_t TITEMSIZE = sizeof(T)>

using mn::container::queue = typedef basic_queue<T, TMAXITEMS, TITEMSIZE>

Template Parameters

T	The type of an Item to queue
TMAXITEMS	Maximal items can queue
TITEMSIZE	A size of a item

◆ rb_tree

template<typename TKey , class TAllocator = memory::default_allocator>

using mn::container::rb_tree = typedef base_rb_tree<internal::rb_tree_traits<TKey>, TAllocator>

◆ ringbuffer_t

template<class T , size_t TCAPACITY = 100, typename TLOCK = LockType_t>

using mn::container::ringbuffer_t = typedef basic_ring_buffer<T, TCAPACITY, TLOCK>

◆ shared_ptr_list

template<typename T , typename TLockType = mn::mutex_t>

using mn::container::shared_ptr_list = typedef basic_shared_list<T, TLockType>

◆ sorted_vector

template<typename TKey , typename TValue , class TCompare = mn::less<TKey>>

using mn::container::sorted_vector = typedef basic_sorted_vector<TKey,TValue, mn::memory::default_allocator_t, TCompare>

◆ stack_t

using mn::container::stack_t = typedef basic_stack<MN_THREAD_CONFIG_STACK_TYPE>

◆ string_stack_t

using mn::container::string_stack_t = typedef basic_stack<const char*>

◆ triple

template<typename TFIRST , typename TSECOND , typename TTHIRD >

using mn::container::triple = typedef basic_triple<TFIRST, TSECOND, TTHIRD>

◆ tuple

template<size_t N, typename T >

using mn::container::tuple = typedef basic_tuple

◆ uint16_stack_t

using mn::container::uint16_stack_t = typedef basic_stack<uint16_t>

◆ uint32_stack_t

using mn::container::uint32_stack_t = typedef basic_stack<uint32_t>

◆ uint64_stack_t

using mn::container::uint64_stack_t = typedef basic_stack<uint64_t>

◆ uint8_stack_t

using mn::container::uint8_stack_t = typedef basic_stack<uint8_t>

◆ vector

template<typename T , class TAllocator = mn::memory::default_allocator, class TStorage = basic_vector_storage<T, TAllocator>>

using mn::container::vector = typedef basic_vector<T, mn::memory::default_allocator>

Enumeration Type Documentation

◆ rb_tree_color

enum mn::container::rb_tree_color

strong

Enumerator
red
black

Function Documentation

◆ any_cast() [1/2]

template<class T >

T* mn::container::any_cast ( basic_any * other )

inlinenoexcept

◆ any_cast() [2/2]

template<class T >

const T* mn::container::any_cast ( const basic_any * other )

inlinenoexcept

◆ equal_range()

template<typename ForwardIterator , typename TComp >

constexpr basic_pair<ForwardIterator,ForwardIterator> mn::container::equal_range	(	ForwardIterator	first,
		ForwardIterator	last,
		const TComp &	value
	)

inlineconstexpr

◆ fill() [1/2]

template<typename T , class TAllocator , class TDeleter >

void mn::container::fill	(	basic_array< T, TAllocator, TDeleter > &	a,
		const int	val
	)

inline

◆ fill() [2/2]

template<typename T , size_t N>

void mn::container::fill	(	basic_fixed_array< T, N > &	a,
		const int	val
	)

inline

◆ make_any()

template<class T , class ... Args>

basic_any mn::container::make_any ( Args &&... args )

inline

◆ make_pair()

template<typename TFIRST , typename TSECOND >

basic_pair<TFIRST, TSECOND> mn::container::make_pair	(	const TFIRST &	a,
		const TSECOND &	b
	)

◆ make_triple()

template<typename TFIRST , typename TSECOND , typename TTHIRD >

triple<TFIRST, TSECOND, TTHIRD> mn::container::make_triple	(	const TFIRST &	a,
		const TSECOND &	b,
		const TTHIRD &	c
	)

◆ operator!=() [1/3]

template<typename T , class TAllocator , class TDeleter >

bool mn::container::operator!=	(	const basic_array< T, TAllocator, TDeleter > &	a,
		const basic_array< T, TAllocator, TDeleter > &	b
	)

inline

◆ operator!=() [2/3]

template<size_t N, typename T , typename U >

bool mn::container::operator!=	(	const basic_basic_tuple< N, T > &	a,
		const basic_basic_tuple< N, U > &	b
	)

inline

◆ operator!=() [3/3]

template<typename T , size_t N>

bool mn::container::operator!=	(	const basic_fixed_array< T, N > &	a,
		const basic_fixed_array< T, N > &	b
	)

inline

◆ operator*() [1/4]

template<size_t N, typename T , typename U >

basic_tuple<N,T> mn::container::operator*	(	const basic_tuple< N, T > &	a,
		const basic_tuple< N, U > &	b
	)

inline

◆ operator*() [2/4]

template<typename T , int calc = 0, class TAllocator = mn::memory::default_allocator, class TStorage = basic_vector_storage<T, TAllocator>>

basic_vector<T, TAllocator, TStorage> mn::container::operator*	(	const basic_vector< T, TAllocator, TStorage > &	a,
		const basic_vector< T, TAllocator, TStorage > &	b
	)

inline

◆ operator*() [3/4]

template<typename T , int calc = 0, class TAllocator = mn::memory::default_allocator, class TStorage = basic_vector_storage<T, TAllocator>>

basic_vector<T, TAllocator, TStorage> mn::container::operator*	(	const basic_vector< T, TAllocator, TStorage > &	a,
		const T &	b
	)

inline

◆ operator*() [4/4]

template<typename T , int calc = 0, class TAllocator = mn::memory::default_allocator, class TStorage = basic_vector_storage<T, TAllocator>>

basic_vector<T, TAllocator, TStorage> mn::container::operator*	(	const T &	a,
		const basic_vector< T, TAllocator, TStorage > &	b
	)

inline

◆ operator*=()

template<size_t N, typename T , typename U >

basic_tuple<N,T>& mn::container::operator*=	(	basic_tuple< N, T > &	a,
		const basic_tuple< N, U > &	b
	)

inline

◆ operator+() [1/4]

template<size_t N, typename T , typename U >

basic_tuple<N,T> mn::container::operator+	(	const basic_tuple< N, T > &	a,
		const basic_tuple< N, U > &	b
	)

inline

◆ operator+() [2/4]

template<typename T , int calc = 0, class TAllocator = mn::memory::default_allocator, class TStorage = basic_vector_storage<T, TAllocator>>

basic_vector<T, TAllocator, TStorage> mn::container::operator+	(	const basic_vector< T, TAllocator, TStorage > &	a,
		const basic_vector< T, TAllocator, TStorage > &	b
	)

inline

◆ operator+() [3/4]

template<typename T , int calc = 0, class TAllocator = mn::memory::default_allocator, class TStorage = basic_vector_storage<T, TAllocator>>

basic_vector<T, TAllocator, TStorage> mn::container::operator+	(	const basic_vector< T, TAllocator, TStorage > &	a,
		const T &	b
	)

inline

◆ operator+() [4/4]

template<typename T , int calc = 0, class TAllocator = mn::memory::default_allocator, class TStorage = basic_vector_storage<T, TAllocator>>

basic_vector<T, TAllocator, TStorage> mn::container::operator+	(	const T &	a,
		const basic_vector< T, TAllocator, TStorage > &	b
	)

inline

◆ operator+=()

template<size_t N, typename T , typename U >

basic_tuple<N,T>& mn::container::operator+=	(	basic_tuple< N, T > &	a,
		const basic_tuple< N, U > &	b
	)

inline

◆ operator-() [1/5]

template<size_t N, typename T , typename U >

basic_tuple<N,T> mn::container::operator-	(	const basic_tuple< N, T > &	a,
		const basic_tuple< N, U > &	b
	)

inline

◆ operator-() [2/5]

template<typename T , int calc = 0, class TAllocator = mn::memory::default_allocator, class TStorage = basic_vector_storage<T, TAllocator>>

basic_vector<T, TAllocator, TStorage> mn::container::operator- ( const basic_vector< T, TAllocator, TStorage > & a )

inline

◆ operator-() [3/5]

template<typename T , int calc = 0, class TAllocator = mn::memory::default_allocator, class TStorage = basic_vector_storage<T, TAllocator>>

basic_vector<T, TAllocator, TStorage> mn::container::operator-	(	const basic_vector< T, TAllocator, TStorage > &	a,
		const basic_vector< T, TAllocator, TStorage > &	b
	)

inline

◆ operator-() [4/5]

template<typename T , int calc = 0, class TAllocator = mn::memory::default_allocator, class TStorage = basic_vector_storage<T, TAllocator>>

basic_vector<T, TAllocator, TStorage> mn::container::operator-	(	const basic_vector< T, TAllocator, TStorage > &	a,
		const T &	b
	)

inline

◆ operator-() [5/5]

template<typename T , int calc = 0, class TAllocator = mn::memory::default_allocator, class TStorage = basic_vector_storage<T, TAllocator>>

basic_vector<T, TAllocator, TStorage> mn::container::operator-	(	const T &	a,
		const basic_vector< T, TAllocator, TStorage > &	b
	)

inline

◆ operator-=()

template<size_t N, typename T , typename U >

basic_tuple<N,T>& mn::container::operator-=	(	basic_tuple< N, T > &	a,
		const basic_tuple< N, U > &	b
	)

inline

◆ operator/() [1/4]

template<size_t N, typename T , typename U >

basic_tuple<N,T> mn::container::operator/	(	const basic_tuple< N, T > &	a,
		const basic_tuple< N, U > &	b
	)

inline

◆ operator/() [2/4]

template<typename T , int calc = 0, class TAllocator = mn::memory::default_allocator, class TStorage = basic_vector_storage<T, TAllocator>>

basic_vector<T, TAllocator, TStorage> mn::container::operator/	(	const basic_vector< T, TAllocator, TStorage > &	a,
		const basic_vector< T, TAllocator, TStorage > &	b
	)

inline

◆ operator/() [3/4]

template<typename T , int calc = 0, class TAllocator = mn::memory::default_allocator, class TStorage = basic_vector_storage<T, TAllocator>>

basic_vector<T, TAllocator, TStorage> mn::container::operator/	(	const basic_vector< T, TAllocator, TStorage > &	a,
		const T &	b
	)

inline

◆ operator/() [4/4]

template<typename T , int calc = 0, class TAllocator = mn::memory::default_allocator, class TStorage = basic_vector_storage<T, TAllocator>>

basic_vector<T, TAllocator, TStorage> mn::container::operator/	(	const T &	a,
		const basic_vector< T, TAllocator, TStorage > &	b
	)

inline

◆ operator/=()

template<size_t N, typename T , typename U >

basic_tuple<N,T>& mn::container::operator/=	(	basic_tuple< N, T > &	a,
		const basic_tuple< N, U > &	b
	)

inline

◆ operator<() [1/3]

template<typename T , class TAllocator , class TDeleter >

bool mn::container::operator<	(	const basic_array< T, TAllocator, TDeleter > &	a,
		const basic_array< T, TAllocator, TDeleter > &	b
	)

inline

◆ operator<() [2/3]

template<typename T , size_t N>

bool mn::container::operator<	(	const basic_fixed_array< T, N > &	a,
		const basic_fixed_array< T, N > &	b
	)

inline

◆ operator<() [3/3]

template<size_t N, typename T , typename U >

bool mn::container::operator<	(	const basic_tuple< N, T > &	a,
		const basic_tuple< N, U > &	b
	)

inline

◆ operator<=() [1/3]

template<typename T , class TAllocator , class TDeleter >

bool mn::container::operator<=	(	const basic_array< T, TAllocator, TDeleter > &	a,
		const basic_array< T, TAllocator, TDeleter > &	b
	)

inline

◆ operator<=() [2/3]

template<typename T , size_t N>

bool mn::container::operator<=	(	const basic_fixed_array< T, N > &	a,
		const basic_fixed_array< T, N > &	b
	)

inline

◆ operator<=() [3/3]

template<size_t N, typename T , typename U >

bool mn::container::operator<=	(	const basic_tuple< N, T > &	a,
		const basic_tuple< N, U > &	b
	)

inline

◆ operator==() [1/3]

template<typename T , class TAllocator , class TDeleter >

bool mn::container::operator==	(	const basic_array< T, TAllocator, TDeleter > &	a,
		const basic_array< T, TAllocator, TDeleter > &	b
	)

inline

◆ operator==() [2/3]

template<size_t N, typename T , typename U >

bool mn::container::operator==	(	const basic_basic_tuple< N, T > &	a,
		const basic_basic_tuple< N, U > &	b
	)

inline

◆ operator==() [3/3]

template<typename T , size_t N>

bool mn::container::operator==	(	const basic_fixed_array< T, N > &	a,
		const basic_fixed_array< T, N > &	b
	)

inline

◆ operator>() [1/3]

template<typename T , class TAllocator , class TDeleter >

bool mn::container::operator>	(	const basic_array< T, TAllocator, TDeleter > &	a,
		const basic_array< T, TAllocator, TDeleter > &	b
	)

inline

◆ operator>() [2/3]

template<typename T , size_t N>

bool mn::container::operator>	(	const basic_fixed_array< T, N > &	a,
		const basic_fixed_array< T, N > &	b
	)

inline

◆ operator>() [3/3]

template<size_t N, typename T , typename U >

bool mn::container::operator>	(	const basic_tuple< N, T > &	a,
		const basic_tuple< N, U > &	b
	)

inline

◆ operator>=() [1/3]

template<typename T , class TAllocator , class TDeleter >

bool mn::container::operator>=	(	const basic_array< T, TAllocator, TDeleter > &	a,
		const basic_array< T, TAllocator, TDeleter > &	b
	)

inline

◆ operator>=() [2/3]

template<typename T , size_t N>

bool mn::container::operator>=	(	const basic_fixed_array< T, N > &	a,
		const basic_fixed_array< T, N > &	b
	)

inline

◆ operator>=() [3/3]

template<size_t N, typename T , typename U >

bool mn::container::operator>=	(	const basic_tuple< N, T > &	a,
		const basic_tuple< N, U > &	b
	)

inline

◆ scale()

template<typename T , class TAllocator = mn::memory::default_allocator, class TStorage = basic_vector_storage<T, TAllocator>>

basic_vector<T, TAllocator, TStorage> mn::container::scale	(	const basic_vector< T, TAllocator, TStorage > &	v,
		const T	s
	)

inline

◆ swap() [1/9]

void mn::container::swap	(	basic_any &	x,
		basic_any &	y
	)

inlinenoexcept

◆ swap() [2/9]

template<typename T , class TAllocator , class TDeleter >

void mn::container::swap	(	basic_array< T, TAllocator, TDeleter > &	a,
		basic_array< T, TAllocator, TDeleter > &	b
	)

inline

◆ swap() [3/9]

template<class T , mn::size_t TITEMSIZE>

void mn::container::swap	(	basic_binary_queue< T, TITEMSIZE > &	a,
		basic_binary_queue< T, TITEMSIZE > &	b
	)

◆ swap() [4/9]

template<class T , mn::size_t TMAXITEMS, mn::size_t TITEMSIZE>

void mn::container::swap	(	basic_deque< T, TMAXITEMS, TITEMSIZE > &	a,
		basic_deque< T, TMAXITEMS, TITEMSIZE > &	b
	)

◆ swap() [5/9]

template<typename T , size_t N>

void mn::container::swap	(	basic_fixed_array< T, N > &	a,
		basic_fixed_array< T, N > &	b
	)

inline

◆ swap() [6/9]

template<typename T >

void mn::container::swap	(	basic_node< T > &	a,
		basic_node< T > &	b
	)

inline

◆ swap() [7/9]

template<class T , mn::size_t TMAXITEMS, mn::size_t TITEMSIZE>

void mn::container::swap	(	basic_queue< T, TMAXITEMS, TITEMSIZE > &	a,
		basic_queue< T, TMAXITEMS, TITEMSIZE > &	b
	)

◆ swap() [8/9]

template<typename T , class TAllocator = mn::memory::default_allocator, class TStorage = basic_vector_storage<T, TAllocator>>

void mn::container::swap	(	basic_vector< T, TAllocator, TStorage > &	a,
		basic_vector< T, TAllocator, TStorage > &	b
	)

◆ swap() [9/9]

template<typename TVALUE >

void mn::container::swap	(	rb_tree_node< TVALUE > &	a,
		rb_tree_node< TVALUE > &	b
	)

◆ zero() [1/2]

template<typename T , class TAllocator , class TDeleter >

void mn::container::zero ( basic_array< T, TAllocator, TDeleter > & a )

inline

◆ zero() [2/2]

template<typename T , size_t N>

void mn::container::zero ( basic_fixed_array< T, N > & a )

inline

Variable Documentation

◆ base_rb_tree

template<class TTreeTraits , class TAllocator >

base_rb_tree<TTreeTraits, TAllocator>::node_type base_rb_tree<TTreeTraits, TAllocator>::ms_sentinel & mn::container::base_rb_tree

Namespaces

Classes

Typedefs

Enumerations

Functions

Variables

Typedef Documentation

◆ array

◆ atomic_queue

◆ biqueue

◆ deque

◆ fixed_array

◆ fixed_vector

◆ float_stack_t

◆ int16_stack_t

◆ int32_stack_t

◆ int64_stack_t

◆ int8_stack_t

◆ list

◆ map

◆ multimap

◆ node

◆ pair

◆ queue

◆ rb_tree

◆ ringbuffer_t

◆ shared_ptr_list

◆ sorted_vector

◆ stack_t

◆ string_stack_t

◆ triple

◆ tuple

◆ uint16_stack_t

◆ uint32_stack_t

◆ uint64_stack_t

◆ uint8_stack_t

◆ vector

Enumeration Type Documentation

◆ rb_tree_color

Function Documentation

◆ any_cast() [1/2]

◆ any_cast() [2/2]

◆ equal_range()

◆ fill() [1/2]

◆ fill() [2/2]

◆ make_any()

◆ make_pair()

◆ make_triple()

◆ operator!=() [1/3]

◆ operator!=() [2/3]

◆ operator!=() [3/3]

◆ operator*() [1/4]

◆ operator*() [2/4]

◆ operator*() [3/4]

◆ operator*() [4/4]

◆ operator*=()

◆ operator+() [1/4]

◆ operator+() [2/4]

◆ operator+() [3/4]

◆ operator+() [4/4]

◆ operator+=()

◆ operator-() [1/5]

◆ operator-() [2/5]

◆ operator-() [3/5]

◆ operator-() [4/5]

◆ operator-() [5/5]

◆ operator-=()

◆ operator/() [1/4]

◆ operator/() [2/4]

◆ operator/() [3/4]

◆ operator/() [4/4]

◆ operator/=()

◆ operator<() [1/3]

◆ operator<() [2/3]

◆ operator<() [3/3]

◆ operator<=() [1/3]

◆ operator<=() [2/3]

◆ operator<=() [3/3]

◆ operator==() [1/3]

◆ operator==() [2/3]