Google OR-Tools: gtl::linked_hash_map< Key, Value, KeyHash, KeyEq, Alloc

template<typename Key, typename Value, typename KeyHash = typename absl::flat_hash_set<Key>::hasher, typename KeyEq = typename absl::flat_hash_set<Key, KeyHash>::key_equal, typename Alloc = std::allocator<std::pair<const Key, Value>>>
class gtl::linked_hash_map< Key, Value, KeyHash, KeyEq, Alloc >

Definition at line 52 of file linked_hash_map.h.

#include <linked_hash_map.h>

Public Types
using	key_type = Key
using	mapped_type = Value
using	hasher = KeyHash
using	key_equal = KeyEq
using	value_type = std::pair<const key_type, mapped_type>
using	allocator_type = Alloc
using	difference_type = ptrdiff_t
using	iterator = typename ListType::iterator
using	const_iterator = typename ListType::const_iterator
using	reverse_iterator = typename ListType::reverse_iterator
using	const_reverse_iterator = typename ListType::const_reverse_iterator
using	reference = typename ListType::reference
using	const_reference = typename ListType::const_reference
using	size_type = typename ListType::size_type
using	pointer = typename std::allocator_traits<allocator_type>::pointer
using	const_pointer
using	node_type = NodeHandle
using	insert_return_type = InsertReturnType<iterator, node_type>

Public Member Functions
	linked_hash_map ()=default
	linked_hash_map (size_t bucket_count, const hasher &hash=hasher(), const key_equal &eq=key_equal(), const allocator_type &alloc=allocator_type())
	linked_hash_map (size_t bucket_count, const hasher &hash, const allocator_type &alloc)
	linked_hash_map (size_t bucket_count, const allocator_type &alloc)
	linked_hash_map (const allocator_type &alloc)
template<class InputIt>
	linked_hash_map (InputIt first, InputIt last, size_t bucket_count=0, const hasher &hash=hasher(), const key_equal &eq=key_equal(), const allocator_type &alloc=allocator_type())
template<class InputIt>
	linked_hash_map (InputIt first, InputIt last, size_t bucket_count, const hasher &hash, const allocator_type &alloc)
template<class InputIt>
	linked_hash_map (InputIt first, InputIt last, size_t bucket_count, const allocator_type &alloc)
template<class InputIt>
	linked_hash_map (InputIt first, InputIt last, const allocator_type &alloc)
	linked_hash_map (std::initializer_list< value_type > init, size_t bucket_count=0, const hasher &hash=hasher(), const key_equal &eq=key_equal(), const allocator_type &alloc=allocator_type())
	linked_hash_map (std::initializer_list< value_type > init, size_t bucket_count, const hasher &hash, const allocator_type &alloc)
	linked_hash_map (std::initializer_list< value_type > init, size_t bucket_count, const allocator_type &alloc)
	linked_hash_map (std::initializer_list< value_type > init, const allocator_type &alloc)
	linked_hash_map (const linked_hash_map &other)
	linked_hash_map (const linked_hash_map &other, const allocator_type &alloc)
	linked_hash_map (linked_hash_map &&other) noexcept
	linked_hash_map (linked_hash_map &&other, const allocator_type &alloc)
