Google OR-Tools: gtl Namespace Reference

Todo: (corentinl) std::to_array available in C++20.

Classes
struct	LogShort
class	LogShortUpToN
struct	LogShortUpTo100
struct	LogMultiline
class	LogMultilineUpToN
struct	LogMultilineUpTo100
struct	LogLegacyUpTo100
struct	LogLegacy
class	IntType
class	ReverseView
class	linked_hash_map
class	BaseDeleter
class	TemplatedElementDeleter
class	ElementDeleter
class	TemplatedValueDeleter
class	ValueDeleter
class	STLElementDeleter
class	STLValueDeleter

Typedefs
typedef LogShortUpTo100	LogDefault
template<typename M>
using	MapUtilValueT = typename M::value_type
template<typename M>
using	MapUtilKeyT = typename MapUtilValueT<M>::first_type
template<typename M>
using	MapUtilMappedT = typename MapUtilValueT<M>::second_type

Functions
template<typename T, std::size_t N>
constexpr std::array< std::remove_cv_t< T >, N >	to_array (T(&ts)[N])
template<typename T, std::size_t N>
constexpr std::array< std::remove_cv_t< T >, N >	to_array (T(&&ts)[N])
template<typename IteratorT, typename PolicyT>
void	LogRangeToStream (std::ostream &out, IteratorT begin, IteratorT end, const PolicyT &policy)
template<typename IteratorT, typename PolicyT>
detail::RangeLogger< IteratorT, PolicyT >	LogRange (const IteratorT &begin, const IteratorT &end, const PolicyT &policy)
template<typename IteratorT>
detail::RangeLogger< IteratorT, LogDefault >	LogRange (const IteratorT &begin, const IteratorT &end)
template<typename ContainerT, typename PolicyT>
auto	LogContainer (const ContainerT &container, const PolicyT &policy) -> decltype(gtl::LogRange(container.begin(), container.end(), policy))
template<typename ContainerT>
auto	LogContainer (const ContainerT &container) -> decltype(gtl::LogContainer(container, LogDefault()))
template<typename E>
detail::EnumLogger< E >	LogEnum (E e)
template<typename IntTypeName, typename ValueType>
std::ostream &	operator<< (std::ostream &os, IntType< IntTypeName, ValueType > arg)
	INT_TYPE_ARITHMETIC_OP (+)
	INT_TYPE_ARITHMETIC_OP (-)
