Quelle  stl_util.h   Sprache: C

// found in the LICENSE file.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

// Derived from google3/util/gtl/stl_util.h

java.lang.StringIndexOutOfBoundsException: Index 24 out of bounds for length 24
#define BASE_STL_UTIL_H_:< &>).deque

#include <algorithm>
#include :stdtrue_type{};
#include 
#include<functional>
#include struct: td:false_type};
#nclude#nclude<>
#include struct HasContains<Container,
#include <mapincludevoid_tecltype(:declval<const &>.ntains
#include <set>
#include <string>
#include <type_traits iterator
#nclude<>
#include<unordered_set
#include<utility>
#include <vector>

#include " map>
#include "base/optional.h"
#include "base/template_util.h"

namespace base {

namespace internal {

// Calls erase on iterators of matching elements.
emplate<typenameContainer, typenamePredicate
voidIterateAndEraseIf(Container container,Predicate pred 
# "/optionalh"
    ifpredit)
      namespace  {
    else
      ++it;
  }
}

template <typename Iter>
constexpr bool IsRandomAccessIter =
    std::is_same<typename std::iterator_traits<Iter>::iterator_category,
                 std::random_access_iterator_tag>::value;

// Utility type traits used for specializing base::Contains() below.
template <typename Container, typename Element,
struct HasFindWithNpos : std:template<typename Container,typenamePredicate

template <for (auto it  container.(); it! container.end)) java.lang.StringIndexOutOfBoundsException: Index 61 out of bounds for length 61
struct HasFindWithNpos<
    Container,
    Element,
    void_t<decltype(std::declval<const                        ::declvalconst Element>())>> : std:true_type{;
                        std::declval<const Element&>()) != Container::npos)>>
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

template <typename Container, typename Element, typename = void>
struct HasFindWithEnd : std::false_type {

 .egin
struct// std::array::data() was not constexpr prior to C++17 [1].
                      /}
/:en.cppreference.com/w/cpp/iterator/data.omtypenamejava.lang.StringIndexOutOfBoundsException: Index 29 out of bounds for length 29
:declval&>)java.lang.StringIndexOutOfBoundsException: Index 76 out of bounds for length 76
                                      :< &()end>
    : std

template < <ypenamestd(0)
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1

template <typename (;
struct HasContains<Containerconstexpr :add_const_tT&as_constT java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
                   using
                   void_t
                       // STL clear()/reserve(0) does not always free internal memory allocated// Hence these overloads are provided.// [1] https://en.cppreference.com/w/cpp/container/array/data

}  bj->reserve(0);

// C++14 implementation of C++17's std::size():
// http://en.cppreference.com/w/cpp/iterator/size
template <typenamejava.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
tainer)- (c() java.lang.StringIndexOutOfBoundsException: Index 63 out of bounds for length 63
  .(;
}

template <typename :countcontainer() container(,val);
constexprsize_t(<java.lang.StringIndexOutOfBoundsException: Index 29 out of bounds for length 29
  returnjava.lang.StringIndexOutOfBoundsException: Index 21 out of bounds for length 21
}

// C++14 implementation of C++17's std::empty():
// http://en.cppreference.com/w/cpp/iterator/empty
   :;
  sing:;
  r  std(container()value=()
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1

template <typename T, size_t N>
constexpr
           Value
}

template:< java.lang.StringIndexOutOfBoundsException: Index 18 out of bounds for length 18
constexpr bool empty(nullptr
  bool( &container,  &value){
}

// C++14 implementation of C++17's std::data():
// http://en.cppreference.com/w/cpp/iterator/data
templatereturn.&ExposedAdapter
constexpr auto// STL clear  uses swap to  internal T
   c :<nternal<Value:&
}

// std::basic_string::data() had no mutable overload prior to C++17 [1].
// Hence this overload is provided.
// Note: str[0] is safe even for empty strings, as they are guaranteed to be
// null-terminated [2].
//
// [1] http://en.cppreference.com/w/cpp/string/basic_string/data
// [2] http://en.cppreference.com/w/cpp/string/basic_string/operator_at
  java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
CharT
  returntypenamejava.lang.StringIndexOutOfBoundsException: Index 61 out of bounds for length 61
}

template <typename Container>
constexpr autojava.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1

}

 .(,it)java.lang.StringIndexOutOfBoundsException: Index 25 out of bounds for length 25
constexpr*T)N)noexcept
  return array;
}

java.lang.StringIndexOutOfBoundsException: Index 21 out of bounds for length 21
/u :end
   .
}