linked_hash_map &	operator= (const linked_hash_map &other)
linked_hash_map &	operator= (linked_hash_map &&other) noexcept
linked_hash_map &	operator= (std::initializer_list< value_type > values)
size_type	size () const
size_type	max_size () const noexcept
bool	empty () const
iterator	begin ()
iterator	end ()
const_iterator	begin () const
const_iterator	end () const
const_iterator	cbegin () const
const_iterator	cend () const
reverse_iterator	rbegin ()
reverse_iterator	rend ()
const_reverse_iterator	rbegin () const
const_reverse_iterator	rend () const
const_reverse_iterator	crbegin () const
const_reverse_iterator	crend () const
reference	front ()
reference	back ()
const_reference	front () const
const_reference	back () const
void	pop_front ()
void	pop_back ()
ABSL_ATTRIBUTE_REINITIALIZES void	clear ()
void	reserve (size_t n)
size_t	capacity () const
size_t	bucket_count () const
float	load_factor () const
hasher	hash_function () const
key_equal	key_eq () const
allocator_type	get_allocator () const
template<class K = key_type>
size_type	erase (const key_arg< K > &key)
iterator	erase (const_iterator position)
iterator	erase (iterator position)
iterator	erase (iterator first, iterator last)
iterator	erase (const_iterator first, const_iterator last)
template<class K = key_type>
iterator	find (const key_arg< K > &key)
template<class K = key_type>
const_iterator	find (const key_arg< K > &key) const
template<class K = key_type>
size_type	count (const key_arg< K > &key) const
template<class K = key_type>
bool	contains (const key_arg< K > &key) const
template<class K = key_type>
mapped_type &	at (const key_arg< K > &key)
template<class K = key_type>
const mapped_type &	at (const key_arg< K > &key) const
template<class K = key_type>
std::pair< iterator, iterator >	equal_range (const key_arg< K > &key)
template<class K = key_type>
std::pair< const_iterator, const_iterator >	equal_range (const key_arg< K > &key) const
template<class K = key_type>
mapped_type &	operator[] (const key_arg< K > &key)
template<class K = key_type, K * = nullptr>
mapped_type &	operator[] (key_arg< K > &&key)
std::pair< iterator, bool >	insert (const value_type &v)
std::pair< iterator, bool >	insert (value_type &&v)
iterator	insert (const_iterator, const value_type &v)
iterator	insert (const_iterator, value_type &&v)
void	insert (std::initializer_list< value_type > ilist)
template<class InputIt>
void	insert (InputIt first, InputIt last)
insert_return_type	insert (node_type &&node)
iterator	insert (const_iterator, node_type &&node)
template<class K = key_type, class V = mapped_type, K * = nullptr, V * = nullptr>
std::pair< iterator, bool >	insert_or_assign (key_arg< K > &&k, V &&v)
template<class K = key_type, class V = mapped_type, K * = nullptr>
std::pair< iterator, bool >	insert_or_assign (key_arg< K > &&k, const V &v)
template<class K = key_type, class V = mapped_type, V * = nullptr>
std::pair< iterator, bool >	insert_or_assign (const key_arg< K > &k, V &&v)
template<class K = key_type, class V = mapped_type>
std::pair< iterator, bool >	insert_or_assign (const key_arg< K > &k, const V &v)
template<class K = key_type, class V = mapped_type, K * = nullptr, V * = nullptr>
iterator	insert_or_assign (const_iterator, key_arg< K > &&k, V &&v)
template<class K = key_type, class V = mapped_type, K * = nullptr>
iterator	insert_or_assign (const_iterator, key_arg< K > &&k, const V &v)
template<class K = key_type, class V = mapped_type, V * = nullptr>
iterator	insert_or_assign (const_iterator, const key_arg< K > &k, V &&v)
template<class K = key_type, class V = mapped_type>
iterator	insert_or_assign (const_iterator, const key_arg< K > &k, const V &v)
template<typename... Args>
std::pair< iterator, bool >	emplace (Args &&... args)
template<class K = key_type, class... Args, K * = nullptr>
iterator	try_emplace (const_iterator, key_arg< K > &&k, Args &&... args)
template<typename... Args>
iterator	emplace_hint (const_iterator, Args &&... args)
template<class K = key_type, typename... Args, K * = nullptr>
std::pair< iterator, bool >	try_emplace (key_arg< K > &&key, Args &&... args)
template<typename H, typename E>
void	merge (linked_hash_map< Key, Value, H, E, Alloc > &src)
template<typename H, typename E>
void	merge (linked_hash_map< Key, Value, H, E, Alloc > &&src)
node_type	extract (const_iterator position)
template<class K = key_type, std::enable_if_t<!std::is_same_v< K, iterator >, int > = 0>
node_type	extract (const key_arg< K > &key)
template<class K = key_type, typename... Args>
std::pair< iterator, bool >	try_emplace (const key_arg< K > &key, Args &&... args)
void	swap (linked_hash_map &other)
void	rehash (size_t n)

Friends
bool	operator== (const linked_hash_map &a, const linked_hash_map &b)
bool	operator!= (const linked_hash_map &a, const linked_hash_map &b)

◆ allocator_type

◆ const_iterator

using gtl::linked_hash_map< Key, Value, KeyHash, KeyEq, Alloc >::const_iterator = typename ListType::const_iterator

◆ const_pointer

Initial value:

typename std::allocator_traits<allocator_type>::const_pointer

Definition at line 148 of file linked_hash_map.h.