INT_TYPE_ARITHMETIC_OP *	INT_TYPE_ARITHMETIC_OP (/);INT_TYPE_ARITHMETIC_OP(<<
	INT_TYPE_ARITHMETIC_OP (> >)
	INT_TYPE_ARITHMETIC_OP (%)
	INT_TYPE_COMPARISON_OP (==)
	INT_TYPE_COMPARISON_OP (!=)
	INT_TYPE_COMPARISON_OP (<=)
	INT_TYPE_COMPARISON_OP (>=)
template<class Container>
ReverseView< Container >	reversed_view (const Container &c)
template<typename Collection, typename KeyType = MapUtilKeyT<Collection>>
const MapUtilMappedT< Collection > &	FindWithDefault (const Collection &collection, const KeyType &key, const MapUtilMappedT< Collection > &value)
template<class Collection, typename KeyType = MapUtilKeyT<Collection>>
const MapUtilMappedT< Collection > &	FindWithDefault (const Collection &collection, const KeyType &key)
template<class Collection>
const Collection::value_type::second_type *	FindOrNull (const Collection &collection, const typename Collection::value_type::first_type &key)
template<class Collection>
Collection::value_type::second_type *	FindOrNull (Collection &collection, const typename Collection::value_type::first_type &key)
template<class Collection>
const Collection::value_type::second_type	FindPtrOrNull (const Collection &collection, const typename Collection::value_type::first_type &key)
template<class Collection, class Key, class Value>
bool	InsertOrUpdate (Collection *const collection, const Key &key, const Value &value)
template<class Collection>
bool	InsertIfNotPresent (Collection *const collection, const typename Collection::value_type &value)
template<class Collection, class Key, class Value>
bool	InsertIfNotPresent (Collection *const collection, const Key &key, const Value &value)
template<class Collection>
void	InsertOrDieNoPrint (Collection *const collection, const typename Collection::value_type &value)
template<class Collection>
void	InsertOrDie (Collection *const collection, const typename Collection::value_type &value)
template<class Collection>
void	InsertOrDie (Collection *const collection, const typename Collection::value_type::first_type &key, const typename Collection::value_type::second_type &data)
template<typename Collection>
auto &	InsertKeyOrDie (Collection *const collection, const typename Collection::value_type::first_type &key)
template<class Collection, class Key, class Value>
bool	FindCopy (const Collection &collection, const Key &key, Value *const value)
template<class Collection, class Key>
bool	ContainsKey (const Collection &collection, const Key &key)
template<class Collection>
const Collection::value_type::second_type &	FindOrDie (const Collection &collection, const typename Collection::value_type::first_type &key)
template<class Collection>
const Collection::value_type::second_type &	FindOrDieNoPrint (const Collection &collection, const typename Collection::value_type::first_type &key)
template<class Collection>
Collection::value_type::second_type &	FindOrDieNoPrint (Collection &collection, const typename Collection::value_type::first_type &key)
template<class Collection>
Collection::value_type::second_type &	LookupOrInsert (Collection *const collection, const typename Collection::value_type::first_type &key, const typename Collection::value_type::second_type &value)
template<typename T, typename LessFunc>
void	STLSortAndRemoveDuplicates (T *v, const LessFunc &less_func)
template<typename T>
void	STLSortAndRemoveDuplicates (T *v)
template<typename T, typename LessFunc>
void	STLStableSortAndRemoveDuplicates (T *v, const LessFunc &less_func)
template<typename T>
void	STLStableSortAndRemoveDuplicates (T *v)
template<typename T, typename E>
void	STLEraseAllFromSequence (T *v, const E &e)
template<typename T, typename A, typename E>
void	STLEraseAllFromSequence (std::list< T, A > *c, const E &e)
template<typename T, typename A, typename E>
void	STLEraseAllFromSequence (std::forward_list< T, A > *c, const E &e)
template<typename T, typename P>
void	STLEraseAllFromSequenceIf (T *v, P pred)
template<typename T, typename A, typename P>
void	STLEraseAllFromSequenceIf (std::list< T, A > *c, P pred)
template<typename T, typename A, typename P>
void	STLEraseAllFromSequenceIf (std::forward_list< T, A > *c, P pred)
template<typename T>
void	STLClearObject (T *obj)
template<typename T, typename A>
void	STLClearObject (std::deque< T, A > *obj)
template<typename T>
void	STLClearIfBig (T *obj, size_t limit=1<< 20)
template<typename T, typename A>
void	STLClearIfBig (std::deque< T, A > *obj, size_t limit=1<< 20)
template<typename T>
void	STLClearHashIfBig (T *obj, size_t limit)
void	STLStringReserveIfNeeded (std::string *s, size_t min_capacity)
template<typename T, typename Traits, typename Alloc>
void	STLStringResizeUninitialized (std::basic_string< T, Traits, Alloc > *s, size_t new_size)
template<typename T, typename Traits, typename Alloc>
bool	STLStringSupportsNontrashingResize (const std::basic_string< T, Traits, Alloc > &s)
void	STLAssignToString (std::string str, const char ptr, size_t n)
void	STLAppendToString (std::string str, const char ptr, size_t n)
char *	string_as_array (std::string *str)
template<typename HashSet>
bool	HashSetEquality (const HashSet &set_a, const HashSet &set_b)
template<typename HashMap, typename BinaryPredicate>
bool	HashMapEquality (const HashMap &map_a, const HashMap &map_b, BinaryPredicate mapped_type_equal)
template<typename K, typename V, typename C, typename A>
bool	HashMapEquality (const std::map< K, V, C, A > &map_a, const std::map< K, V, C, A > &map_b)
template<typename HashMap>
bool	HashMapEquality (const HashMap &a, const HashMap &b)
template<typename ForwardIterator>
void	STLDeleteContainerPointers (ForwardIterator begin, ForwardIterator end)
template<typename ForwardIterator>
void	STLDeleteContainerPairPointers (ForwardIterator begin, ForwardIterator end)
template<typename ForwardIterator>
void	STLDeleteContainerPairFirstPointers (ForwardIterator begin, ForwardIterator end)
template<typename ForwardIterator>
void	STLDeleteContainerPairSecondPointers (ForwardIterator begin, ForwardIterator end)
template<typename T>
void	STLDeleteElements (T *container)
template<typename T>
void	STLDeleteValues (T *v)
template<typename T>
ABSL_MUST_USE_RESULT T *	release_ptr (T **ptr)
template<typename In1, typename In2, typename Out, typename Compare>
void	STLSetDifference (const In1 &a, const In2 &b, Out *out, Compare compare)
template<typename In1, typename In2, typename Out>
std::enable_if<!std::is_function< Out >::value, void >::type	STLSetDifference (const In1 &a, const In2 &b, Out *out)
template<typename Out, typename In1, typename In2, typename Compare>
Out	STLSetDifferenceAs (const In1 &a, const In2 &b, Compare compare)
template<typename Out, typename In1, typename In2>
Out	STLSetDifferenceAs (const In1 &a, const In2 &b)
template<typename In1, typename In2, typename Compare>
In1	STLSetDifference (const In1 &a, const In2 &b, Compare compare)
template<typename In1, typename In2>
In1	STLSetDifference (const In1 &a, const In2 &b)
template<typename In1>
In1	STLSetDifference (const In1 &a, const In1 &b)
template<typename In1, typename In2, typename Out, typename Compare>
void	STLSetUnion (const In1 &a, const In2 &b, Out *out, Compare compare)
template<typename In1, typename In2, typename Out>
std::enable_if<!std::is_function< Out >::value, void >::type	STLSetUnion (const In1 &a, const In2 &b, Out *out)
template<typename Out, typename In1, typename In2, typename Compare>
Out	STLSetUnionAs (const In1 &a, const In2 &b, Compare compare)
template<typename Out, typename In1, typename In2>
Out	STLSetUnionAs (const In1 &a, const In2 &b)
template<typename In1, typename In2, typename Compare>
In1	STLSetUnion (const In1 &a, const In2 &b, Compare compare)
template<typename In1, typename In2>
In1	STLSetUnion (const In1 &a, const In2 &b)
template<typename In1>
In1	STLSetUnion (const In1 &a, const In1 &b)
template<typename In1, typename In2, typename Out, typename Compare>
void	STLSetSymmetricDifference (const In1 &a, const In2 &b, Out *out, Compare compare)
template<typename In1, typename In2, typename Out>
std::enable_if<!std::is_function< Out >::value, void >::type	STLSetSymmetricDifference (const In1 &a, const In2 &b, Out *out)
template<typename Out, typename In1, typename In2, typename Compare>
Out	STLSetSymmetricDifferenceAs (const In1 &a, const In2 &b, Compare comp)
template<typename Out, typename In1, typename In2>
Out	STLSetSymmetricDifferenceAs (const In1 &a, const In2 &b)
template<typename In1, typename In2, typename Compare>
In1	STLSetSymmetricDifference (const In1 &a, const In2 &b, Compare comp)
template<typename In1, typename In2>
In1	STLSetSymmetricDifference (const In1 &a, const In2 &b)
template<typename In1>
In1	STLSetSymmetricDifference (const In1 &a, const In1 &b)
template<typename In1, typename In2, typename Out, typename Compare>
void	STLSetIntersection (const In1 &a, const In2 &b, Out *out, Compare compare)
template<typename In1, typename In2, typename Out>
std::enable_if<!std::is_function< Out >::value, void >::type	STLSetIntersection (const In1 &a, const In2 &b, Out *out)
template<typename Out, typename In1, typename In2, typename Compare>
Out	STLSetIntersectionAs (const In1 &a, const In2 &b, Compare compare)
template<typename Out, typename In1, typename In2>
Out	STLSetIntersectionAs (const In1 &a, const In2 &b)
template<typename In1, typename In2, typename Compare>
In1	STLSetIntersection (const In1 &a, const In2 &b, Compare compare)
template<typename In1, typename In2>
In1	STLSetIntersection (const In1 &a, const In2 &b)
template<typename In1>
In1	STLSetIntersection (const In1 &a, const In1 &b)
template<typename In1, typename In2, typename Compare>
bool	STLIncludes (const In1 &a, const In2 &b, Compare compare)
template<typename In1, typename In2>
bool	STLIncludes (const In1 &a, const In2 &b)
template<typename InputIterator1, typename InputIterator2, typename Comp>
bool	SortedRangesHaveIntersection (InputIterator1 begin1, InputIterator1 end1, InputIterator2 begin2, InputIterator2 end2, Comp comparator)
template<typename InputIterator1, typename InputIterator2>
bool	SortedRangesHaveIntersection (InputIterator1 begin1, InputIterator1 end1, InputIterator2 begin2, InputIterator2 end2)
template<typename In1, typename In2, typename Comp>
bool	SortedContainersHaveIntersection (const In1 &in1, const In2 &in2, Comp comparator)
template<typename In1, typename In2>
bool	SortedContainersHaveIntersection (const In1 &in1, const In2 &in2)

◆ LogDefault

◆ MapUtilKeyT

template<typename M>

using gtl::MapUtilKeyT = typename MapUtilValueT<M>::first_type

◆ MapUtilMappedT

template<typename M>

using gtl::MapUtilMappedT = typename MapUtilValueT<M>::second_type

◆ MapUtilValueT

template<typename M>

using gtl::MapUtilValueT = typename M::value_type

◆ ContainsKey()

template<class Collection, class Key>

bool gtl::ContainsKey	(	const Collection &	collection,
		const Key &	key )

◆ FindCopy()

template<class Collection, class Key, class Value>

bool gtl::FindCopy	(	const Collection &	collection,
		const Key &	key,
		Value *const	value )

◆ FindOrDie()

template<class Collection>

const Collection::value_type::second_type & gtl::FindOrDie	(	const Collection &	collection,
		const typename Collection::value_type::first_type &	key )

◆ FindOrDieNoPrint() [1/2]

template<class Collection>

Collection::value_type::second_type & gtl::FindOrDieNoPrint	(	Collection &	collection,
		const typename Collection::value_type::first_type &	key )

◆ FindOrDieNoPrint() [2/2]

template<class Collection>

const Collection::value_type::second_type & gtl::FindOrDieNoPrint	(	const Collection &	collection,
		const typename Collection::value_type::first_type &	key )

◆ FindOrNull() [1/2]

template<class Collection>

Collection::value_type::second_type * gtl::FindOrNull	(	Collection &	collection,
		const typename Collection::value_type::first_type &	key )

◆ FindOrNull() [2/2]

template<class Collection>

const Collection::value_type::second_type * gtl::FindOrNull	(	const Collection &	collection,
		const typename Collection::value_type::first_type &	key )

◆ FindPtrOrNull()

template<class Collection>

const Collection::value_type::second_type gtl::FindPtrOrNull	(	const Collection &	collection,
		const typename Collection::value_type::first_type &	key )

◆ FindWithDefault() [1/2]

template<class Collection, typename KeyType = MapUtilKeyT<Collection>>

const MapUtilMappedT< Collection > & gtl::FindWithDefault	(	const Collection &	collection,
		const KeyType &	key )

◆ FindWithDefault() [2/2]

template<typename Collection, typename KeyType = MapUtilKeyT<Collection>>

const MapUtilMappedT< Collection > & gtl::FindWithDefault	(	const Collection &	collection,
		const KeyType &	key,
		const MapUtilMappedT< Collection > &	value )

◆ HashMapEquality() [1/3]

template<typename HashMap>

bool gtl::HashMapEquality	(	const HashMap &	a,
		const HashMap &	b )

inline

◆ HashMapEquality() [2/3]

template<typename HashMap, typename BinaryPredicate>

bool gtl::HashMapEquality	(	const HashMap &	map_a,
		const HashMap &	map_b,
		BinaryPredicate	mapped_type_equal )

inline

◆ HashMapEquality() [3/3]

template<typename K, typename V, typename C, typename A>

bool gtl::HashMapEquality	(	const std::map< K, V, C, A > &	map_a,
		const std::map< K, V, C, A > &	map_b )

inline

◆ HashSetEquality()

template<typename HashSet>

bool gtl::HashSetEquality	(	const HashSet &	set_a,
		const HashSet &	set_b )

inline

◆ InsertIfNotPresent() [1/2]

template<class Collection, class Key, class Value>

bool gtl::InsertIfNotPresent	(	Collection *const	collection,
		const Key &	key,
		const Value &	value )

◆ InsertIfNotPresent() [2/2]

template<class Collection>

bool gtl::InsertIfNotPresent	(	Collection *const	collection,
		const typename Collection::value_type &	value )

◆ InsertKeyOrDie()

template<typename Collection>

auto & gtl::InsertKeyOrDie	(	Collection *const	collection,
		const typename Collection::value_type::first_type &	key )

◆ InsertOrDie() [1/2]

template<class Collection>

void gtl::InsertOrDie	(	Collection *const	collection,
		const typename Collection::value_type &	value )

◆ InsertOrDie() [2/2]

template<class Collection>

void gtl::InsertOrDie	(	Collection *const	collection,
		const typename Collection::value_type::first_type &	key,
		const typename Collection::value_type::second_type &	data )

◆ InsertOrDieNoPrint()

template<class Collection>

void gtl::InsertOrDieNoPrint	(	Collection *const	collection,
		const typename Collection::value_type &	value )

◆ InsertOrUpdate()

template<class Collection, class Key, class Value>

bool gtl::InsertOrUpdate	(	Collection *const	collection,
		const Key &	key,
		const Value &	value )

◆ INT_TYPE_ARITHMETIC_OP() [1/5]

gtl::INT_TYPE_ARITHMETIC_OP

(

)

◆ INT_TYPE_ARITHMETIC_OP() [2/5]

gtl::INT_TYPE_ARITHMETIC_OP

(

)

◆ INT_TYPE_ARITHMETIC_OP() [3/5]

gtl::INT_TYPE_ARITHMETIC_OP

(

)

◆ INT_TYPE_ARITHMETIC_OP() [4/5]

INT_TYPE_ARITHMETIC_OP * gtl::INT_TYPE_ARITHMETIC_OP

(

)

◆ INT_TYPE_ARITHMETIC_OP() [5/5]

gtl::INT_TYPE_ARITHMETIC_OP

(

)

◆ INT_TYPE_COMPARISON_OP() [1/4]

gtl::INT_TYPE_COMPARISON_OP

(

)

◆ INT_TYPE_COMPARISON_OP() [2/4]

gtl::INT_TYPE_COMPARISON_OP

(

)

◆ INT_TYPE_COMPARISON_OP() [3/4]

gtl::INT_TYPE_COMPARISON_OP

(

)

◆ INT_TYPE_COMPARISON_OP() [4/4]

gtl::INT_TYPE_COMPARISON_OP

(

)

◆ LogContainer() [1/2]

template<typename ContainerT>

auto gtl::LogContainer

(

const ContainerT &

container

)

->decltype(gtl::LogContainer(container, LogDefault()))

◆ LogContainer() [2/2]

template<typename ContainerT, typename PolicyT>

auto gtl::LogContainer	(	const ContainerT &	container,
		const PolicyT &	policy )->decltype(gtl::LogRange(container.begin(), container.end(), policy))

◆ LogEnum()

◆ LogRange() [1/2]

template<typename IteratorT>

◆ LogRange() [2/2]

template<typename IteratorT, typename PolicyT>

detail::RangeLogger< IteratorT, PolicyT > gtl::LogRange	(	const IteratorT &	begin,
		const IteratorT &	end,
		const PolicyT &	policy )

◆ LogRangeToStream()

template<typename IteratorT, typename PolicyT>

void gtl::LogRangeToStream	(	std::ostream &	out,
		IteratorT	begin,
		IteratorT	end,
		const PolicyT &	policy )

inline

◆ LookupOrInsert()

template<class Collection>

Collection::value_type::second_type & gtl::LookupOrInsert	(	Collection *const	collection,
		const typename Collection::value_type::first_type &	key,
		const typename Collection::value_type::second_type &	value )

◆ operator<<()

template<typename IntTypeName, typename ValueType>

std::ostream & gtl::operator<<	(	std::ostream &	os,
		IntType< IntTypeName, ValueType >	arg )

◆ release_ptr()

template<typename T>

ABSL_MUST_USE_RESULT T * gtl::release_ptr

(

T **

ptr

)

◆ reversed_view()

template<class Container>

ReverseView< Container > gtl::reversed_view

(

const Container &

)

◆ SortedContainersHaveIntersection() [1/2]

template<typename In1, typename In2>

bool gtl::SortedContainersHaveIntersection	(	const In1 &	in1,
		const In2 &	in2 )

◆ SortedContainersHaveIntersection() [2/2]

template<typename In1, typename In2, typename Comp>

bool gtl::SortedContainersHaveIntersection	(	const In1 &	in1,
		const In2 &	in2,
		Comp	comparator )

◆ SortedRangesHaveIntersection() [1/2]

template<typename InputIterator1, typename InputIterator2>

bool gtl::SortedRangesHaveIntersection	(	InputIterator1	begin1,
		InputIterator1	end1,
		InputIterator2	begin2,
		InputIterator2	end2 )

◆ SortedRangesHaveIntersection() [2/2]

template<typename InputIterator1, typename InputIterator2, typename Comp>

bool gtl::SortedRangesHaveIntersection	(	InputIterator1	begin1,
		InputIterator1	end1,
		InputIterator2	begin2,
		InputIterator2	end2,
		Comp	comparator )

◆ STLAppendToString()

void gtl::STLAppendToString	(	std::string *	str,
		const char *	ptr,
		size_t	n )

inline

◆ STLAssignToString()

void gtl::STLAssignToString	(	std::string *	str,
		const char *	ptr,
		size_t	n )

inline

◆ STLClearHashIfBig()

template<typename T>

void gtl::STLClearHashIfBig	(	T *	obj,
		size_t	limit )

inline

◆ STLClearIfBig() [1/2]

template<typename T, typename A>

void gtl::STLClearIfBig	(	std::deque< T, A > *	obj,
		size_t	limit = 1 << 20 )

inline

◆ STLClearIfBig() [2/2]

template<typename T>

void gtl::STLClearIfBig	(	T *	obj,
		size_t	limit = 1 << 20 )

inline

◆ STLClearObject() [1/2]

template<typename T, typename A>

void gtl::STLClearObject

(

std::deque< T, A > *

obj

)

◆ STLClearObject() [2/2]

template<typename T>

void gtl::STLClearObject

(

T *

obj

)

◆ STLDeleteContainerPairFirstPointers()

template<typename ForwardIterator>

void gtl::STLDeleteContainerPairFirstPointers	(	ForwardIterator	begin,
		ForwardIterator	end )

◆ STLDeleteContainerPairPointers()

template<typename ForwardIterator>

void gtl::STLDeleteContainerPairPointers	(	ForwardIterator	begin,
		ForwardIterator	end )

◆ STLDeleteContainerPairSecondPointers()

template<typename ForwardIterator>

void gtl::STLDeleteContainerPairSecondPointers	(	ForwardIterator	begin,
		ForwardIterator	end )

◆ STLDeleteContainerPointers()

template<typename ForwardIterator>

void gtl::STLDeleteContainerPointers	(	ForwardIterator	begin,
		ForwardIterator	end )

◆ STLDeleteElements()

template<typename T>

void gtl::STLDeleteElements

(

T *

container

)

◆ STLDeleteValues()

template<typename T>

void gtl::STLDeleteValues

(

T *

)

◆ STLEraseAllFromSequence() [1/3]

template<typename T, typename A, typename E>

void gtl::STLEraseAllFromSequence	(	std::forward_list< T, A > *	c,
		const E &	e )

◆ STLEraseAllFromSequence() [2/3]

template<typename T, typename A, typename E>

void gtl::STLEraseAllFromSequence	(	std::list< T, A > *	c,
		const E &	e )

◆ STLEraseAllFromSequence() [3/3]

template<typename T, typename E>

void gtl::STLEraseAllFromSequence	(	T *	v,
		const E &	e )

◆ STLEraseAllFromSequenceIf() [1/3]

template<typename T, typename A, typename P>

void gtl::STLEraseAllFromSequenceIf	(	std::forward_list< T, A > *	c,
		P	pred )

◆ STLEraseAllFromSequenceIf() [2/3]

template<typename T, typename A, typename P>

void gtl::STLEraseAllFromSequenceIf	(	std::list< T, A > *	c,
		P	pred )

◆ STLEraseAllFromSequenceIf() [3/3]

template<typename T, typename P>

void gtl::STLEraseAllFromSequenceIf	(	T *	v,
		P	pred )

◆ STLIncludes() [1/2]

template<typename In1, typename In2>

bool gtl::STLIncludes	(	const In1 &	a,
		const In2 &	b )

◆ STLIncludes() [2/2]

template<typename In1, typename In2, typename Compare>

bool gtl::STLIncludes	(	const In1 &	a,
		const In2 &	b,
		Compare	compare )

◆ STLSetDifference() [1/5]

template<typename In1>

In1 gtl::STLSetDifference	(	const In1 &	a,
		const In1 &	b )

◆ STLSetDifference() [2/5]

template<typename In1, typename In2>

In1 gtl::STLSetDifference	(	const In1 &	a,
		const In2 &	b )

◆ STLSetDifference() [3/5]

template<typename In1, typename In2, typename Compare>

In1 gtl::STLSetDifference	(	const In1 &	a,
		const In2 &	b,
		Compare	compare )

◆ STLSetDifference() [4/5]

template<typename In1, typename In2, typename Out>

std::enable_if<!std::is_function< Out >::value, void >::type gtl::STLSetDifference	(	const In1 &	a,
		const In2 &	b,
		Out *	out )

◆ STLSetDifference() [5/5]

template<typename In1, typename In2, typename Out, typename Compare>

void gtl::STLSetDifference	(	const In1 &	a,
		const In2 &	b,
		Out *	out,
		Compare	compare )

◆ STLSetDifferenceAs() [1/2]

template<typename Out, typename In1, typename In2>

Out gtl::STLSetDifferenceAs	(	const In1 &	a,
		const In2 &	b )

◆ STLSetDifferenceAs() [2/2]

template<typename Out, typename In1, typename In2, typename Compare>

Out gtl::STLSetDifferenceAs	(	const In1 &	a,
		const In2 &	b,
		Compare	compare )

◆ STLSetIntersection() [1/5]

template<typename In1>

In1 gtl::STLSetIntersection	(	const In1 &	a,
		const In1 &	b )

◆ STLSetIntersection() [2/5]

template<typename In1, typename In2>

In1 gtl::STLSetIntersection	(	const In1 &	a,
		const In2 &	b )

◆ STLSetIntersection() [3/5]

template<typename In1, typename In2, typename Compare>

In1 gtl::STLSetIntersection	(	const In1 &	a,
		const In2 &	b,
		Compare	compare )

◆ STLSetIntersection() [4/5]

template<typename In1, typename In2, typename Out>

std::enable_if<!std::is_function< Out >::value, void >::type gtl::STLSetIntersection	(	const In1 &	a,
		const In2 &	b,
		Out *	out )

◆ STLSetIntersection() [5/5]

template<typename In1, typename In2, typename Out, typename Compare>

void gtl::STLSetIntersection	(	const In1 &	a,
		const In2 &	b,
		Out *	out,
		Compare	compare )

◆ STLSetIntersectionAs() [1/2]

template<typename Out, typename In1, typename In2>

Out gtl::STLSetIntersectionAs	(	const In1 &	a,
		const In2 &	b )

◆ STLSetIntersectionAs() [2/2]

template<typename Out, typename In1, typename In2, typename Compare>

Out gtl::STLSetIntersectionAs	(	const In1 &	a,
		const In2 &	b,
		Compare	compare )

◆ STLSetSymmetricDifference() [1/5]

template<typename In1>

In1 gtl::STLSetSymmetricDifference	(	const In1 &	a,
		const In1 &	b )

◆ STLSetSymmetricDifference() [2/5]

template<typename In1, typename In2>

In1 gtl::STLSetSymmetricDifference	(	const In1 &	a,
		const In2 &	b )

◆ STLSetSymmetricDifference() [3/5]

template<typename In1, typename In2, typename Compare>

In1 gtl::STLSetSymmetricDifference	(	const In1 &	a,
		const In2 &	b,
		Compare	comp )

◆ STLSetSymmetricDifference() [4/5]

template<typename In1, typename In2, typename Out>

std::enable_if<!std::is_function< Out >::value, void >::type gtl::STLSetSymmetricDifference	(	const In1 &	a,
		const In2 &	b,
		Out *	out )

◆ STLSetSymmetricDifference() [5/5]

template<typename In1, typename In2, typename Out, typename Compare>

void gtl::STLSetSymmetricDifference	(	const In1 &	a,
		const In2 &	b,
		Out *	out,
		Compare	compare )

◆ STLSetSymmetricDifferenceAs() [1/2]

template<typename Out, typename In1, typename In2>

Out gtl::STLSetSymmetricDifferenceAs	(	const In1 &	a,
		const In2 &	b )

◆ STLSetSymmetricDifferenceAs() [2/2]

template<typename Out, typename In1, typename In2, typename Compare>

Out gtl::STLSetSymmetricDifferenceAs	(	const In1 &	a,
		const In2 &	b,
		Compare	comp )

◆ STLSetUnion() [1/5]

template<typename In1>

In1 gtl::STLSetUnion	(	const In1 &	a,
		const In1 &	b )

◆ STLSetUnion() [2/5]

template<typename In1, typename In2>

In1 gtl::STLSetUnion	(	const In1 &	a,
		const In2 &	b )

◆ STLSetUnion() [3/5]

template<typename In1, typename In2, typename Compare>

In1 gtl::STLSetUnion	(	const In1 &	a,
		const In2 &	b,
		Compare	compare )

◆ STLSetUnion() [4/5]

template<typename In1, typename In2, typename Out>

std::enable_if<!std::is_function< Out >::value, void >::type gtl::STLSetUnion	(	const In1 &	a,
		const In2 &	b,
		Out *	out )

◆ STLSetUnion() [5/5]

template<typename In1, typename In2, typename Out, typename Compare>

void gtl::STLSetUnion	(	const In1 &	a,
		const In2 &	b,
		Out *	out,
		Compare	compare )

◆ STLSetUnionAs() [1/2]

template<typename Out, typename In1, typename In2>

Out gtl::STLSetUnionAs	(	const In1 &	a,
		const In2 &	b )

◆ STLSetUnionAs() [2/2]

template<typename Out, typename In1, typename In2, typename Compare>

Out gtl::STLSetUnionAs	(	const In1 &	a,
		const In2 &	b,
		Compare	compare )

◆ STLSortAndRemoveDuplicates() [1/2]

template<typename T>

void gtl::STLSortAndRemoveDuplicates

(

T *

)

inline

◆ STLSortAndRemoveDuplicates() [2/2]

template<typename T, typename LessFunc>

void gtl::STLSortAndRemoveDuplicates	(	T *	v,
		const LessFunc &	less_func )

inline

◆ STLStableSortAndRemoveDuplicates() [1/2]

template<typename T>

void gtl::STLStableSortAndRemoveDuplicates

(

T *

)

inline

◆ STLStableSortAndRemoveDuplicates() [2/2]

template<typename T, typename LessFunc>

void gtl::STLStableSortAndRemoveDuplicates	(	T *	v,
		const LessFunc &	less_func )

inline

◆ STLStringReserveIfNeeded()

void gtl::STLStringReserveIfNeeded	(	std::string *	s,
		size_t	min_capacity )

inline

◆ STLStringResizeUninitialized()

template<typename T, typename Traits, typename Alloc>

void gtl::STLStringResizeUninitialized	(	std::basic_string< T, Traits, Alloc > *	s,
		size_t	new_size )

inline

◆ STLStringSupportsNontrashingResize()

template<typename T, typename Traits, typename Alloc>

bool gtl::STLStringSupportsNontrashingResize

(

const std::basic_string< T, Traits, Alloc > &

)

inline

◆ string_as_array()

char * gtl::string_as_array

(

std::string *

str

)

inline

◆ to_array() [1/2]

template<typename T, std::size_t N>

std::array< std::remove_cv_t< T >, N > gtl::to_array

(

T(&&)

ts[N]

)

constexpr

Definition at line 49 of file array.h.

◆ to_array() [2/2]

template<typename T, std::size_t N>

std::array< std::remove_cv_t< T >, N > gtl::to_array

(

T(&)

ts[N]

)

constexpr

Definition at line 44 of file array.h.

Classes

Typedefs

Functions

◆ LogDefault

◆ MapUtilKeyT

◆ MapUtilMappedT

◆ MapUtilValueT

◆ ContainsKey()

◆ FindCopy()

◆ FindOrDie()

◆ FindOrDieNoPrint() [1/2]

◆ FindOrDieNoPrint() [2/2]

◆ FindOrNull() [1/2]

◆ FindOrNull() [2/2]

◆ FindPtrOrNull()

◆ FindWithDefault() [1/2]

◆ FindWithDefault() [2/2]

◆ HashMapEquality() [1/3]

◆ HashMapEquality() [2/3]

◆ HashMapEquality() [3/3]

◆ HashSetEquality()

◆ InsertIfNotPresent() [1/2]

◆ InsertIfNotPresent() [2/2]

◆ InsertKeyOrDie()

◆ InsertOrDie() [1/2]

◆ InsertOrDie() [2/2]

◆ InsertOrDieNoPrint()

◆ InsertOrUpdate()

◆ INT_TYPE_ARITHMETIC_OP() [1/5]

◆ INT_TYPE_ARITHMETIC_OP() [2/5]

◆ INT_TYPE_ARITHMETIC_OP() [3/5]

◆ INT_TYPE_ARITHMETIC_OP() [4/5]

◆ INT_TYPE_ARITHMETIC_OP() [5/5]

◆ INT_TYPE_COMPARISON_OP() [1/4]

◆ INT_TYPE_COMPARISON_OP() [2/4]

◆ INT_TYPE_COMPARISON_OP() [3/4]

◆ INT_TYPE_COMPARISON_OP() [4/4]

◆ LogContainer() [1/2]

◆ LogContainer() [2/2]

◆ LogEnum()

◆ LogRange() [1/2]

◆ LogRange() [2/2]

◆ LogRangeToStream()

◆ LookupOrInsert()

◆ operator<<()

◆ release_ptr()

◆ reversed_view()

◆ SortedContainersHaveIntersection() [1/2]

◆ SortedContainersHaveIntersection() [2/2]

◆ SortedRangesHaveIntersection() [1/2]

◆ SortedRangesHaveIntersection() [2/2]

◆ STLAppendToString()

◆ STLAssignToString()

◆ STLClearHashIfBig()

◆ STLClearIfBig() [1/2]

◆ STLClearIfBig() [2/2]

◆ STLClearObject() [1/2]

◆ STLClearObject() [2/2]

◆ STLDeleteContainerPairFirstPointers()

◆ STLDeleteContainerPairPointers()

◆ STLDeleteContainerPairSecondPointers()

◆ STLDeleteContainerPointers()

◆ STLDeleteElements()

◆ STLDeleteValues()

◆ STLEraseAllFromSequence() [1/3]

◆ STLEraseAllFromSequence() [2/3]

◆ STLEraseAllFromSequence() [3/3]

◆ STLEraseAllFromSequenceIf() [1/3]

◆ STLEraseAllFromSequenceIf() [2/3]

◆ STLEraseAllFromSequenceIf() [3/3]

◆ STLIncludes() [1/2]

◆ STLIncludes() [2/2]

◆ STLSetDifference() [1/5]

◆ STLSetDifference() [2/5]

◆ STLSetDifference() [3/5]

◆ STLSetDifference() [4/5]

◆ STLSetDifference() [5/5]

◆ STLSetDifferenceAs() [1/2]

◆ STLSetDifferenceAs() [2/2]

◆ STLSetIntersection() [1/5]