container.h File Reference

#include <algorithm>
#include <cassert>
#include <iterator>
#include <numeric>
#include <type_traits>
#include <unordered_map>
#include <unordered_set>
#include <utility>
#include <vector>
#include "absl/algorithm/algorithm.h"
#include "absl/base/macros.h"
#include "absl/meta/type_traits.h"

Include dependency graph for container.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Classes
struct	absl::container_algorithm_internal::IsUnorderedContainer< T >
struct	absl::container_algorithm_internal::IsUnorderedContainer< std::unordered_map< Key, T, Hash, KeyEqual, Allocator > >
struct	absl::container_algorithm_internal::IsUnorderedContainer< std::unordered_set< Key, Hash, KeyEqual, Allocator > >

Namespaces
	absl
	absl::container_algorithm_internal

Typedefs
template<typename C >
using	absl::container_algorithm_internal::ContainerDifferenceType = decltype(std::distance(std::declval< ContainerIter< C > >(), std::declval< ContainerIter< C > >()))
template<typename C >
using	absl::container_algorithm_internal::ContainerIter = decltype(begin(std::declval< C & >()))
template<typename C1 , typename C2 >
using	absl::container_algorithm_internal::ContainerIterPairType = decltype(std::make_pair(ContainerIter< C1 >(), ContainerIter< C2 >()))
template<typename C >
using	absl::container_algorithm_internal::ContainerPointerType = typename std::iterator_traits< ContainerIter< C > >::pointer

