Google OR-Tools v9.15
a fast and portable software suite for combinatorial optimization
Loading...
Searching...
No Matches
stl_util.h File Reference
#include <stddef.h>
#include <string.h>
#include <algorithm>
#include <cassert>
#include <deque>
#include <forward_list>
#include <functional>
#include <iterator>
#include <list>
#include <map>
#include <string>
#include <type_traits>
#include "absl/base/attributes.h"
#include "absl/meta/type_traits.h"
#include "absl/strings/internal/resize_uninitialized.h"

Go to the source code of this file.

Classes

class  gtl::internal::Equiv< LessFunc >
class  gtl::BaseDeleter
class  gtl::TemplatedElementDeleter< STLContainer >
class  gtl::ElementDeleter
class  gtl::TemplatedValueDeleter< STLContainer >
class  gtl::ValueDeleter
class  gtl::STLElementDeleter< STLContainer >
class  gtl::STLValueDeleter< STLContainer >
struct  gtl::stl_util_internal::TransparentLess
struct  gtl::stl_util_internal::Unordered< typename, typename, typename >
struct  gtl::stl_util_internal::Unordered< T, absl::void_t< typename T::hasher > >
struct  gtl::stl_util_internal::Unordered< T, absl::void_t< typename T::hasher >, absl::void_t< typename T::reverse_iterator > >

Namespaces

namespace  gtl
namespace  gtl::internal
namespace  gtl::stl_util_internal

Functions

