1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
|
#pragma once
#include <util/system/defaults.h>
#include <stlfwd>
template <typename TCharType, typename TTraits = std::char_traits<TCharType>>
class TBasicString;
using TString = TBasicString<char>;
using TUtf16String = TBasicString<wchar16>;
using TUtf32String = TBasicString<wchar32>;
template <typename TCharType, typename TTraits = std::char_traits<TCharType>>
class TBasicStringBuf;
using TStringBuf = TBasicStringBuf<char>;
using TWtringBuf = TBasicStringBuf<wchar16>;
using TUtf32StringBuf = TBasicStringBuf<wchar32>;
// misc
class TBuffer;
// functors
template <class T = void>
struct TLess;
template <class T = void>
struct TGreater;
template <class T = void>
struct TEqualTo;
template <class T>
struct THash;
// intrusive containers
struct TIntrusiveListDefaultTag;
template <class T, class Tag = TIntrusiveListDefaultTag>
class TIntrusiveList;
template <class T, class D, class Tag = TIntrusiveListDefaultTag>
class TIntrusiveListWithAutoDelete;
template <class T, class Tag = TIntrusiveListDefaultTag>
class TIntrusiveSList;
// containers
template <class T, class A = std::allocator<T>>
class TVector;
template <class T, class A = std::allocator<T>>
class TDeque;
template <class T, class S = TDeque<T>>
class TQueue;
template <class T, class S = TVector<T>, class C = TLess<T>>
class TPriorityQueue;
template <class Key, class T, class HashFcn = THash<Key>, class EqualKey = TEqualTo<Key>, class Alloc = std::allocator<Key>>
class THashMap;
template <class Key, class T, class HashFcn = THash<Key>, class EqualKey = TEqualTo<Key>, class Alloc = std::allocator<Key>>
class THashMultiMap;
template <class Value, class HashFcn = THash<Value>, class EqualKey = TEqualTo<Value>, class Alloc = std::allocator<Value>>
class THashSet;
template <class Value, class HashFcn = THash<Value>, class EqualKey = TEqualTo<Value>, class Alloc = std::allocator<Value>>
class THashMultiSet;
template <class T, class A = std::allocator<T>>
class TList;
template <class K, class V, class Less = TLess<K>, class A = std::allocator<K>>
class TMap;
template <class K, class V, class Less = TLess<K>, class A = std::allocator<K>>
class TMultiMap;
template <class K, class L = TLess<K>, class A = std::allocator<K>>
class TSet;
template <class K, class L = TLess<K>, class A = std::allocator<K>>
class TMultiSet;
template <class T, class S = TDeque<T>>
class TStack;
template <size_t BitCount, typename TChunkType = ui64>
class TBitMap;
// autopointers
class TDelete;
class TDeleteArray;
class TFree;
class TCopyNew;
template <class T, class D = TDelete>
class TAutoPtr;
template <class T, class D = TDelete>
class THolder;
template <class T, class C, class D = TDelete>
class TRefCounted;
template <class T>
class TDefaultIntrusivePtrOps;
template <class T, class Ops>
class TSimpleIntrusiveOps;
template <class T, class Ops = TDefaultIntrusivePtrOps<T>>
class TIntrusivePtr;
template <class T, class Ops = TDefaultIntrusivePtrOps<T>>
class TIntrusiveConstPtr;
template <class T, class Ops = TDefaultIntrusivePtrOps<T>>
using TSimpleIntrusivePtr = TIntrusivePtr<T, TSimpleIntrusiveOps<T, Ops>>;
template <class T, class C, class D = TDelete>
class TSharedPtr;
template <class T, class C = TCopyNew, class D = TDelete>
class TCopyPtr;
template <class TPtr, class TCopy = TCopyNew>
class TCowPtr;
template <typename T>
class TPtrArg;
template <typename T>
using TArrayHolder = THolder<T, TDeleteArray>;
template <typename T>
using TMallocHolder = THolder<T, TFree>;
template <typename T>
using TArrayPtr = TAutoPtr<T, TDeleteArray>;
template <typename T>
using TMallocPtr = TAutoPtr<T, TFree>;
// maybe
namespace NMaybe {
struct TPolicyUndefinedExcept;
} // namespace NMaybe
template <class T, class Policy = ::NMaybe::TPolicyUndefinedExcept>
class TMaybe;
struct TGUID;
template <class T>
class TArrayRef;
template <class T>
using TConstArrayRef = TArrayRef<const T>;
|