◆ const_reference

using gtl::linked_hash_map< Key, Value, KeyHash, KeyEq, Alloc >::const_reference = typename ListType::const_reference

◆ const_reverse_iterator

using gtl::linked_hash_map< Key, Value, KeyHash, KeyEq, Alloc >::const_reverse_iterator = typename ListType::const_reverse_iterator

◆ difference_type

◆ hasher

◆ insert_return_type

◆ iterator

using gtl::linked_hash_map< Key, Value, KeyHash, KeyEq, Alloc >::iterator = typename ListType::iterator

◆ key_equal

◆ key_type

◆ mapped_type

◆ node_type

◆ pointer

using gtl::linked_hash_map< Key, Value, KeyHash, KeyEq, Alloc >::pointer = typename std::allocator_traits<allocator_type>::pointer

◆ reference

using gtl::linked_hash_map< Key, Value, KeyHash, KeyEq, Alloc >::reference = typename ListType::reference

◆ reverse_iterator

using gtl::linked_hash_map< Key, Value, KeyHash, KeyEq, Alloc >::reverse_iterator = typename ListType::reverse_iterator

◆ size_type

using gtl::linked_hash_map< Key, Value, KeyHash, KeyEq, Alloc >::size_type = typename ListType::size_type

◆ value_type

◆ linked_hash_map() [2/17]

gtl::linked_hash_map< Key, Value, KeyHash, KeyEq, Alloc >::linked_hash_map	(	size_t	bucket_count,
		const hasher &	hash = hasher(),
		const key_equal &	eq = key_equal(),
		const allocator_type &	alloc = allocator_type() )

inlineexplicit

◆ linked_hash_map() [3/17]

gtl::linked_hash_map< Key, Value, KeyHash, KeyEq, Alloc >::linked_hash_map	(	size_t	bucket_count,
		const hasher &	hash,
		const allocator_type &	alloc )

inline

◆ linked_hash_map() [4/17]

gtl::linked_hash_map< Key, Value, KeyHash, KeyEq, Alloc >::linked_hash_map	(	size_t	bucket_count,
		const allocator_type &	alloc )

inline

◆ linked_hash_map() [5/17]

gtl::linked_hash_map< Key, Value, KeyHash, KeyEq, Alloc >::linked_hash_map

(

const allocator_type &

alloc

)

inlineexplicit

◆ linked_hash_map() [6/17]

template<class InputIt>

gtl::linked_hash_map< Key, Value, KeyHash, KeyEq, Alloc >::linked_hash_map	(	InputIt	first,
		InputIt	last,
		size_t	bucket_count = 0,
		const hasher &	hash = hasher(),
		const key_equal &	eq = key_equal(),
		const allocator_type &	alloc = allocator_type() )

inline

◆ linked_hash_map() [7/17]

template<class InputIt>

gtl::linked_hash_map< Key, Value, KeyHash, KeyEq, Alloc >::linked_hash_map	(	InputIt	first,
		InputIt	last,
		size_t	bucket_count,
		const hasher &	hash,
		const allocator_type &	alloc )

inline

◆ linked_hash_map() [8/17]

template<class InputIt>

gtl::linked_hash_map< Key, Value, KeyHash, KeyEq, Alloc >::linked_hash_map	(	InputIt	first,
		InputIt	last,
		size_t	bucket_count,
		const allocator_type &	alloc )

inline

◆ linked_hash_map() [9/17]

template<class InputIt>

gtl::linked_hash_map< Key, Value, KeyHash, KeyEq, Alloc >::linked_hash_map	(	InputIt	first,
		InputIt	last,
		const allocator_type &	alloc )

inline

◆ linked_hash_map() [10/17]

gtl::linked_hash_map< Key, Value, KeyHash, KeyEq, Alloc >::linked_hash_map	(	std::initializer_list< value_type >	init,
		size_t	bucket_count = 0,
		const hasher &	hash = hasher(),
		const key_equal &	eq = key_equal(),
		const allocator_type &	alloc = allocator_type() )

inline

◆ linked_hash_map() [11/17]

gtl::linked_hash_map< Key, Value, KeyHash, KeyEq, Alloc >::linked_hash_map	(	std::initializer_list< value_type >	init,
		size_t	bucket_count,
		const hasher &	hash,
		const allocator_type &	alloc )

inline