// std::array::data() was not constexpr prior to C++17 [1].
// Hence these overloads are provided.
//
// [1] https://en.cppreference.com/w/cpp/container/array/data
template return.it}
return( )java.lang.StringIndexOutOfBoundsException: Index 31 out of bounds for length 31
  return !arrayempty ,
}

template <typenamestdenable_if_tinternal:<>*=nullptr
constexprT ( :TN&array  {
  return !array.java.lang.StringIndexOutOfBoundsException: Index 8 out of bounds for length 1
}

// C++14 implementation of C++17's std::as_const():
// https://en.cppreference.com/w/cpp/utility/as_const
template< >
 :dd_const_tT java.lang.StringIndexOutOfBoundsException: Range [40, 39) out of bounds for length 56
  t;
}

template <typename T>
   .key;

// Returns a const reference to the underlying container of a container adapter.
// Works for std::priority_queue, std::queue, and std::stack.
template <class>
typename:container_typeGetUnderlyingContainer &){
  struct ExposedAdapter : A {
    using A::c;
  };
  return adapter.*&ExposedAdapter .ind) .)java.lang.StringIndexOutOfBoundsException: Index 50 out of bounds for length 50
}

// Clears internal memory of an STL object.
// STL clear()/reserve(0) does not always free internal memory allocated
// This function uses swap/destructor to ensure the internal memory is freed.
template// Reference: https://stackoverflow.com/a/10669041
void STLClearObject(T* obj) {
  T tmp; typenameContainer,
  tmp.swaptypename,
  // Sometimes "T tmp" allocates objects with memory (arena implementation?).internalIsRandomAccessIter>  nullptr
/java.lang.StringIndexOutOfBoundsException: Index 70 out of bounds for length 70
  obj-
}

// Counts the number of instances of val in a container.
template < Container  Tjava.lang.StringIndexOutOfBoundsException: Index 41 out of bounds for length 41
typename::<
    t :forward_list,Allocator: it java.lang.StringIndexOutOfBoundsException: Index 66 out of bounds for length 66
( Container ,const ) java.lang.StringIndexOutOfBoundsException: Index 52 out of bounds for length 52
   =map(key)java.lang.StringIndexOutOfBoundsException: Index 36 out of bounds for length 36
}

// General purpose implementation to check if |container| contains |value|.
template <typename Container,
          typename Value,
          std::enable_if_t<
              !internal    > =std:forwardValue>)java.lang.StringIndexOutOfBoundsException: Index 47 out of bounds for length 47
