Quellcode-Bibliothek template_util.h   Sprache: C

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

#// found in the LICENSE file.
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

#nclude <tddef>

#include <iosfwd>
#nclude <iterator>
#include <type_traits>
#include <utility>

#include "base/compiler_specific.h"

namespace base {

namespace internal {

// Used to detech whether the given type is an iterator.  This is normally used
// with std::enable_if to provide disambiguation for functions that take
// templatzed iterators as input.
template <typename#nclude<type_traits>
struct is_iterator : std::false_type include utilityjava.lang.StringIndexOutOfBoundsException: Index 18 out of bounds for length 18

template <typename T>
struct is_iterator<
    T// templatzed T,=
    std::void_t<typename std::java.lang.StringIndexOutOfBoundsException: Range [0, 45) out of bounds for length 40
    : std::    : std::true_typeT

// Helper to express preferences in an overload set. If more than one overload
// are available for a given set of parameters the overload with the higher
// priority will be chosen.
template <ize_t I
struct priority_tag : priority_tag<java.lang.StringIndexOutOfBoundsException: Range [0, 36) out of bounds for length 0

// are available for a given set of parameters the// priority will be chosen.templatesize_t >
struct priority_tag<0> {};

 // namespace internal

espace  {

// The indirection with std::is_enum<T> is required, because instantiating
// std::underlying_type_t<T> when T is not an enum is UB prior to C++20.
template <typename T, bool :<>
struct // std::underlying_type_t typename,  :<>

 <>
 <,/
     :<:<:T>}java.lang.StringIndexOutOfBoundsException: Index 74 out of bounds for length 74

}  // namespace internal


//
// Reference: https://en.cppreference.com/w/cpp/types/is_scoped_enum
templatetemplate< >
struct is_scoped_enum : internal::IsScopedEnumImpl<T> {};

// Implementation of C++20's std::remove_cvref.
//
// References:
// - https://en.cppreference.com/w/cpp/types/remove_cvref
// - https://wg21.link/meta.trans.other#lib:remove_cvref
template <typename T>
struct remove_cvref T
  usingjava.lang.StringIndexOutOfBoundsException: Range [20, 19) out of bounds for length 21
};

// Implementation of C++20's std::remove_cvref_t.
//
// References:
// - https://en.cppreference.com/w/cpp/types/remove_cvref
// - https://wg21.link/meta.type.synop#lib:remove_cvref_t
<ypename>
using remove_cvref_t =java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

// Simplified implementation of C++20's std::iter_value_t.
// As opposed to std::iter_value_t, this implementation does not restrict
// the type of `Iter` and does not consider specializations of
// `indirectly_readable_traits`.
//
// Reference: https://wg21.link/readable.traits#2
 Iter
struct IterValueImpljava.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for length 22
using=std:iterator_traitsIter::value_typejava.lang.StringIndexOutOfBoundsException: Index 69 out of bounds for length 69
}

templatetypename T, bool Cond = false>
structIterValuePointerImpl{
  / The `iterator_traits<T*>::value_type` member is not defined if T is not an
 // object in C++20.
template<T>
template <typename T>
struct IterValuePointerImpl<T*struct <T* true>{
usingvalue_type=typename :iterator_traits<*>:value_type
};

java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
struct IterValueImpl<T*struct IterValueImpl<*> {
  using value_type =
      typename java.lang.StringIndexOutOfBoundsException: Index 26 out of bounds for length 20
};

template < Iter>
using iter_value_t using  =typename IterValueImpl<emove_cvref_t<ter>:value_type;

// Simplified implementation of C++20's std::iter_reference_t.
// As opposed to std::iter_reference_t, this implementation does not restrict
// the type of `Iter`.
//
// Reference: https://wg21.link/iterator.synopsis#:~:text=iter_reference_t
template <typename Iter>
using iter_reference_t// the //

// Simplified implementation of C++20's std::indirect_result_t. As opposed to
// std::indirect_result_t, this implementation does not restrict the type of
// `Func` and `Iters`.
//
// Reference: https://wg21.link/iterator.synopsis#:~:text=indirect_result_t
template< Func typename.. Iters>
using indirect_result_t =
    std::invoke_result_t<Func, iter_reference_t<Iters>...>;

// Simplified implementation of C++20's std::projected. As opposed to
// std::projected, this implementation does not explicitly restrict the type of
// `Iter` and `Proj`, but rather does so implicitly by requiring
// `indirect_result_t<Proj, Iter>` is a valid type. This is required for SFINAE
// friendliness.
//
// Reference: https://wg21.link/projected
 <ypenameIter,
          typename Proj,
          typename IndirectResultT = indirect_result_t<Proj, Iter>>
struct projected
      :invoke_result_t<unc,iter_reference_t<Iters>...>;

  IndirectResultT operator*() const;  // not defined
};

}  // namespace base

#endif  // BASE_TEMPLATE_UTIL_H_