◆ linked_hash_map() [12/17]

gtl::linked_hash_map< Key, Value, KeyHash, KeyEq, Alloc >::linked_hash_map	(	std::initializer_list< value_type >	init,
		size_t	bucket_count,
		const allocator_type &	alloc )

inline

◆ linked_hash_map() [13/17]

gtl::linked_hash_map< Key, Value, KeyHash, KeyEq, Alloc >::linked_hash_map	(	std::initializer_list< value_type >	init,
		const allocator_type &	alloc )

inline

◆ linked_hash_map() [14/17]

gtl::linked_hash_map< Key, Value, KeyHash, KeyEq, Alloc >::linked_hash_map

(

const linked_hash_map< Key, Value, KeyHash, KeyEq, Alloc > &

other

)

inline

◆ linked_hash_map() [15/17]

gtl::linked_hash_map< Key, Value, KeyHash, KeyEq, Alloc >::linked_hash_map	(	const linked_hash_map< Key, Value, KeyHash, KeyEq, Alloc > &	other,
		const allocator_type &	alloc )

inline

◆ linked_hash_map() [16/17]

gtl::linked_hash_map< Key, Value, KeyHash, KeyEq, Alloc >::linked_hash_map

(

linked_hash_map< Key, Value, KeyHash, KeyEq, Alloc > &&

other

)

inlinenoexcept

◆ linked_hash_map() [17/17]

gtl::linked_hash_map< Key, Value, KeyHash, KeyEq, Alloc >::linked_hash_map	(	linked_hash_map< Key, Value, KeyHash, KeyEq, Alloc > &&	other,
		const allocator_type &	alloc )

inline

◆ at() [1/2]

template<class K = key_type>

◆ at() [2/2]

template<class K = key_type>

const mapped_type & gtl::linked_hash_map< Key, Value, KeyHash, KeyEq, Alloc >::at

(

const key_arg< K > &

key

)

const

inline

◆ back() [1/2]

◆ back() [2/2]

◆ begin() [1/2]

◆ begin() [2/2]

◆ bucket_count()

◆ capacity()

◆ cbegin()

◆ cend()

◆ clear()

ABSL_ATTRIBUTE_REINITIALIZES void gtl::linked_hash_map< Key, Value, KeyHash, KeyEq, Alloc >::clear

(

)

inline

◆ contains()

template<class K = key_type>

bool gtl::linked_hash_map< Key, Value, KeyHash, KeyEq, Alloc >::contains

(

const key_arg< K > &

key

)

const

inline

◆ count()

template<class K = key_type>

size_type gtl::linked_hash_map< Key, Value, KeyHash, KeyEq, Alloc >::count

(

const key_arg< K > &

key

)

const

inline

◆ crbegin()

◆ crend()

◆ emplace()

template<typename... Args>

std::pair< iterator, bool > gtl::linked_hash_map< Key, Value, KeyHash, KeyEq, Alloc >::emplace

(

Args &&...

args

)

inline

◆ emplace_hint()

template<typename... Args>

◆ empty()

◆ end() [1/2]

◆ end() [2/2]

◆ equal_range() [1/2]

template<class K = key_type>

std::pair< iterator, iterator > gtl::linked_hash_map< Key, Value, KeyHash, KeyEq, Alloc >::equal_range

(

const key_arg< K > &

key

)

inline

◆ equal_range() [2/2]

template<class K = key_type>

std::pair< const_iterator, const_iterator > gtl::linked_hash_map< Key, Value, KeyHash, KeyEq, Alloc >::equal_range

(

const key_arg< K > &

key

)

const

inline

◆ erase() [1/5]

template<class K = key_type>

◆ erase() [2/5]

◆ erase() [3/5]

◆ erase() [4/5]

◆ erase() [5/5]

◆ extract() [1/2]

template<class K = key_type, std::enable_if_t<!std::is_same_v< K, iterator >, int > = 0>

◆ extract() [2/2]

◆ find() [1/2]

template<class K = key_type>

◆ find() [2/2]

template<class K = key_type>

◆ front() [1/2]

◆ front() [2/2]

◆ get_allocator()

◆ hash_function()

◆ insert() [1/8]

◆ insert() [2/8]

◆ insert() [3/8]

◆ insert() [4/8]

◆ insert() [5/8]

template<class InputIt>

