#include <mn_sorted_vector.hpp>

Inheritance diagram for mn::container::basic_sorted_vector< TKey, TValue, TAllocator, TCompare, TStorage >:

Collaboration diagram for mn::container::basic_sorted_vector< TKey, TValue, TAllocator, TCompare, TStorage >:

Public Types
using	key_type = TKey

using	mapped_type = TValue

using	size_type = typename base_type::size_type

using	value_type = typename base_type::value_type

using	pointer = typename base_type::pointer

using	reference = typename base_type::reference

using	iterator = typename base_type::iterator

using	const_iterator = typename base_type::const_iterator

using	allocator_type = typename base_type::allocator_type

using	compare_type = internal::compare_func< value_type, TCompare >

using	pair_type = basic_pair< iterator, bool >

Public Member Functions
	basic_sorted_vector (const allocator_type &allocator=allocator_type())

template<class InputIterator >
	basic_sorted_vector (InputIterator first, InputIterator last, const allocator_type &allocator=allocator_type())

	basic_sorted_vector (const basic_sorted_vector &)=delete

basic_sorted_vector &	operator= (const basic_sorted_vector &)=delete

pair_type	insert (const value_type &val)

pair_type	insert (const key_type &k, const mapped_type &v)

iterator	find (const key_type &k)

const_iterator	find (const key_type &k) const

iterator	erase (iterator it)

size_type	erase (const key_type &k)

iterator	lower_bound (const key_type &k)

const_iterator	lower_bound (const key_type &k) const

iterator	upper_bound (const key_type &k)

const_iterator	upper_bound (const key_type &k) const

iterator	begin ()

iterator	end ()

size_type	size () const

bool	empty () const

size_type	capacity ()

void	clear ()

const allocator_type &	get_allocator () const

void	set_allocator (const allocator_type &allocator)

Private Types
using	base_type = basic_vector< basic_pair< TKey, TValue >, TAllocator, TStorage >

Private Types inherited from mn::container::basic_vector< basic_pair< TKey, TValue >, TAllocator, basic_vector_storage< basic_pair< TKey, TValue >, TAllocator > >
using	iterator_category = random_access_iterator_tag

using	value_type = basic_pair< TKey, TValue >

using	pointer = basic_pair< TKey, TValue > *

using	reference = basic_pair< TKey, TValue > &

using	lreference = basic_pair< TKey, TValue > &&

using	const_reference = const basic_pair< TKey, TValue > &

using	difference_type = mn::ptrdiff_t

using	iterator = pointer

using	const_iterator = const pointer

using	allocator_type = TAllocator

using	size_type = mn::size_t

Private Member Functions
bool	invariant () const

Private Member Functions inherited from mn::container::basic_vector< basic_pair< TKey, TValue >, TAllocator, basic_vector_storage< basic_pair< TKey, TValue >, TAllocator > >
	basic_vector (const allocator_type &allocator=allocator_type())

	basic_vector (size_type initialSize, const allocator_type &allocator=allocator_type())

	basic_vector (const_iterator first, const_iterator last, const allocator_type &allocator=allocator_type())

	basic_vector (const basic_vector &rhs, const allocator_type &allocator=allocator_type())

	~basic_vector ()

void	copy (const basic_vector &rhs)

iterator	begin ()

iterator	end ()

size_type	size () const

bool	empty () const

size_type	capacity ()

pointer	data ()

reference	front ()

const reference	cfront ()

reference	back ()

const reference	cback ()

reference	at (size_type i)

const reference	const_at (size_type i)

void	push_back (const_reference v)

void	push_back (lreference v)

void	push_back ()

void	pop_back ()

void	assign (const pointer first, const pointer last)

void	insert (size_type index, size_type n, const reference val)

void	insert (iterator it, size_type n, const reference val)

iterator	insert (iterator it, const_reference val)

iterator	erase (iterator it)

iterator	erase (iterator first, iterator last)

void	resize (size_type n)

void	reserve (size_type n)

void	clear ()

void	reset ()

void	set_capacity (size_type newCapacity)

size_type	index_of (const reference item, size_type index=0) const

iterator	find (const reference item)

const allocator_type &	get_allocator () const

void	set_allocator (const allocator_type &allocator)

bool	validate_iterator (const_iterator it) const

basic_vector &	operator= (const basic_vector &rhs)

reference	operator[] (size_type i)

const reference	operator[] (size_type i) const

Private Attributes
compare_type	m_compare

Additional Inherited Members
Static Private Attributes inherited from mn::container::basic_vector< basic_pair< TKey, TValue >, TAllocator, basic_vector_storage< basic_pair< TKey, TValue >, TAllocator > >
static const size_type	npos

static const size_type	kInitialCapacity