template<typename T, typename LessFunc>
void gtl::STLSortAndRemoveDuplicates (T *v, const LessFunc &less_func)
template<typename T>
void gtl::STLSortAndRemoveDuplicates (T *v)
template<typename T, typename LessFunc>
void gtl::STLStableSortAndRemoveDuplicates (T *v, const LessFunc &less_func)
template<typename T>
void gtl::STLStableSortAndRemoveDuplicates (T *v)
template<typename T, typename E>
void gtl::STLEraseAllFromSequence (T *v, const E &e)
template<typename T, typename A, typename E>
void gtl::STLEraseAllFromSequence (std::list< T, A > *c, const E &e)
template<typename T, typename A, typename E>
void gtl::STLEraseAllFromSequence (std::forward_list< T, A > *c, const E &e)
template<typename T, typename P>
void gtl::STLEraseAllFromSequenceIf (T *v, P pred)
template<typename T, typename A, typename P>
void gtl::STLEraseAllFromSequenceIf (std::list< T, A > *c, P pred)
template<typename T, typename A, typename P>
void gtl::STLEraseAllFromSequenceIf (std::forward_list< T, A > *c, P pred)
template<typename T>
void gtl::STLClearObject (T *obj)
template<typename T, typename A>
void gtl::STLClearObject (std::deque< T, A > *obj)
template<typename T>
void gtl::STLClearIfBig (T *obj, size_t limit=1<< 20)
template<typename T, typename A>
void gtl::STLClearIfBig (std::deque< T, A > *obj, size_t limit=1<< 20)
template<typename T>
void gtl::STLClearHashIfBig (T *obj, size_t limit)
void gtl::STLStringReserveIfNeeded (std::string *s, size_t min_capacity)
template<typename T, typename Traits, typename Alloc>
void gtl::STLStringResizeUninitialized (std::basic_string< T, Traits, Alloc > *s, size_t new_size)
template<typename T, typename Traits, typename Alloc>
bool gtl::STLStringSupportsNontrashingResize (const std::basic_string< T, Traits, Alloc > &s)
void gtl::STLAssignToString (std::string *str, const char *ptr, size_t n)
void gtl::STLAppendToString (std::string *str, const char *ptr, size_t n)
char * gtl::string_as_array (std::string *str)
template<typename HashSet>
bool gtl::HashSetEquality (const HashSet &set_a, const HashSet &set_b)
template<typename HashMap, typename BinaryPredicate>
bool gtl::HashMapEquality (const HashMap &map_a, const HashMap &map_b, BinaryPredicate mapped_type_equal)
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)
template<typename HashMap>
bool gtl::HashMapEquality (const HashMap &a, const HashMap &b)
template<typename ForwardIterator>
void gtl::STLDeleteContainerPointers (ForwardIterator begin, ForwardIterator end)
template<typename ForwardIterator>
void gtl::STLDeleteContainerPairPointers (ForwardIterator begin, ForwardIterator end)
template<typename ForwardIterator>
void gtl::STLDeleteContainerPairFirstPointers (ForwardIterator begin, ForwardIterator end)
template<typename ForwardIterator>
void gtl::STLDeleteContainerPairSecondPointers (ForwardIterator begin, ForwardIterator end)
template<typename T>
void gtl::STLDeleteElements (T *container)
template<typename T>
void gtl::STLDeleteValues (T *v)
template<typename T>
ABSL_MUST_USE_RESULT T * gtl::release_ptr (T **ptr)
template<typename In1, typename In2, typename Out, typename Compare>
void gtl::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 gtl::STLSetDifference (const In1 &a, const In2 &b, Out *out)
template<typename Out, typename In1, typename In2, typename Compare>
Out gtl::STLSetDifferenceAs (const In1 &a, const In2 &b, Compare compare)
template<typename Out, typename In1, typename In2>
Out gtl::STLSetDifferenceAs (const In1 &a, const In2 &b)
template<typename In1, typename In2, typename Compare>
In1 gtl::STLSetDifference (const In1 &a, const In2 &b, Compare compare)
template<typename In1, typename In2>
In1 gtl::STLSetDifference (const In1 &a, const In2 &b)
template<typename In1>
In1 gtl::STLSetDifference (const In1 &a, const In1 &b)
template<typename In1, typename In2, typename Out, typename Compare>
void gtl::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 gtl::STLSetUnion (const In1 &a, const In2 &b, Out *out)
template<typename Out, typename In1, typename In2, typename Compare>
Out gtl::STLSetUnionAs (const In1 &a, const In2 &b, Compare compare)
template<typename Out, typename In1, typename In2>
Out gtl::STLSetUnionAs (const In1 &a, const In2 &b)
template<typename In1, typename In2, typename Compare>
In1 gtl::STLSetUnion (const In1 &a, const In2 &b, Compare compare)
template<typename In1, typename In2>
In1 gtl::STLSetUnion (const In1 &a, const In2 &b)
template<typename In1>
In1 gtl::STLSetUnion (const In1 &a, const In1 &b)
template<typename In1, typename In2, typename Out, typename Compare>
void gtl::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 gtl::STLSetSymmetricDifference (const In1 &a, const In2 &b, Out *out)
template<typename Out, typename In1, typename In2, typename Compare>
Out gtl::STLSetSymmetricDifferenceAs (const In1 &a, const In2 &b, Compare comp)
template<typename Out, typename In1, typename In2>
Out gtl::STLSetSymmetricDifferenceAs (const In1 &a, const In2 &b)
template<typename In1, typename In2, typename Compare>
In1 gtl::STLSetSymmetricDifference (const In1 &a, const In2 &b, Compare comp)
template<typename In1, typename In2>
In1 gtl::STLSetSymmetricDifference (const In1 &a, const In2 &b)
template<typename In1>
In1 gtl::STLSetSymmetricDifference (const In1 &a, const In1 &b)
template<typename In1, typename In2, typename Out, typename Compare>
void gtl::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 gtl::STLSetIntersection (const In1 &a, const In2 &b, Out *out)
template<typename Out, typename In1, typename In2, typename Compare>
Out gtl::STLSetIntersectionAs (const In1 &a, const In2 &b, Compare compare)
template<typename Out, typename In1, typename In2>
Out gtl::STLSetIntersectionAs (const In1 &a, const In2 &b)
template<typename In1, typename In2, typename Compare>
In1 gtl::STLSetIntersection (const In1 &a, const In2 &b, Compare compare)
template<typename In1, typename In2>
In1 gtl::STLSetIntersection (const In1 &a, const In2 &b)
template<typename In1>
In1 gtl::STLSetIntersection (const In1 &a, const In1 &b)
template<typename In1, typename In2, typename Compare>
bool gtl::STLIncludes (const In1 &a, const In2 &b, Compare compare)
template<typename In1, typename In2>
bool gtl::STLIncludes (const In1 &a, const In2 &b)
template<typename InputIterator1, typename InputIterator2, typename Comp>
bool gtl::SortedRangesHaveIntersection (InputIterator1 begin1, InputIterator1 end1, InputIterator2 begin2, InputIterator2 end2, Comp comparator)
template<typename InputIterator1, typename InputIterator2>
bool gtl::SortedRangesHaveIntersection (InputIterator1 begin1, InputIterator1 end1, InputIterator2 begin2, InputIterator2 end2)
template<typename In1, typename In2, typename Comp>
bool gtl::SortedContainersHaveIntersection (const In1 &in1, const In2 &in2, Comp comparator)
template<typename In1, typename In2>
bool gtl::SortedContainersHaveIntersection (const In1 &in1, const In2 &in2)