void gtl::linked_hash_map< Key, Value, KeyHash, KeyEq, Alloc >::insert	(	InputIt	first,
		InputIt	last )

inline

◆ insert() [6/8]

◆ insert() [7/8]

void gtl::linked_hash_map< Key, Value, KeyHash, KeyEq, Alloc >::insert

(

std::initializer_list< value_type >

ilist

)

inline

◆ insert() [8/8]

◆ insert_or_assign() [1/8]

template<class K = key_type, class V = mapped_type>

std::pair< iterator, bool > gtl::linked_hash_map< Key, Value, KeyHash, KeyEq, Alloc >::insert_or_assign	(	const key_arg< K > &	k,
		const V &	v )

inline

◆ insert_or_assign() [2/8]

template<class K = key_type, class V = mapped_type, V * = nullptr>

std::pair< iterator, bool > gtl::linked_hash_map< Key, Value, KeyHash, KeyEq, Alloc >::insert_or_assign	(	const key_arg< K > &	k,
		V &&	v )

inline

◆ insert_or_assign() [3/8]

template<class K = key_type, class V = mapped_type>

iterator gtl::linked_hash_map< Key, Value, KeyHash, KeyEq, Alloc >::insert_or_assign	(	const_iterator	,
		const key_arg< K > &	k,
		const V &	v )

inline

◆ insert_or_assign() [4/8]

template<class K = key_type, class V = mapped_type, V * = nullptr>

iterator gtl::linked_hash_map< Key, Value, KeyHash, KeyEq, Alloc >::insert_or_assign	(	const_iterator	,
		const key_arg< K > &	k,
		V &&	v )

inline

◆ insert_or_assign() [5/8]

template<class K = key_type, class V = mapped_type, K * = nullptr>

iterator gtl::linked_hash_map< Key, Value, KeyHash, KeyEq, Alloc >::insert_or_assign	(	const_iterator	,
		key_arg< K > &&	k,
		const V &	v )

inline

◆ insert_or_assign() [6/8]

template<class K = key_type, class V = mapped_type, K * = nullptr, V * = nullptr>

iterator gtl::linked_hash_map< Key, Value, KeyHash, KeyEq, Alloc >::insert_or_assign	(	const_iterator	,
		key_arg< K > &&	k,
		V &&	v )

inline

◆ insert_or_assign() [7/8]

template<class K = key_type, class V = mapped_type, K * = nullptr>

std::pair< iterator, bool > gtl::linked_hash_map< Key, Value, KeyHash, KeyEq, Alloc >::insert_or_assign	(	key_arg< K > &&	k,
		const V &	v )

inline

◆ insert_or_assign() [8/8]

template<class K = key_type, class V = mapped_type, K * = nullptr, V * = nullptr>

std::pair< iterator, bool > gtl::linked_hash_map< Key, Value, KeyHash, KeyEq, Alloc >::insert_or_assign	(	key_arg< K > &&	k,
		V &&	v )

inline

◆ key_eq()

◆ load_factor()

◆ max_size()

◆ merge() [1/2]

template<typename H, typename E>

void gtl::linked_hash_map< Key, Value, KeyHash, KeyEq, Alloc >::merge

(

linked_hash_map< Key, Value, H, E, Alloc > &&

src

)

inline

◆ merge() [2/2]

template<typename H, typename E>

void gtl::linked_hash_map< Key, Value, KeyHash, KeyEq, Alloc >::merge

(

linked_hash_map< Key, Value, H, E, Alloc > &

src

)

inline

◆ operator=() [1/3]

linked_hash_map & gtl::linked_hash_map< Key, Value, KeyHash, KeyEq, Alloc >::operator=

(

const linked_hash_map< Key, Value, KeyHash, KeyEq, Alloc > &

other

)

inline

◆ operator=() [2/3]

linked_hash_map & gtl::linked_hash_map< Key, Value, KeyHash, KeyEq, Alloc >::operator=

(

linked_hash_map< Key, Value, KeyHash, KeyEq, Alloc > &&

other

)

inlinenoexcept

◆ operator=() [3/3]

linked_hash_map & gtl::linked_hash_map< Key, Value, KeyHash, KeyEq, Alloc >::operator=

(

std::initializer_list< value_type >

values

)

inline

◆ operator[]() [1/2]

template<class K = key_type>

mapped_type & gtl::linked_hash_map< Key, Value, KeyHash, KeyEq, Alloc >::operator[]