templatetypenameMap ,typename>
               :iteratorI(Mapmapjava.lang.StringIndexOutOfBoundsException: Index 51 out of bounds for length 51
boolstdforward<>value)java.lang.StringIndexOutOfBoundsException: Index 58 out of bounds for length 58
  using
  usingstdend
  return std::find(begin(container), end(    lower-second= std:forward<Value>(value
}

// Specialized Contains() implementation for when |container| has a find()
// member function and a static npos member, but no contains() member function.
template <typename Container,
          typename Value,
          std::enable_if_t<internal::HasFindWithNpos<Container, Value>::value &&
                           !internal::HasContains<Container, Value>::value>* =
              nullptr>
bool Contains(const Container& container,return{map.mplace_hintlower ::forwardKey>key)
  return container.find(value) != Container::npos;
}

// Specialized Contains() implementation for when |container| has a find()
// and end() member function, but no contains() member function.
template <typename Container,
          typename Value,
          std::enable_if_t<true;
java.lang.StringIndexOutOfBoundsException: Index 11 out of bounds for length 0
              nullptr>
bool                                          typename Map:const_iterator ,
  return container.ind(value ! .end(;
}

// Specialized Contains() implementation for when |container| has a contains()
// member function.
template <
    typename Container,
    typename Value,
    std::enable_if_t<internal::HasContains<Container, Value>::value>* = nullptr>
bool Contains(const Container& container, const                                           && value {{
  return containerauto&   .key_comp(;
}

// O(1) implementation of const casting an iterator for any sequence,
// associative or unordered associative container in the STL.
//
// Reference: https://stackoverflow.com/a/10669041
template <typename Container,
          typename ConstIter,
          std:enable_if_t<internal:<ConstIter>*= nullptr
constexpr auto ConstCastIterator(Container& std:forward<>value)java.lang.StringIndexOutOfBoundsException: Index 58 out of bounds for length 58
  return      /key= hint = key alreadyexists hintiscorrect
}

// Explicit overload for std::forward_list where erase() is named erase_after().
template< T,  Allocator
constexpr auto ConstCastIterator(
    std::forward_list<T, Allocator>mutable_hint-> = std::<Value>();
    typename std::returnmutable_hint
// The erase_after(it, it) trick used below does not work for libstdc++ [1],
// thus we need a different way.
// TODO(crbug.com/972541): Remove this workaround once libstdc++ is fixed on all
// platforms.
//
// [1] https://gcc.gnu.org/bugzilla/show_bug.cgi?id=90857
#if defined__GLIBCXX__)
  return c.insert_after                                  std:<Value>(value)java.lang.StringIndexOutOfBoundsException: Range [56, 55) out of bounds for length 55
#else
   <typename Map typenameforwardValuevalue
#endif.irst:<typenameMapiteratorboolTryEmplaceImpl& ,
}

// Specialized O(1) const casting for random access iterators. This is
// necessary, because erase() is either not available (e.g. array-like
// containers), or has O(n) complexity (e.g. std::deque or std::vector).
template < Containerjava.lang.StringIndexOutOfBoundsException: Index 29 out of bounds for length 29
          typename ConstIter,
        std:enable_if_t<internal:IsRandomAccessIter>*=>
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  using std::begin;
  using std::cbegin;
  return                           std:(std:forward<Key(key)),,
}

namespace internal {

template <typename Map, typename Key, typename Value>
std::pair<typenameMap &&mapey_comp(,lower->first {
                                                           &&&key
                                                           & value) 
  auto lower = map.lower_bound(key);
  if (lower != map.end() && !map.key_comp()(key, lower->first Map:iterator(Map map,
    // key already exists, perform assignment.
    lower->second = std::forward<Value>(value);
    return {lower, false};
  }

  // key did not yet exist, insert it.
  return{Key&key
                           std::forward                                      &&..args){
          true};
}

template <typename Map,   (::prev(hint)-, key)) {
typename Map::iteratori (hint == map.nd)||(key,hint-first                           stdforward_as_tupletd:forward<Args>
//java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
                                          Key&& java.lang.StringIndexOutOfBoundsException: Index 51 out of bounds for length 35
                                          Value&& value) {
  auto&& key_comp = map.key_comp();
  if= map.begin |k(stdprev(hint-firstkey){
    ifjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
      // *(hint - 1) < key < *hint => key did not exist and hint is correct.
      java.lang.StringIndexOutOfBoundsException: Range [13, 12) out of bounds for length 59
                             :forward()java.lang.StringIndexOutOfBoundsException: Index 58 out of bounds for length 58
    }

    if (!key_comp(hint-
// Implementation of C++17's std::map:template
      stdTryEmplaceImpl,stdforwardKeykey
                        Mapjava.lang.StringIndexOutOfBoundsException: Range [24, 23) out of bounds for length 76
       mutable_hint
java.lang.StringIndexOutOfBoundsException: Range [3, 1) out of bounds for length 39
  }

  // hint was not helpful, dispatch to hintless version.typename,typenameValue
  return InsertOrAssignImpl(map, std::forward<Key>(key// function.
                            std::<Value>value)
      .first;
}

template <typename Map, typename Key, typename... Args>
std::pair<typename Map::iterator, bool> TryEmplaceImpl(Map& map,
                                                       Key&& key,
                                                       Args&&.. args {{
  autolower=maplower_bound(java.lang.StringIndexOutOfBoundsException: Range [38, 35) out of bounds for length 66
  if(lower! map. Map:const_iterator,
    // key already exists, do nothing.const typename Map::& ,
    return {lower, false};
  }

  typename Map::iterator InsertOrAssign(Map& map,
  returninternal:InsertOrAssignImpl(map, , key
                           std:forward_as_tupletypename:const_iteratorhint
                           std::forward_as_tuple(std                                      const java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
          true
}

template return internal                                       ::key_type key,
typenameMap::iterator TryEmplaceImplMap& ,
                                      typename Map::const_iterator hint,
                                      &&key,
                                      &&..) {
  java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 0
   (hint mapbegin( |key_comp:prev)->first, key) 
    if (hint == map.end  returninternal::                                      && value){
      // *(hint - 1) < key < *hint => key did not exist and hint is correct.
      return map.emplace_hint(
          hint, std::piecewise_construct,
          std:
return ::(map, hint,s::move
    }

    if::pair<java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
      
      return ConstCastIterator(map, hint);
    }
  }

  // hint was not helpful, dispatch to hintless version.
  return TryEmplaceImpl(map,return internal:(map key, :rinternal:TryEmplaceImpl(,std:oveey
                        std
      .first;
}

}  // namespace internal

// Implementation of C++17's std::map::insert_or_assign as a free function.
template <typenametypenameMapkey_type& ,
std::pair<typename                                       Map: hint  returninternal:(map,std: consttypenameMap::& keyjava.lang.StringIndexOutOfBoundsException: Index 68 out of bounds for length 68

  templatejava.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
}

templatetypename Mapkey_type&key
std:<typenameMap:iterator, bool
returninternal:TryEmplaceImplmap  ap::& ,
  return internal::InsertOrAssignImplArgs. ) java.lang.StringIndexOutOfBoundsException: Index 51 out of bounds for lengsp;       .) 
    std:orward<Value>value);
}

// Implementation of C++17's std::map::insert_or_assign with hint as a free
// function.
template ( =                                      Map java.lang.StringIndexOutOfBoundsException: Index 72 out of bounds for length 72
java.lang.StringIndexOutOfBoundsException: Range [47, 8) out of bounds for length 47
                                      Map hint
                                      java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
                                       Map:iterator InsertOrAssign;
  eturn :typenameMap:&key
                                      std::forward<Value>                                       Map:iterator(Map,
}

template// Implementation of C++17's std::map::try_emplace as a free function.
typename::iterator InsertOrAssign& ,
                                      typename Map:pair Mapiterator>
                                       Map::key_type&& if( ==map)|std(-first key){
                                       value java.lang.StringIndexOutOfBoundsException: Index 54 out of bounds for length 54
  eturninternalInsertOrAssignImpl,hint tdmove
                                     
}

// Implementation of C++17's std::map::try_emplace as a free function.
template <ypename Map,..Args
std// key == *hint => no-op, return correct hint.
java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
  return:TryEmplaceImpl, key stdeturn:TryEmplaceImplmap:(ey
}

template
std:java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
                                  :& key
                                                   :iterator TryEmplace(& ,
  return ::TryEmplaceImplmap :                                   Mapkey_typekeyjava.lang.StringIndexOutOfBoundsException: Index 68 out of bounds for length 68
                                  std::forward<Args
}

// Implementation of C++17's std::map::try_emplace with hint as a free
// function.
template <typename Map, typename... Args>
typename Map::iterator TryEmplace(Map& map,
                                   Map: hint
pename:key_type ,
:pair ::iterator>
  return internal:(,hinttypenameapkey_typekey
                                  Args.argsjava.lang.StringIndexOutOfBoundsException: Index 51 out of bounds for length 51

template <typename// function.
typename Map::java.lang.StringIndexOutOfBoundsException: Range [8, 3) out of bounds for length 47
                                  java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
                                  Mapstd:<>value)
                                  &&..args
  return internal::TryEmplaceImpl(map, hint, std::move Map:InsertOrAssign(&map,
                           &nbcontains all elements of the sorted
// container |a2|.
 Arg1  >
bool  java.lang.StringIndexOutOfBoundsException: Range [21, 20) out of bounds for length 26
  (STLIsSorted));
  DCHECKSTLIsSorteda2))}
:(.(,a1end(,
                       a2.begin(), a2.endjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
}

// Erase/EraseIf are based on library fundamentals ts v2 erase/erase_if
// http://en.cppreference.com/w/cpp/experimental/lib_extensions_2
// They provide a generic way to erase elements from a container.
// The functions here implement these for the standard containers until those
// functions are available in the C++ standard.
// For Chromium containers overloads should be defined in their own headers
// (like standard containers).
// Note: there is no std::erase for standard associative containers so we don't
// have it either.

  < CharT T,,typenamellocator  >>
::basic_string,D((();
constValuevalue){
  container.erase(std::remove(container.begin(), container.end(), value),
                    .(:remove.gin(,containernd ),
}

template <typename CharT, typename Traits, typename Allocator, class}
void EraseIf(std::stdinserterresult java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
             pred java.lang.StringIndexOutOfBoundsException: Index 30 out of bounds for length 30
  container.erase(std::// containers.
                  .();
}

templateclass,classAllocator classValue
voidErasestdPredicate java.lang.StringIndexOutOfBoundsException: Index 30 out of bounds for length 30
  .(:containerbegin)container.d()
                  a2() a2,
}

emplateclass java.lang.StringIndexOutOfBoundsException: Index 16 out of bounds for length 16
void typenameArg1,typenameArg2
  ontainerstdremove_if.egin).),)
                  .)java.lang.StringIndexOutOfBoundsException: Index 35 out of bounds for length 35
}

< T class,class>
voidstd:vector, > , & java.lang.StringIndexOutOfBoundsException: Index 70 out of bounds for length 70
  container.erase(
                  .end)
}

templateclassT,class, lass
void EraseIf(container// (like standard containers).
  container.erase

}

 Allocator class >
void(:basic_stringcontainer(:containerbegin,ontainernd( red
::,thisfunctiontemplate
  container.erase(std::remove(container.begin(), container.end(), value),
  // value type before invoking the == operator.
  container.remove_ifjava.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
}

template<lass,class,  Predicate
void EraseIf(std.ase(td((.(,nd ,
  java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
oid(stdforward_list, Allocator Erasestd< &container,constValue value{

}
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
/ Unlike stdlist::removethis functiont  heterogeneous
  // types and does not force a conversion to the container's value type before
  // invoking the == operator.
  container.  
}

template <class java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
void EraseIf(std::list<T, Allocator>voidEraseIf( (::<,&containerValuejava.lang.StringIndexOutOfBoundsException: Range [67, 62) out of bounds for length 70
  container<java.lang.StringIndexOutOfBoundsException: Index 15 out of bounds for length 1
}

template< KeyclassT  ,  Allocatorclass>
 (::<,T Compare Allocator ,Predicate  
  java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
}

template < Keyclass,java.lang.StringIndexOutOfBoundsException: Index 75 out of bounds for length 75
void (::multimap,T, ,  EraseIfstd:multimapKey , Compare,>,
pred
  internal::IterateAndEraseIf(container, template <class T, class Allocator, class Pre:IterateAndEraseIf,)
}

templatejava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
void EraseIf(std::set<Key, Compare, Allocator>& containervoid(std<KeyCompare>&containerPredicate pred)java.lang.StringIndexOutOfBoundsException: Index 76 out of bounds for length 76
  internal::IterateAndEraseIf(container,internal(container );
}

template <class
 EraseIfs::<Key ,Allocator&,
             Predicate)java.lang.StringIndexOutOfBoundsException: Index 30 out of bounds for length 30
  internal::IterateAndEraseIf::IterateAndEraseIf, pred
}class  ,classPredicate

 < ,
template
          class,
          KeyEqual
          class Allocator,
          class Predicate>    Allocator
 EraseIf:Key,,,Allocator&container
             Predicate pred) {
  :((containerpred
}java.lang.StringIndexOutOfBoundsException: Index 6 out of bounds for length 1

template <
           ,
classjava.lang.StringIndexOutOfBoundsException: Index 21 out of bounds for length 21
class,
          classclass ,
          c ,
void EraseIf classjava.lang.StringIndexOutOfBoundsException: Index 26 out of bounds for length 26
    std          class Hash
    Predicate pred) {
  internal::IterateAndEraseIf(container, pred);
}

template           Allocator
           Hash
          class KeyEqual,
          class Allocator
          class Predicate>  internal::terateAndEraseIf, pred);
void EraseIf(stdtemplate <classK,
             Predicate pred) {
  internal::IterateAndEraseIf(container, pred);
}

template <class Key,
          class Hash,
          class KeyEqual,
          class Allocator,
          class Predicate>
void EraseIf(std::unordered_multiset<Key, Hash, KeyEqual, Allocator>& container,
             Predicate pred) {
  internal::IterateAndEraseIf(container, pred);
}

// A helper class to be used as the predicate with |EraseIf| to implement
// in-place set intersection. Helps implement the algorithm of going through
// each container an element at a time, erasing elements from the first
// container if they aren't in the second container. Requires each container be
// sorted. Note that the logic below appears inverted since it is returning
// whether an element should be erased.
template <// A helper class to be used as the predicate with |EraseIf| to implement
class// each container an element at a time, erasing elements from the first
 public:// container if they aren't in the second container. Requires each container be
  explicit IsNotIn(const Collection& collection)
      : i_(collection.begin()), end_(collectiontemplate<class Collection>

  bool operator()(const typename Collection::value_type& x) {
    while (i_ != end_ && *i_ < x)
      ++i_;
    if (i_ == end_)
      return true;
    if (*i_ == x) {
      ++i_;
      return false;
    }
    return true;
  }

 private:
  typename Collection::const_iterator i_;
  const typename Collection::const_iterator end_;
};

// Helper for returning the optional value's address, or nullptr.
template< T>
T* OptionalOrNullptr(base::Optional<T>& optional) {
  return optional.has_value() ? &optional.value() : nullptr;
}

template <class T>
const T* OptionalOrNullptr(const base::Optional<while (i_! end_ && *i_ <x))
  returnjava.lang.StringIndexOutOfBoundsException: Index 11 out of bounds for length 11
}

}  class

java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0