Move URL from WebCore to WTF
[WebKit-https.git] / Source / WTF / wtf / Forward.h
1 /*
2  *  Copyright (C) 2006-2018 Apple Inc. All rights reserved.
3  *
4  *  This library is free software; you can redistribute it and/or
5  *  modify it under the terms of the GNU Library General Public
6  *  License as published by the Free Software Foundation; either
7  *  version 2 of the License, or (at your option) any later version.
8  *
9  *  This library is distributed in the hope that it will be useful,
10  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
11  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
12  *  Library General Public License for more details.
13  *
14  *  You should have received a copy of the GNU Library General Public License
15  *  along with this library; see the file COPYING.LIB.  If not, write to
16  *  the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
17  *  Boston, MA 02110-1301, USA.
18  *
19  */
20
21 #pragma once
22
23 #include <stddef.h>
24
25 namespace WTF {
26
27 class AtomicString;
28 class AtomicStringImpl;
29 class BinarySemaphore;
30 class CString;
31 class CrashOnOverflow;
32 class FunctionDispatcher;
33 class Hasher;
34 class MonotonicTime;
35 class OrdinalNumber;
36 class PrintStream;
37 class SHA1;
38 class Seconds;
39 class String;
40 class StringBuilder;
41 class StringImpl;
42 class StringView;
43 class TextPosition;
44 class TextStream;
45 class UniquedStringImpl;
46 class URL;
47 class WallTime;
48
49 struct FastMalloc;
50
51 template<typename> class CompletionHandler;
52 template<typename T> struct DumbPtrTraits;
53 template<typename T> struct DumbValueTraits;
54 template<typename> class Function;
55 template<typename> class LazyNeverDestroyed;
56 template<typename> class NeverDestroyed;
57 template<typename> class OptionSet;
58 template<typename T, typename = DumbPtrTraits<T>> class Ref;
59 template<typename T, typename = DumbPtrTraits<T>> class RefPtr;
60 template<typename> class StringBuffer;
61 template<typename, typename = void> class StringTypeAdapter;
62
63 template<typename> struct DefaultHash { using Hash = void; };
64 template<typename> struct HashTraits;
65
66 template<typename> struct EnumTraits;
67 template<typename E, E...> struct EnumValues;
68
69 template<typename...> class Variant;
70 template<typename, size_t = 0, typename = CrashOnOverflow, size_t = 16> class Vector;
71 template<typename Value, typename = typename DefaultHash<Value>::Hash, typename = HashTraits<Value>> class HashCountedSet;
72 template<typename KeyArg, typename MappedArg, typename = typename DefaultHash<KeyArg>::Hash, typename = HashTraits<KeyArg>, typename = HashTraits<MappedArg>> class HashMap;
73 template<typename ValueArg, typename = typename DefaultHash<ValueArg>::Hash, typename = HashTraits<ValueArg>> class HashSet;
74
75 template<size_t, typename> struct variant_alternative;
76 template<ptrdiff_t, typename...> struct __indexed_type;
77 template<ptrdiff_t _Index, typename... _Types> constexpr typename __indexed_type<_Index, _Types...>::__type const& get(Variant<_Types...> const&);
78
79 }
80
81 namespace std {
82 namespace experimental {
83 inline namespace fundamentals_v3 {
84 template<class, class> class expected;
85 template<class> class unexpected;
86 }}} // namespace std::experimental::fundamentals_v3
87
88 using WTF::AtomicString;
89 using WTF::AtomicStringImpl;
90 using WTF::BinarySemaphore;
91 using WTF::CString;
92 using WTF::CompletionHandler;
93 using WTF::DumbPtrTraits;
94 using WTF::DumbValueTraits;
95 using WTF::Function;
96 using WTF::FunctionDispatcher;
97 using WTF::HashCountedSet;
98 using WTF::HashMap;
99 using WTF::HashSet;
100 using WTF::Hasher;
101 using WTF::LazyNeverDestroyed;
102 using WTF::NeverDestroyed;
103 using WTF::OptionSet;
104 using WTF::OrdinalNumber;
105 using WTF::PrintStream;
106 using WTF::Ref;
107 using WTF::RefPtr;
108 using WTF::SHA1;
109 using WTF::String;
110 using WTF::StringBuffer;
111 using WTF::StringBuilder;
112 using WTF::StringImpl;
113 using WTF::StringView;
114 using WTF::TextPosition;
115 using WTF::TextStream;
116 using WTF::URL;
117 using WTF::Variant;
118 using WTF::Vector;
119
120 template<class T, class E> using Expected = std::experimental::expected<T, E>;
121 template<class E> using Unexpected = std::experimental::unexpected<E>;
122
123 // Sometimes an inline method simply forwards to another one and does nothing else. If it were
124 // just a forward declaration of that method then you would only need a forward declaration of
125 // its return types and parameter types too, but because it's inline and it actually needs to
126 // return / pass these types (even though it's just passing through whatever it called) you
127 // now find yourself having to actually have a full declaration of these types. That might be
128 // an include you'd rather avoid.
129 //
130 // No more. Enter template magic to lazily instantiate that method!
131 //
132 // This macro makes the method work as if you'd declared the return / parameter types as normal,
133 // but forces lazy instantiation of the method at the call site, at which point the caller (not
134 // the declaration) had better have a full declaration of the return / parameter types.
135 //
136 // Simply pass the forward-declared types to the macro, with an alias for each, and then define
137 // your function as you otherwise would have but using the aliased name. Why the alias? So you
138 // can be lazy on templated types! Sample usage:
139 //
140 // struct Foo; // No need to define Foo!
141 // template<typename T>
142 // struct A {
143 //     Foo declared(Bar); // Forward declarations of Foo and Bar are sufficient here.
144 //     // The below code would normally require a definition of Foo and Bar.
145 //     WTF_LAZY_INSTANTIATE(Foo=Foo, Bar=Bar) Foo forwarder(Bar b) { return declared(b); }
146 // };
147 #define WTF_LAZY_JOIN_UNLAZE(A, B) A##B
148 #define WTF_LAZY_JOIN(A, B) WTF_LAZY_JOIN_UNLAZE(A, B)
149 #define WTF_LAZY_ARGUMENT_NUMBER(_1, _2, _3, _4, _5, _6, _7, _8, N, ...) N
150 #define WTF_LAZY_AUGMENT(...) unused, __VA_ARGS__
151 #define WTF_LAZY_EXPAND(x) x
152 #define WTF_LAZY_NUM_ARGS_(...) WTF_LAZY_EXPAND(WTF_LAZY_ARGUMENT_NUMBER(__VA_ARGS__, 7, 6, 5, 4, 3, 2, 1, 0))
153 #define WTF_LAZY_NUM_ARGS(...) WTF_LAZY_NUM_ARGS_(WTF_LAZY_AUGMENT(__VA_ARGS__))
154 #define WTF_LAZY_FOR_EACH_TERM(F, ...) \
155     WTF_LAZY_JOIN(WTF_LAZY_FOR_EACH_TERM_, WTF_LAZY_NUM_ARGS(__VA_ARGS__))(F, (__VA_ARGS__))
156 #define WTF_LAZY_FIRST(_1, ...) _1
157 #define WTF_LAZY_REST(_1, ...) (__VA_ARGS__)
158 #define WTF_LAZY_REST_(_1, ...) __VA_ARGS__
159 #define WTF_LAZY_CALL(F, ARG) F(ARG)
160 #define WTF_LAZY_FOR_EACH_TERM_0(...)
161 #define WTF_LAZY_FOR_EACH_TERM_1(F, ARGS) WTF_LAZY_CALL(F, WTF_LAZY_FIRST ARGS) WTF_LAZY_FOR_EACH_TERM_0(F, WTF_LAZY_REST ARGS)
162 #define WTF_LAZY_FOR_EACH_TERM_2(F, ARGS) WTF_LAZY_CALL(F, WTF_LAZY_FIRST ARGS) WTF_LAZY_FOR_EACH_TERM_1(F, WTF_LAZY_REST ARGS)
163 #define WTF_LAZY_FOR_EACH_TERM_3(F, ARGS) WTF_LAZY_CALL(F, WTF_LAZY_FIRST ARGS) WTF_LAZY_FOR_EACH_TERM_2(F, WTF_LAZY_REST ARGS)
164 #define WTF_LAZY_FOR_EACH_TERM_4(F, ARGS) WTF_LAZY_CALL(F, WTF_LAZY_FIRST ARGS) WTF_LAZY_FOR_EACH_TERM_3(F, WTF_LAZY_REST ARGS)
165 #define WTF_LAZY_FOR_EACH_TERM_5(F, ARGS) WTF_LAZY_CALL(F, WTF_LAZY_FIRST ARGS) WTF_LAZY_FOR_EACH_TERM_4(F, WTF_LAZY_REST ARGS)
166 #define WTF_LAZY_FOR_EACH_TERM_6(F, ARGS) WTF_LAZY_CALL(F, WTF_LAZY_FIRST ARGS) WTF_LAZY_FOR_EACH_TERM_5(F, WTF_LAZY_REST ARGS)
167 #define WTF_LAZY_FOR_EACH_TERM_7(F, ARGS) WTF_LAZY_CALL(F, WTF_LAZY_FIRST ARGS) WTF_LAZY_FOR_EACH_TERM_6(F, WTF_LAZY_REST ARGS)
168 #define WTF_LAZY_DECLARE_ALIAS_AND_TYPE(ALIAS_AND_TYPE) typename ALIAS_AND_TYPE,
169 #define WTF_LAZY_INSTANTIATE(...)                                        \
170     template<                                                            \
171     WTF_LAZY_FOR_EACH_TERM(WTF_LAZY_DECLARE_ALIAS_AND_TYPE, __VA_ARGS__) \
172     typename = void>
173
174 #define WTF_LAZY_HAS_REST_0(...)
175 #define WTF_LAZY_HAS_REST_1(...)
176 #define WTF_LAZY_HAS_REST_2 WTF_LAZY_EXPAND
177 #define WTF_LAZY_HAS_REST_3 WTF_LAZY_EXPAND
178 #define WTF_LAZY_HAS_REST_4 WTF_LAZY_EXPAND
179 #define WTF_LAZY_HAS_REST_5 WTF_LAZY_EXPAND
180 #define WTF_LAZY_HAS_REST_6 WTF_LAZY_EXPAND
181 #define WTF_LAZY_HAS_REST_7 WTF_LAZY_EXPAND
182 #define WTF_LAZY_HAS_REST_8 WTF_LAZY_EXPAND
183 #define WTF_LAZY_HAS_REST(...) \
184     WTF_LAZY_JOIN(WTF_LAZY_HAS_REST_, WTF_LAZY_NUM_ARGS(__VA_ARGS__))