(

const key_arg< K > &

key

)

inline

◆ operator[]() [2/2]

template<class K = key_type, K * = nullptr>

◆ pop_back()

◆ pop_front()

◆ rbegin() [1/2]

◆ rbegin() [2/2]

◆ rehash()

◆ rend() [1/2]

◆ rend() [2/2]

◆ reserve()

◆ size()

◆ swap()

void gtl::linked_hash_map< Key, Value, KeyHash, KeyEq, Alloc >::swap

(

linked_hash_map< Key, Value, KeyHash, KeyEq, Alloc > &

other

)

inline

◆ try_emplace() [1/3]

template<class K = key_type, typename... Args>

std::pair< iterator, bool > gtl::linked_hash_map< Key, Value, KeyHash, KeyEq, Alloc >::try_emplace	(	const key_arg< K > &	key,
		Args &&...	args )

inline

◆ try_emplace() [2/3]

template<class K = key_type, class... Args, K * = nullptr>

iterator gtl::linked_hash_map< Key, Value, KeyHash, KeyEq, Alloc >::try_emplace	(	const_iterator	,
		key_arg< K > &&	k,
		Args &&...	args )

inline

◆ try_emplace() [3/3]

template<class K = key_type, typename... Args, K * = nullptr>

std::pair< iterator, bool > gtl::linked_hash_map< Key, Value, KeyHash, KeyEq, Alloc >::try_emplace	(	key_arg< K > &&	key,
		Args &&...	args )

inline

◆ operator!=

bool operator!=	(	const linked_hash_map< Key, Value, KeyHash, KeyEq, Alloc > &	a,
		const linked_hash_map< Key, Value, KeyHash, KeyEq, Alloc > &	b )

friend

◆ operator==

bool operator==	(	const linked_hash_map< Key, Value, KeyHash, KeyEq, Alloc > &	a,
		const linked_hash_map< Key, Value, KeyHash, KeyEq, Alloc > &	b )

friend

The documentation for this class was generated from the following file:

ortools/base/linked_hash_map.h

Public Types

Public Member Functions

Friends

◆ allocator_type

◆ const_iterator

◆ const_pointer

◆ const_reference

◆ const_reverse_iterator

◆ difference_type

◆ hasher

◆ insert_return_type

◆ iterator

◆ key_equal

◆ key_type

◆ mapped_type

◆ node_type

◆ pointer

◆ reference

◆ reverse_iterator

◆ size_type

◆ value_type

◆ linked_hash_map() [2/17]

◆ linked_hash_map() [3/17]

◆ linked_hash_map() [4/17]

◆ linked_hash_map() [5/17]

◆ linked_hash_map() [6/17]

◆ linked_hash_map() [7/17]

◆ linked_hash_map() [8/17]

◆ linked_hash_map() [9/17]

◆ linked_hash_map() [10/17]

◆ linked_hash_map() [11/17]

◆ linked_hash_map() [12/17]

◆ linked_hash_map() [13/17]

◆ linked_hash_map() [14/17]

◆ linked_hash_map() [15/17]

◆ linked_hash_map() [16/17]

◆ linked_hash_map() [17/17]

◆ at() [1/2]

◆ at() [2/2]

◆ back() [1/2]

◆ back() [2/2]

◆ begin() [1/2]

◆ begin() [2/2]

◆ bucket_count()

◆ capacity()

◆ cbegin()

◆ cend()

◆ clear()

◆ contains()

◆ count()

◆ crbegin()

◆ crend()

◆ emplace()

◆ emplace_hint()

◆ empty()

◆ end() [1/2]

◆ end() [2/2]

◆ equal_range() [1/2]

◆ equal_range() [2/2]

◆ erase() [1/5]

◆ erase() [2/5]

◆ erase() [3/5]

◆ erase() [4/5]

◆ erase() [5/5]

◆ extract() [1/2]

◆ extract() [2/2]

◆ find() [1/2]

◆ find() [2/2]

◆ front() [1/2]

◆ front() [2/2]

◆ get_allocator()

◆ hash_function()

◆ insert() [1/8]

◆ insert() [2/8]

◆ insert() [3/8]

◆ insert() [4/8]

◆ insert() [5/8]

◆ insert() [6/8]

◆ insert() [7/8]

◆ insert() [8/8]