Functions
template<typename Sequence , typename T >
decay_t< T >	absl::c_accumulate (const Sequence &sequence, T &&init)
template<typename Sequence , typename T , typename BinaryOp >
decay_t< T >	absl::c_accumulate (const Sequence &sequence, T &&init, BinaryOp &&binary_op)
template<typename InputSequence , typename OutputIt >
OutputIt	absl::c_adjacent_difference (const InputSequence &input, OutputIt output_first)
template<typename InputSequence , typename OutputIt , typename BinaryOp >
OutputIt	absl::c_adjacent_difference (const InputSequence &input, OutputIt output_first, BinaryOp &&op)
template<typename Sequence >
container_algorithm_internal::ContainerIter< Sequence >	absl::c_adjacent_find (Sequence &sequence)
template<typename Sequence , typename BinaryPredicate >
container_algorithm_internal::ContainerIter< Sequence >	absl::c_adjacent_find (Sequence &sequence, BinaryPredicate &&pred)
template<typename C , typename Pred >
bool	absl::c_all_of (const C &c, Pred &&pred)
template<typename C , typename Pred >
bool	absl::c_any_of (const C &c, Pred &&pred)
template<typename C >
ContainerIter< C >	absl::container_algorithm_internal::c_begin (C &c)
template<typename Sequence , typename T >
bool	absl::c_binary_search (Sequence &&sequence, T &&value)
template<typename Sequence , typename T , typename Compare >
bool	absl::c_binary_search (Sequence &&sequence, T &&value, Compare &&comp)
template<typename InputSequence , typename OutputIterator >
OutputIterator	absl::c_copy (const InputSequence &input, OutputIterator output)
template<typename C , typename BidirectionalIterator >
BidirectionalIterator	absl::c_copy_backward (const C &src, BidirectionalIterator dest)
template<typename InputSequence , typename OutputIterator , typename Pred >
OutputIterator	absl::c_copy_if (const InputSequence &input, OutputIterator output, Pred &&pred)
template<typename C , typename Size , typename OutputIterator >
OutputIterator	absl::c_copy_n (const C &input, Size n, OutputIterator output)
template<typename C , typename T >
container_algorithm_internal::ContainerDifferenceType< const C >	absl::c_count (const C &c, T &&value)
template<typename C , typename Pred >
container_algorithm_internal::ContainerDifferenceType< const C >	absl::c_count_if (const C &c, Pred &&pred)
template<typename C >
container_algorithm_internal::ContainerDifferenceType< const C >	absl::c_distance (const C &c)
template<typename C >
ContainerIter< C >	absl::container_algorithm_internal::c_end (C &c)
template<typename C1 , typename C2 >
bool	absl::c_equal (const C1 &c1, const C2 &c2)
template<typename C1 , typename C2 , typename BinaryPredicate >
bool	absl::c_equal (const C1 &c1, const C2 &c2, BinaryPredicate &&pred)
template<typename Sequence , typename T >
container_algorithm_internal::ContainerIterPairType< Sequence, Sequence >	absl::c_equal_range (Sequence &sequence, T &&value)
template<typename Sequence , typename T , typename Compare >
container_algorithm_internal::ContainerIterPairType< Sequence, Sequence >	absl::c_equal_range (Sequence &sequence, T &&value, Compare &&comp)
template<typename C , typename T >
void	absl::c_fill (C &c, T &&value)
template<typename C , typename Size , typename T >
void	absl::c_fill_n (C &c, Size n, T &&value)
template<typename C , typename T >
container_algorithm_internal::ContainerIter< C >	absl::c_find (C &c, T &&value)
template<typename Sequence1 , typename Sequence2 >
container_algorithm_internal::ContainerIter< Sequence1 >	absl::c_find_end (Sequence1 &sequence, Sequence2 &subsequence)
template<typename Sequence1 , typename Sequence2 , typename BinaryPredicate >
container_algorithm_internal::ContainerIter< Sequence1 >	absl::c_find_end (Sequence1 &sequence, Sequence2 &subsequence, BinaryPredicate &&pred)
template<typename C1 , typename C2 >
container_algorithm_internal::ContainerIter< C1 >	absl::c_find_first_of (C1 &container, C2 &options)
template<typename C1 , typename C2 , typename BinaryPredicate >
container_algorithm_internal::ContainerIter< C1 >	absl::c_find_first_of (C1 &container, C2 &options, BinaryPredicate &&pred)
template<typename C , typename Pred >
container_algorithm_internal::ContainerIter< C >	absl::c_find_if (C &c, Pred &&pred)
template<typename C , typename Pred >
container_algorithm_internal::ContainerIter< C >	absl::c_find_if_not (C &c, Pred &&pred)
template<typename C , typename Function >
decay_t< Function >	absl::c_for_each (C &&c, Function &&f)
template<typename C , typename Generator >
void	absl::c_generate (C &c, Generator &&gen)
template<typename C , typename Size , typename Generator >
container_algorithm_internal::ContainerIter< C >	absl::c_generate_n (C &c, Size n, Generator &&gen)
template<typename C1 , typename C2 >
bool	absl::c_includes (const C1 &c1, const C2 &c2)
template<typename C1 , typename C2 , typename Compare >
bool	absl::c_includes (const C1 &c1, const C2 &c2, Compare &&comp)
template<typename Sequence1 , typename Sequence2 , typename T >
decay_t< T >	absl::c_inner_product (const Sequence1 &factors1, const Sequence2 &factors2, T &&sum)
template<typename Sequence1 , typename Sequence2 , typename T , typename BinaryOp1 , typename BinaryOp2 >
decay_t< T >	absl::c_inner_product (const Sequence1 &factors1, const Sequence2 &factors2, T &&sum, BinaryOp1 &&op1, BinaryOp2 &&op2)
template<typename C >
void	absl::c_inplace_merge (C &c, container_algorithm_internal::ContainerIter< C > middle)
template<typename C , typename Compare >
void	absl::c_inplace_merge (C &c, container_algorithm_internal::ContainerIter< C > middle, Compare &&comp)
template<typename Sequence , typename T >
void	absl::c_iota (Sequence &sequence, T &&value)
template<typename RandomAccessContainer >
bool	absl::c_is_heap (const RandomAccessContainer &sequence)
template<typename RandomAccessContainer , typename Compare >
bool	absl::c_is_heap (const RandomAccessContainer &sequence, Compare &&comp)
template<typename RandomAccessContainer >
container_algorithm_internal::ContainerIter< RandomAccessContainer >	absl::c_is_heap_until (RandomAccessContainer &sequence)
template<typename RandomAccessContainer , typename Compare >
container_algorithm_internal::ContainerIter< RandomAccessContainer >	absl::c_is_heap_until (RandomAccessContainer &sequence, Compare &&comp)
template<typename C , typename Pred >
bool	absl::c_is_partitioned (const C &c, Pred &&pred)
template<typename C1 , typename C2 >
bool	absl::c_is_permutation (const C1 &c1, const C2 &c2)
template<typename C1 , typename C2 , typename BinaryPredicate >
bool	absl::c_is_permutation (const C1 &c1, const C2 &c2, BinaryPredicate &&pred)
template<typename C >
bool	absl::c_is_sorted (const C &c)
template<typename C , typename Compare >
bool	absl::c_is_sorted (const C &c, Compare &&comp)
template<typename C >
container_algorithm_internal::ContainerIter< C >	absl::c_is_sorted_until (C &c)
template<typename C , typename Compare >
container_algorithm_internal::ContainerIter< C >	absl::c_is_sorted_until (C &c, Compare &&comp)
template<typename Sequence1 , typename Sequence2 >
bool	absl::c_lexicographical_compare (Sequence1 &&sequence1, Sequence2 &&sequence2)
template<typename Sequence1 , typename Sequence2 , typename Compare >
bool	absl::c_lexicographical_compare (Sequence1 &&sequence1, Sequence2 &&sequence2, Compare &&comp)
template<typename C , typename EqualityComparable >
bool	absl::c_linear_search (const C &c, EqualityComparable &&value)
template<typename Sequence , typename T >
container_algorithm_internal::ContainerIter< Sequence >	absl::c_lower_bound (Sequence &sequence, T &&value)
template<typename Sequence , typename T , typename Compare >
container_algorithm_internal::ContainerIter< Sequence >	absl::c_lower_bound (Sequence &sequence, T &&value, Compare &&comp)
template<typename RandomAccessContainer >
void	absl::c_make_heap (RandomAccessContainer &sequence)
template<typename RandomAccessContainer , typename Compare >
void	absl::c_make_heap (RandomAccessContainer &sequence, Compare &&comp)
template<typename Sequence >
container_algorithm_internal::ContainerIter< Sequence >	absl::c_max_element (Sequence &sequence)
template<typename Sequence , typename Compare >
container_algorithm_internal::ContainerIter< Sequence >	absl::c_max_element (Sequence &sequence, Compare &&comp)
template<typename C1 , typename C2 , typename OutputIterator >
OutputIterator	absl::c_merge (const C1 &c1, const C2 &c2, OutputIterator result)
template<typename C1 , typename C2 , typename OutputIterator , typename Compare >
OutputIterator	absl::c_merge (const C1 &c1, const C2 &c2, OutputIterator result, Compare &&comp)
template<typename Sequence >
container_algorithm_internal::ContainerIter< Sequence >	absl::c_min_element (Sequence &sequence)
template<typename Sequence , typename Compare >
container_algorithm_internal::ContainerIter< Sequence >	absl::c_min_element (Sequence &sequence, Compare &&comp)
template<typename C >
container_algorithm_internal::ContainerIterPairType< C, C >	absl::c_minmax_element (C &c)
template<typename C , typename Compare >
container_algorithm_internal::ContainerIterPairType< C, C >	absl::c_minmax_element (C &c, Compare &&comp)
template<typename C1 , typename C2 >
container_algorithm_internal::ContainerIterPairType< C1, C2 >	absl::c_mismatch (C1 &c1, C2 &c2)
template<typename C1 , typename C2 , typename BinaryPredicate >
container_algorithm_internal::ContainerIterPairType< C1, C2 >	absl::c_mismatch (C1 &c1, C2 &c2, BinaryPredicate &&pred)
template<typename C , typename OutputIterator >
OutputIterator	absl::c_move (C &&src, OutputIterator dest)
template<typename C >
bool	absl::c_next_permutation (C &c)
template<typename C , typename Compare >
bool	absl::c_next_permutation (C &c, Compare &&comp)
template<typename C , typename Pred >
bool	absl::c_none_of (const C &c, Pred &&pred)
template<typename RandomAccessContainer >
void	absl::c_nth_element (RandomAccessContainer &sequence, container_algorithm_internal::ContainerIter< RandomAccessContainer > nth)
template<typename RandomAccessContainer , typename Compare >
void	absl::c_nth_element (RandomAccessContainer &sequence, container_algorithm_internal::ContainerIter< RandomAccessContainer > nth, Compare &&comp)
template<typename RandomAccessContainer >
void	absl::c_partial_sort (RandomAccessContainer &sequence, container_algorithm_internal::ContainerIter< RandomAccessContainer > middle)
template<typename RandomAccessContainer , typename Compare >
void	absl::c_partial_sort (RandomAccessContainer &sequence, container_algorithm_internal::ContainerIter< RandomAccessContainer > middle, Compare &&comp)
template<typename C , typename RandomAccessContainer >
container_algorithm_internal::ContainerIter< RandomAccessContainer >	absl::c_partial_sort_copy (const C &sequence, RandomAccessContainer &result)
template<typename C , typename RandomAccessContainer , typename Compare >
container_algorithm_internal::ContainerIter< RandomAccessContainer >	absl::c_partial_sort_copy (const C &sequence, RandomAccessContainer &result, Compare &&comp)
template<typename InputSequence , typename OutputIt >
OutputIt	absl::c_partial_sum (const InputSequence &input, OutputIt output_first)
template<typename InputSequence , typename OutputIt , typename BinaryOp >
OutputIt	absl::c_partial_sum (const InputSequence &input, OutputIt output_first, BinaryOp &&op)
template<typename C , typename Pred >
container_algorithm_internal::ContainerIter< C >	absl::c_partition (C &c, Pred &&pred)
template<typename C , typename OutputIterator1 , typename OutputIterator2 , typename Pred >
std::pair< OutputIterator1, OutputIterator2 >	absl::c_partition_copy (const C &c, OutputIterator1 out_true, OutputIterator2 out_false, Pred &&pred)
template<typename C , typename Pred >
container_algorithm_internal::ContainerIter< C >	absl::c_partition_point (C &c, Pred &&pred)
template<typename RandomAccessContainer >
void	absl::c_pop_heap (RandomAccessContainer &sequence)
template<typename RandomAccessContainer , typename Compare >
void	absl::c_pop_heap (RandomAccessContainer &sequence, Compare &&comp)
template<typename C >
bool	absl::c_prev_permutation (C &c)
template<typename C , typename Compare >
bool	absl::c_prev_permutation (C &c, Compare &&comp)
template<typename RandomAccessContainer >
void	absl::c_push_heap (RandomAccessContainer &sequence)
template<typename RandomAccessContainer , typename Compare >
void	absl::c_push_heap (RandomAccessContainer &sequence, Compare &&comp)
template<typename C , typename OutputIterator , typename T >
OutputIterator	absl::c_remove_copy (const C &c, OutputIterator result, T &&value)
template<typename C , typename OutputIterator , typename Pred >
OutputIterator	absl::c_remove_copy_if (const C &c, OutputIterator result, Pred &&pred)
template<typename Sequence , typename T >
void	absl::c_replace (Sequence &sequence, const T &old_value, const T &new_value)
template<typename C , typename OutputIterator , typename T >
OutputIterator	absl::c_replace_copy (const C &c, OutputIterator result, T &&old_value, T &&new_value)
template<typename C , typename OutputIterator , typename Pred , typename T >
OutputIterator	absl::c_replace_copy_if (const C &c, OutputIterator result, Pred &&pred, T &&new_value)
template<typename C , typename Pred , typename T >
void	absl::c_replace_if (C &c, Pred &&pred, T &&new_value)
template<typename Sequence >
void	absl::c_reverse (Sequence &sequence)
template<typename C , typename OutputIterator >
OutputIterator	absl::c_reverse_copy (const C &sequence, OutputIterator result)
template<typename C , typename Iterator = container_algorithm_internal::ContainerIter<C>>
Iterator	absl::c_rotate (C &sequence, Iterator middle)
template<typename C , typename OutputIterator >
OutputIterator	absl::c_rotate_copy (const C &sequence, container_algorithm_internal::ContainerIter< const C > middle, OutputIterator result)
template<typename Sequence1 , typename Sequence2 >
container_algorithm_internal::ContainerIter< Sequence1 >	absl::c_search (Sequence1 &sequence, Sequence2 &subsequence)
template<typename Sequence1 , typename Sequence2 , typename BinaryPredicate >
container_algorithm_internal::ContainerIter< Sequence1 >	absl::c_search (Sequence1 &sequence, Sequence2 &subsequence, BinaryPredicate &&pred)
template<typename Sequence , typename Size , typename T >
container_algorithm_internal::ContainerIter< Sequence >	absl::c_search_n (Sequence &sequence, Size count, T &&value)
template<typename Sequence , typename Size , typename T , typename BinaryPredicate >
container_algorithm_internal::ContainerIter< Sequence >	absl::c_search_n (Sequence &sequence, Size count, T &&value, BinaryPredicate &&pred)
template<typename C1 , typename C2 , typename OutputIterator , typename = typename std::enable_if< !container_algorithm_internal::IsUnorderedContainer<C1>::value, void>::type, typename = typename std::enable_if< !container_algorithm_internal::IsUnorderedContainer<C2>::value, void>::type>
OutputIterator	absl::c_set_difference (const C1 &c1, const C2 &c2, OutputIterator output)
template<typename C1 , typename C2 , typename OutputIterator , typename Compare , typename = typename std::enable_if< !container_algorithm_internal::IsUnorderedContainer<C1>::value, void>::type, typename = typename std::enable_if< !container_algorithm_internal::IsUnorderedContainer<C2>::value, void>::type>
OutputIterator	absl::c_set_difference (const C1 &c1, const C2 &c2, OutputIterator output, Compare &&comp)
template<typename C1 , typename C2 , typename OutputIterator , typename = typename std::enable_if< !container_algorithm_internal::IsUnorderedContainer<C1>::value, void>::type, typename = typename std::enable_if< !container_algorithm_internal::IsUnorderedContainer<C2>::value, void>::type>
OutputIterator	absl::c_set_intersection (const C1 &c1, const C2 &c2, OutputIterator output)
template<typename C1 , typename C2 , typename OutputIterator , typename Compare , typename = typename std::enable_if< !container_algorithm_internal::IsUnorderedContainer<C1>::value, void>::type, typename = typename std::enable_if< !container_algorithm_internal::IsUnorderedContainer<C2>::value, void>::type>
OutputIterator	absl::c_set_intersection (const C1 &c1, const C2 &c2, OutputIterator output, Compare &&comp)
template<typename C1 , typename C2 , typename OutputIterator , typename = typename std::enable_if< !container_algorithm_internal::IsUnorderedContainer<C1>::value, void>::type, typename = typename std::enable_if< !container_algorithm_internal::IsUnorderedContainer<C2>::value, void>::type>
OutputIterator	absl::c_set_symmetric_difference (const C1 &c1, const C2 &c2, OutputIterator output)
template<typename C1 , typename C2 , typename OutputIterator , typename Compare , typename = typename std::enable_if< !container_algorithm_internal::IsUnorderedContainer<C1>::value, void>::type, typename = typename std::enable_if< !container_algorithm_internal::IsUnorderedContainer<C2>::value, void>::type>
OutputIterator	absl::c_set_symmetric_difference (const C1 &c1, const C2 &c2, OutputIterator output, Compare &&comp)
template<typename C1 , typename C2 , typename OutputIterator , typename = typename std::enable_if< !container_algorithm_internal::IsUnorderedContainer<C1>::value, void>::type, typename = typename std::enable_if< !container_algorithm_internal::IsUnorderedContainer<C2>::value, void>::type>
OutputIterator	absl::c_set_union (const C1 &c1, const C2 &c2, OutputIterator output)
template<typename C1 , typename C2 , typename OutputIterator , typename Compare , typename = typename std::enable_if< !container_algorithm_internal::IsUnorderedContainer<C1>::value, void>::type, typename = typename std::enable_if< !container_algorithm_internal::IsUnorderedContainer<C2>::value, void>::type>
OutputIterator	absl::c_set_union (const C1 &c1, const C2 &c2, OutputIterator output, Compare &&comp)
template<typename RandomAccessContainer , typename UniformRandomBitGenerator >
void	absl::c_shuffle (RandomAccessContainer &c, UniformRandomBitGenerator &&gen)
template<typename C >
void	absl::c_sort (C &c)
template<typename C , typename Compare >
void	absl::c_sort (C &c, Compare &&comp)
template<typename RandomAccessContainer >
void	absl::c_sort_heap (RandomAccessContainer &sequence)
template<typename RandomAccessContainer , typename Compare >
void	absl::c_sort_heap (RandomAccessContainer &sequence, Compare &&comp)
template<typename C , typename Pred >
container_algorithm_internal::ContainerIter< C >	absl::c_stable_partition (C &c, Pred &&pred)
template<typename C >
void	absl::c_stable_sort (C &c)
template<typename C , typename Compare >
void	absl::c_stable_sort (C &c, Compare &&comp)
template<typename C1 , typename C2 >
container_algorithm_internal::ContainerIter< C2 >	absl::c_swap_ranges (C1 &c1, C2 &c2)
template<typename InputSequence , typename OutputIterator , typename UnaryOp >
OutputIterator	absl::c_transform (const InputSequence &input, OutputIterator output, UnaryOp &&unary_op)
template<typename InputSequence1 , typename InputSequence2 , typename OutputIterator , typename BinaryOp >
OutputIterator	absl::c_transform (const InputSequence1 &input1, const InputSequence2 &input2, OutputIterator output, BinaryOp &&binary_op)
template<typename C , typename OutputIterator >
OutputIterator	absl::c_unique_copy (const C &c, OutputIterator result)
template<typename C , typename OutputIterator , typename BinaryPredicate >
OutputIterator	absl::c_unique_copy (const C &c, OutputIterator result, BinaryPredicate &&pred)
template<typename Sequence , typename T >
container_algorithm_internal::ContainerIter< Sequence >	absl::c_upper_bound (Sequence &sequence, T &&value)
template<typename Sequence , typename T , typename Compare >
container_algorithm_internal::ContainerIter< Sequence >	absl::c_upper_bound (Sequence &sequence, T &&value, Compare &&comp)