Lines Matching refs:T

45 template <typename T>
48 template <typename T>
49 using ScopedArenaDeque = std::deque<T, ScopedArenaAllocatorAdapter<T>>;
51 template <typename T>
52 using ScopedArenaForwardList = std::forward_list<T, ScopedArenaAllocatorAdapter<T>>;
54 template <typename T>
55 using ScopedArenaQueue = std::queue<T, ScopedArenaDeque<T>>;
57 template <typename T>
58 using ScopedArenaVector = dchecked_vector<T, ScopedArenaAllocatorAdapter<T>>;
60 template <typename T, typename Comparator = std::less<T>>
61 using ScopedArenaPriorityQueue = std::priority_queue<T, ScopedArenaVector<T>, Comparator>;
63 template <typename T>
64 using ScopedArenaStdStack = std::stack<T, ScopedArenaDeque<T>>;
66 template <typename T, typename Comparator = std::less<T>>
67 using ScopedArenaSet = std::set<T, Comparator, ScopedArenaAllocatorAdapter<T>>;
73 template <typename T,
74           typename EmptyFn = DefaultEmptyFn<T>,
75           typename HashFn = DefaultHashFn<T>,
76           typename Pred = DefaultPred<T>>
77 using ScopedArenaHashSet = HashSet<T, EmptyFn, HashFn, Pred, ScopedArenaAllocatorAdapter<T>>;
144 template <typename T>
149   using value_type      = T;
150   using pointer         = T*;
151   using reference       = T&;
152   using const_pointer   = const T*;
153   using const_reference = const T&;
181     return static_cast<size_type>(-1) / sizeof(T);  in max_size()
191     return reinterpret_cast<T*>(arena_stack_->Alloc(n * sizeof(T),
196     arena_stack_->MakeInaccessible(p, sizeof(T) * n);  in deallocate()
221 template <typename T>
222 inline bool operator==(const ScopedArenaAllocatorAdapter<T>& lhs,
223                        const ScopedArenaAllocatorAdapter<T>& rhs) {
227 template <typename T>
228 inline bool operator!=(const ScopedArenaAllocatorAdapter<T>& lhs,
229                        const ScopedArenaAllocatorAdapter<T>& rhs) {
238 template <typename T>
244   ALWAYS_INLINE void ProtectMemory(T* ptr, size_t size) const {  in ProtectMemory()
260   void operator()(T* ptr) const {  in operator()
262       ptr->~T();  in operator()
263       ProtectMemory(ptr, sizeof(T));  in operator()
273 template <typename T>
274 class ArenaDelete<T[]> {
276   void operator()([[maybe_unused]] T* ptr) const {  in operator()
277     static_assert(std::is_trivially_destructible_v<T>,  in operator()
284 template <typename T>
285 using ArenaUniquePtr = std::unique_ptr<T, ArenaDelete<T>>;