File: | tools/clang/utils/TableGen/ClangOptionDocEmitter.cpp |
Warning: | line 140, column 1 Potential memory leak |
Press '?' to see keyboard shortcuts
Keyboard shortcuts:
1 | //===- ClangOptionDocEmitter.cpp - Documentation for command line flags ---===// | |||
2 | // | |||
3 | // The LLVM Compiler Infrastructure | |||
4 | // | |||
5 | // This file is distributed under the University of Illinois Open Source | |||
6 | // License. See LICENSE.TXT for details. | |||
7 | // | |||
8 | // FIXME: Once this has stabilized, consider moving it to LLVM. | |||
9 | // | |||
10 | //===----------------------------------------------------------------------===// | |||
11 | ||||
12 | #include "llvm/TableGen/Error.h" | |||
13 | #include "llvm/ADT/STLExtras.h" | |||
14 | #include "llvm/ADT/SmallString.h" | |||
15 | #include "llvm/ADT/StringSwitch.h" | |||
16 | #include "llvm/ADT/Twine.h" | |||
17 | #include "llvm/TableGen/Record.h" | |||
18 | #include "llvm/TableGen/TableGenBackend.h" | |||
19 | #include <cctype> | |||
20 | #include <cstring> | |||
21 | #include <map> | |||
22 | ||||
23 | using namespace llvm; | |||
24 | ||||
25 | namespace clang { | |||
26 | namespace docs { | |||
27 | namespace { | |||
28 | struct DocumentedOption { | |||
29 | Record *Option; | |||
30 | std::vector<Record*> Aliases; | |||
31 | }; | |||
32 | struct DocumentedGroup; | |||
33 | struct Documentation { | |||
34 | std::vector<DocumentedGroup> Groups; | |||
35 | std::vector<DocumentedOption> Options; | |||
36 | }; | |||
37 | struct DocumentedGroup : Documentation { | |||
38 | Record *Group; | |||
39 | }; | |||
40 | ||||
41 | // Reorganize the records into a suitable form for emitting documentation. | |||
42 | Documentation extractDocumentation(RecordKeeper &Records) { | |||
43 | Documentation Result; | |||
44 | ||||
45 | // Build the tree of groups. The root in the tree is the fake option group | |||
46 | // (Record*)nullptr, which contains all top-level groups and options. | |||
47 | std::map<Record*, std::vector<Record*> > OptionsInGroup; | |||
48 | std::map<Record*, std::vector<Record*> > GroupsInGroup; | |||
49 | std::map<Record*, std::vector<Record*> > Aliases; | |||
50 | ||||
51 | std::map<std::string, Record*> OptionsByName; | |||
52 | for (Record *R : Records.getAllDerivedDefinitions("Option")) | |||
53 | OptionsByName[R->getValueAsString("Name")] = R; | |||
54 | ||||
55 | auto Flatten = [](Record *R) { | |||
56 | return R->getValue("DocFlatten") && R->getValueAsBit("DocFlatten"); | |||
57 | }; | |||
58 | ||||
59 | auto SkipFlattened = [&](Record *R) -> Record* { | |||
60 | while (R && Flatten(R)) { | |||
61 | auto *G = dyn_cast<DefInit>(R->getValueInit("Group")); | |||
62 | if (!G) | |||
63 | return nullptr; | |||
64 | R = G->getDef(); | |||
65 | } | |||
66 | return R; | |||
67 | }; | |||
68 | ||||
69 | for (Record *R : Records.getAllDerivedDefinitions("OptionGroup")) { | |||
70 | if (Flatten(R)) | |||
71 | continue; | |||
72 | ||||
73 | Record *Group = nullptr; | |||
74 | if (auto *G = dyn_cast<DefInit>(R->getValueInit("Group"))) | |||
75 | Group = SkipFlattened(G->getDef()); | |||
76 | GroupsInGroup[Group].push_back(R); | |||
77 | } | |||
78 | ||||
79 | for (Record *R : Records.getAllDerivedDefinitions("Option")) { | |||
80 | if (auto *A = dyn_cast<DefInit>(R->getValueInit("Alias"))) { | |||
81 | Aliases[A->getDef()].push_back(R); | |||
82 | continue; | |||
83 | } | |||
84 | ||||
85 | // Pretend no-X and Xno-Y options are aliases of X and XY. | |||
86 | std::string Name = R->getValueAsString("Name"); | |||
87 | if (Name.size() >= 4) { | |||
88 | if (Name.substr(0, 3) == "no-" && OptionsByName[Name.substr(3)]) { | |||
89 | Aliases[OptionsByName[Name.substr(3)]].push_back(R); | |||
90 | continue; | |||
91 | } | |||
92 | if (Name.substr(1, 3) == "no-" && OptionsByName[Name[0] + Name.substr(4)]) { | |||
93 | Aliases[OptionsByName[Name[0] + Name.substr(4)]].push_back(R); | |||
94 | continue; | |||
95 | } | |||
96 | } | |||
97 | ||||
98 | Record *Group = nullptr; | |||
99 | if (auto *G = dyn_cast<DefInit>(R->getValueInit("Group"))) | |||
100 | Group = SkipFlattened(G->getDef()); | |||
101 | OptionsInGroup[Group].push_back(R); | |||
102 | } | |||
103 | ||||
104 | auto CompareByName = [](Record *A, Record *B) { | |||
105 | return A->getValueAsString("Name") < B->getValueAsString("Name"); | |||
106 | }; | |||
107 | ||||
108 | auto CompareByLocation = [](Record *A, Record *B) { | |||
109 | return A->getLoc()[0].getPointer() < B->getLoc()[0].getPointer(); | |||
110 | }; | |||
111 | ||||
112 | auto DocumentationForOption = [&](Record *R) -> DocumentedOption { | |||
113 | auto &A = Aliases[R]; | |||
114 | llvm::sort(A.begin(), A.end(), CompareByName); | |||
115 | return {R, std::move(A)}; | |||
116 | }; | |||
117 | ||||
118 | std::function<Documentation(Record *)> DocumentationForGroup = | |||
119 | [&](Record *R) -> Documentation { | |||
120 | Documentation D; | |||
121 | ||||
122 | auto &Groups = GroupsInGroup[R]; | |||
123 | llvm::sort(Groups.begin(), Groups.end(), CompareByLocation); | |||
124 | for (Record *G : Groups) { | |||
125 | D.Groups.emplace_back(); | |||
126 | D.Groups.back().Group = G; | |||
127 | Documentation &Base = D.Groups.back(); | |||
128 | Base = DocumentationForGroup(G); | |||
129 | } | |||
130 | ||||
131 | auto &Options = OptionsInGroup[R]; | |||
132 | llvm::sort(Options.begin(), Options.end(), CompareByName); | |||
133 | for (Record *O : Options) | |||
134 | D.Options.push_back(DocumentationForOption(O)); | |||
135 | ||||
136 | return D; | |||
137 | }; | |||
138 | ||||
139 | return DocumentationForGroup(nullptr); | |||
140 | } | |||
| ||||
141 | ||||
142 | // Get the first and successive separators to use for an OptionKind. | |||
143 | std::pair<StringRef,StringRef> getSeparatorsForKind(const Record *OptionKind) { | |||
144 | return StringSwitch<std::pair<StringRef, StringRef>>(OptionKind->getName()) | |||
145 | .Cases("KIND_JOINED", "KIND_JOINED_OR_SEPARATE", | |||
146 | "KIND_JOINED_AND_SEPARATE", | |||
147 | "KIND_REMAINING_ARGS_JOINED", {"", " "}) | |||
148 | .Case("KIND_COMMAJOINED", {"", ","}) | |||
149 | .Default({" ", " "}); | |||
150 | } | |||
151 | ||||
152 | const unsigned UnlimitedArgs = unsigned(-1); | |||
153 | ||||
154 | // Get the number of arguments expected for an option, or -1 if any number of | |||
155 | // arguments are accepted. | |||
156 | unsigned getNumArgsForKind(Record *OptionKind, const Record *Option) { | |||
157 | return StringSwitch<unsigned>(OptionKind->getName()) | |||
158 | .Cases("KIND_JOINED", "KIND_JOINED_OR_SEPARATE", "KIND_SEPARATE", 1) | |||
159 | .Cases("KIND_REMAINING_ARGS", "KIND_REMAINING_ARGS_JOINED", | |||
160 | "KIND_COMMAJOINED", UnlimitedArgs) | |||
161 | .Case("KIND_JOINED_AND_SEPARATE", 2) | |||
162 | .Case("KIND_MULTIARG", Option->getValueAsInt("NumArgs")) | |||
163 | .Default(0); | |||
164 | } | |||
165 | ||||
166 | bool hasFlag(const Record *OptionOrGroup, StringRef OptionFlag) { | |||
167 | for (const Record *Flag : OptionOrGroup->getValueAsListOfDefs("Flags")) | |||
168 | if (Flag->getName() == OptionFlag) | |||
169 | return true; | |||
170 | return false; | |||
171 | } | |||
172 | ||||
173 | bool isExcluded(const Record *OptionOrGroup, const Record *DocInfo) { | |||
174 | // FIXME: Provide a flag to specify the set of exclusions. | |||
175 | for (StringRef Exclusion : DocInfo->getValueAsListOfStrings("ExcludedFlags")) | |||
176 | if (hasFlag(OptionOrGroup, Exclusion)) | |||
177 | return true; | |||
178 | return false; | |||
179 | } | |||
180 | ||||
181 | std::string escapeRST(StringRef Str) { | |||
182 | std::string Out; | |||
183 | for (auto K : Str) { | |||
184 | if (StringRef("`*|_[]\\").count(K)) | |||
185 | Out.push_back('\\'); | |||
186 | Out.push_back(K); | |||
187 | } | |||
188 | return Out; | |||
189 | } | |||
190 | ||||
191 | StringRef getSphinxOptionID(StringRef OptionName) { | |||
192 | for (auto I = OptionName.begin(), E = OptionName.end(); I != E; ++I) | |||
193 | if (!isalnum(*I) && *I != '-') | |||
194 | return OptionName.substr(0, I - OptionName.begin()); | |||
195 | return OptionName; | |||
196 | } | |||
197 | ||||
198 | bool canSphinxCopeWithOption(const Record *Option) { | |||
199 | // HACK: Work arond sphinx's inability to cope with punctuation-only options | |||
200 | // such as /? by suppressing them from the option list. | |||
201 | for (char C : Option->getValueAsString("Name")) | |||
202 | if (isalnum(C)) | |||
203 | return true; | |||
204 | return false; | |||
205 | } | |||
206 | ||||
207 | void emitHeading(int Depth, std::string Heading, raw_ostream &OS) { | |||
208 | assert(Depth < 8 && "groups nested too deeply")(static_cast <bool> (Depth < 8 && "groups nested too deeply" ) ? void (0) : __assert_fail ("Depth < 8 && \"groups nested too deeply\"" , "/build/llvm-toolchain-snapshot-7~svn329677/tools/clang/utils/TableGen/ClangOptionDocEmitter.cpp" , 208, __extension__ __PRETTY_FUNCTION__)); | |||
209 | OS << Heading << '\n' | |||
210 | << std::string(Heading.size(), "=~-_'+<>"[Depth]) << "\n"; | |||
211 | } | |||
212 | ||||
213 | /// Get the value of field \p Primary, if possible. If \p Primary does not | |||
214 | /// exist, get the value of \p Fallback and escape it for rST emission. | |||
215 | std::string getRSTStringWithTextFallback(const Record *R, StringRef Primary, | |||
216 | StringRef Fallback) { | |||
217 | for (auto Field : {Primary, Fallback}) { | |||
218 | if (auto *V = R->getValue(Field)) { | |||
219 | StringRef Value; | |||
220 | if (auto *SV = dyn_cast_or_null<StringInit>(V->getValue())) | |||
221 | Value = SV->getValue(); | |||
222 | else if (auto *CV = dyn_cast_or_null<CodeInit>(V->getValue())) | |||
223 | Value = CV->getValue(); | |||
224 | if (!Value.empty()) | |||
225 | return Field == Primary ? Value.str() : escapeRST(Value); | |||
226 | } | |||
227 | } | |||
228 | return StringRef(); | |||
229 | } | |||
230 | ||||
231 | void emitOptionWithArgs(StringRef Prefix, const Record *Option, | |||
232 | ArrayRef<StringRef> Args, raw_ostream &OS) { | |||
233 | OS << Prefix << escapeRST(Option->getValueAsString("Name")); | |||
234 | ||||
235 | std::pair<StringRef, StringRef> Separators = | |||
236 | getSeparatorsForKind(Option->getValueAsDef("Kind")); | |||
237 | ||||
238 | StringRef Separator = Separators.first; | |||
239 | for (auto Arg : Args) { | |||
240 | OS << Separator << escapeRST(Arg); | |||
241 | Separator = Separators.second; | |||
242 | } | |||
243 | } | |||
244 | ||||
245 | void emitOptionName(StringRef Prefix, const Record *Option, raw_ostream &OS) { | |||
246 | // Find the arguments to list after the option. | |||
247 | unsigned NumArgs = getNumArgsForKind(Option->getValueAsDef("Kind"), Option); | |||
248 | bool HasMetaVarName = !Option->isValueUnset("MetaVarName"); | |||
249 | ||||
250 | std::vector<std::string> Args; | |||
251 | if (HasMetaVarName) | |||
252 | Args.push_back(Option->getValueAsString("MetaVarName")); | |||
253 | else if (NumArgs == 1) | |||
254 | Args.push_back("<arg>"); | |||
255 | ||||
256 | // Fill up arguments if this option didn't provide a meta var name or it | |||
257 | // supports an unlimited number of arguments. We can't see how many arguments | |||
258 | // already are in a meta var name, so assume it has right number. This is | |||
259 | // needed for JoinedAndSeparate options so that there arent't too many | |||
260 | // arguments. | |||
261 | if (!HasMetaVarName || NumArgs == UnlimitedArgs) { | |||
262 | while (Args.size() < NumArgs) { | |||
263 | Args.push_back(("<arg" + Twine(Args.size() + 1) + ">").str()); | |||
264 | // Use '--args <arg1> <arg2>...' if any number of args are allowed. | |||
265 | if (Args.size() == 2 && NumArgs == UnlimitedArgs) { | |||
266 | Args.back() += "..."; | |||
267 | break; | |||
268 | } | |||
269 | } | |||
270 | } | |||
271 | ||||
272 | emitOptionWithArgs(Prefix, Option, std::vector<StringRef>(Args.begin(), Args.end()), OS); | |||
273 | ||||
274 | auto AliasArgs = Option->getValueAsListOfStrings("AliasArgs"); | |||
275 | if (!AliasArgs.empty()) { | |||
276 | Record *Alias = Option->getValueAsDef("Alias"); | |||
277 | OS << " (equivalent to "; | |||
278 | emitOptionWithArgs( | |||
279 | Alias->getValueAsListOfStrings("Prefixes").front(), Alias, | |||
280 | AliasArgs, OS); | |||
281 | OS << ")"; | |||
282 | } | |||
283 | } | |||
284 | ||||
285 | bool emitOptionNames(const Record *Option, raw_ostream &OS, bool EmittedAny) { | |||
286 | for (auto &Prefix : Option->getValueAsListOfStrings("Prefixes")) { | |||
287 | if (EmittedAny) | |||
288 | OS << ", "; | |||
289 | emitOptionName(Prefix, Option, OS); | |||
290 | EmittedAny = true; | |||
291 | } | |||
292 | return EmittedAny; | |||
293 | } | |||
294 | ||||
295 | template <typename Fn> | |||
296 | void forEachOptionName(const DocumentedOption &Option, const Record *DocInfo, | |||
297 | Fn F) { | |||
298 | F(Option.Option); | |||
299 | ||||
300 | for (auto *Alias : Option.Aliases) | |||
301 | if (!isExcluded(Alias, DocInfo) && canSphinxCopeWithOption(Option.Option)) | |||
302 | F(Alias); | |||
303 | } | |||
304 | ||||
305 | void emitOption(const DocumentedOption &Option, const Record *DocInfo, | |||
306 | raw_ostream &OS) { | |||
307 | if (isExcluded(Option.Option, DocInfo)) | |||
308 | return; | |||
309 | if (Option.Option->getValueAsDef("Kind")->getName() == "KIND_UNKNOWN" || | |||
310 | Option.Option->getValueAsDef("Kind")->getName() == "KIND_INPUT") | |||
311 | return; | |||
312 | if (!canSphinxCopeWithOption(Option.Option)) | |||
313 | return; | |||
314 | ||||
315 | // HACK: Emit a different program name with each option to work around | |||
316 | // sphinx's inability to cope with options that differ only by punctuation | |||
317 | // (eg -ObjC vs -ObjC++, -G vs -G=). | |||
318 | std::vector<std::string> SphinxOptionIDs; | |||
319 | forEachOptionName(Option, DocInfo, [&](const Record *Option) { | |||
320 | for (auto &Prefix : Option->getValueAsListOfStrings("Prefixes")) | |||
321 | SphinxOptionIDs.push_back( | |||
322 | getSphinxOptionID((Prefix + Option->getValueAsString("Name")).str())); | |||
323 | }); | |||
324 | assert(!SphinxOptionIDs.empty() && "no flags for option")(static_cast <bool> (!SphinxOptionIDs.empty() && "no flags for option") ? void (0) : __assert_fail ("!SphinxOptionIDs.empty() && \"no flags for option\"" , "/build/llvm-toolchain-snapshot-7~svn329677/tools/clang/utils/TableGen/ClangOptionDocEmitter.cpp" , 324, __extension__ __PRETTY_FUNCTION__)); | |||
325 | static std::map<std::string, int> NextSuffix; | |||
326 | int SphinxWorkaroundSuffix = NextSuffix[*std::max_element( | |||
327 | SphinxOptionIDs.begin(), SphinxOptionIDs.end(), | |||
328 | [&](const std::string &A, const std::string &B) { | |||
329 | return NextSuffix[A] < NextSuffix[B]; | |||
330 | })]; | |||
331 | for (auto &S : SphinxOptionIDs) | |||
332 | NextSuffix[S] = SphinxWorkaroundSuffix + 1; | |||
333 | if (SphinxWorkaroundSuffix) | |||
334 | OS << ".. program:: " << DocInfo->getValueAsString("Program") | |||
335 | << SphinxWorkaroundSuffix << "\n"; | |||
336 | ||||
337 | // Emit the names of the option. | |||
338 | OS << ".. option:: "; | |||
339 | bool EmittedAny = false; | |||
340 | forEachOptionName(Option, DocInfo, [&](const Record *Option) { | |||
341 | EmittedAny = emitOptionNames(Option, OS, EmittedAny); | |||
342 | }); | |||
343 | if (SphinxWorkaroundSuffix) | |||
344 | OS << "\n.. program:: " << DocInfo->getValueAsString("Program"); | |||
345 | OS << "\n\n"; | |||
346 | ||||
347 | // Emit the description, if we have one. | |||
348 | std::string Description = | |||
349 | getRSTStringWithTextFallback(Option.Option, "DocBrief", "HelpText"); | |||
350 | if (!Description.empty()) | |||
351 | OS << Description << "\n\n"; | |||
352 | } | |||
353 | ||||
354 | void emitDocumentation(int Depth, const Documentation &Doc, | |||
355 | const Record *DocInfo, raw_ostream &OS); | |||
356 | ||||
357 | void emitGroup(int Depth, const DocumentedGroup &Group, const Record *DocInfo, | |||
358 | raw_ostream &OS) { | |||
359 | if (isExcluded(Group.Group, DocInfo)) | |||
360 | return; | |||
361 | ||||
362 | emitHeading(Depth, | |||
363 | getRSTStringWithTextFallback(Group.Group, "DocName", "Name"), OS); | |||
364 | ||||
365 | // Emit the description, if we have one. | |||
366 | std::string Description = | |||
367 | getRSTStringWithTextFallback(Group.Group, "DocBrief", "HelpText"); | |||
368 | if (!Description.empty()) | |||
369 | OS << Description << "\n\n"; | |||
370 | ||||
371 | // Emit contained options and groups. | |||
372 | emitDocumentation(Depth + 1, Group, DocInfo, OS); | |||
373 | } | |||
374 | ||||
375 | void emitDocumentation(int Depth, const Documentation &Doc, | |||
376 | const Record *DocInfo, raw_ostream &OS) { | |||
377 | for (auto &O : Doc.Options) | |||
378 | emitOption(O, DocInfo, OS); | |||
379 | for (auto &G : Doc.Groups) | |||
380 | emitGroup(Depth, G, DocInfo, OS); | |||
381 | } | |||
382 | ||||
383 | } // namespace | |||
384 | } // namespace docs | |||
385 | ||||
386 | void EmitClangOptDocs(RecordKeeper &Records, raw_ostream &OS) { | |||
387 | using namespace docs; | |||
388 | ||||
389 | const Record *DocInfo = Records.getDef("GlobalDocumentation"); | |||
390 | if (!DocInfo) { | |||
| ||||
391 | PrintFatalError("The GlobalDocumentation top-level definition is missing, " | |||
392 | "no documentation will be generated."); | |||
393 | return; | |||
394 | } | |||
395 | OS << DocInfo->getValueAsString("Intro") << "\n"; | |||
396 | OS << ".. program:: " << DocInfo->getValueAsString("Program") << "\n"; | |||
397 | ||||
398 | emitDocumentation(0, extractDocumentation(Records), DocInfo, OS); | |||
399 | } | |||
400 | } // end namespace clang |
1 | // Implementation of std::function -*- C++ -*- |
2 | |
3 | // Copyright (C) 2004-2017 Free Software Foundation, Inc. |
4 | // |
5 | // This file is part of the GNU ISO C++ Library. This library is free |
6 | // software; you can redistribute it and/or modify it under the |
7 | // terms of the GNU General Public License as published by the |
8 | // Free Software Foundation; either version 3, or (at your option) |
9 | // any later version. |
10 | |
11 | // This library is distributed in the hope that it will be useful, |
12 | // but WITHOUT ANY WARRANTY; without even the implied warranty of |
13 | // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
14 | // GNU General Public License for more details. |
15 | |
16 | // Under Section 7 of GPL version 3, you are granted additional |
17 | // permissions described in the GCC Runtime Library Exception, version |
18 | // 3.1, as published by the Free Software Foundation. |
19 | |
20 | // You should have received a copy of the GNU General Public License and |
21 | // a copy of the GCC Runtime Library Exception along with this program; |
22 | // see the files COPYING3 and COPYING.RUNTIME respectively. If not, see |
23 | // <http://www.gnu.org/licenses/>. |
24 | |
25 | /** @file include/bits/function.h |
26 | * This is an internal header file, included by other library headers. |
27 | * Do not attempt to use it directly. @headername{functional} |
28 | */ |
29 | |
30 | #ifndef _GLIBCXX_STD_FUNCTION_H1 |
31 | #define _GLIBCXX_STD_FUNCTION_H1 1 |
32 | |
33 | #pragma GCC system_header |
34 | |
35 | #if __cplusplus201103L < 201103L |
36 | # include <bits/c++0x_warning.h> |
37 | #else |
38 | |
39 | #if __cpp_rtti199711 |
40 | # include <typeinfo> |
41 | #endif |
42 | #include <bits/stl_function.h> |
43 | #include <bits/invoke.h> |
44 | #include <bits/refwrap.h> |
45 | #include <bits/functexcept.h> |
46 | |
47 | namespace std _GLIBCXX_VISIBILITY(default)__attribute__ ((__visibility__ ("default"))) |
48 | { |
49 | _GLIBCXX_BEGIN_NAMESPACE_VERSION |
50 | |
51 | /** |
52 | * Derives from @c unary_function or @c binary_function, or perhaps |
53 | * nothing, depending on the number of arguments provided. The |
54 | * primary template is the basis case, which derives nothing. |
55 | */ |
56 | template<typename _Res, typename... _ArgTypes> |
57 | struct _Maybe_unary_or_binary_function { }; |
58 | |
59 | /// Derives from @c unary_function, as appropriate. |
60 | template<typename _Res, typename _T1> |
61 | struct _Maybe_unary_or_binary_function<_Res, _T1> |
62 | : std::unary_function<_T1, _Res> { }; |
63 | |
64 | /// Derives from @c binary_function, as appropriate. |
65 | template<typename _Res, typename _T1, typename _T2> |
66 | struct _Maybe_unary_or_binary_function<_Res, _T1, _T2> |
67 | : std::binary_function<_T1, _T2, _Res> { }; |
68 | |
69 | |
70 | /** |
71 | * @brief Exception class thrown when class template function's |
72 | * operator() is called with an empty target. |
73 | * @ingroup exceptions |
74 | */ |
75 | class bad_function_call : public std::exception |
76 | { |
77 | public: |
78 | virtual ~bad_function_call() noexcept; |
79 | |
80 | const char* what() const noexcept; |
81 | }; |
82 | |
83 | /** |
84 | * Trait identifying "location-invariant" types, meaning that the |
85 | * address of the object (or any of its members) will not escape. |
86 | * Trivially copyable types are location-invariant and users can |
87 | * specialize this trait for other types. |
88 | */ |
89 | template<typename _Tp> |
90 | struct __is_location_invariant |
91 | : is_trivially_copyable<_Tp>::type |
92 | { }; |
93 | |
94 | class _Undefined_class; |
95 | |
96 | union _Nocopy_types |
97 | { |
98 | void* _M_object; |
99 | const void* _M_const_object; |
100 | void (*_M_function_pointer)(); |
101 | void (_Undefined_class::*_M_member_pointer)(); |
102 | }; |
103 | |
104 | union [[gnu::may_alias]] _Any_data |
105 | { |
106 | void* _M_access() { return &_M_pod_data[0]; } |
107 | const void* _M_access() const { return &_M_pod_data[0]; } |
108 | |
109 | template<typename _Tp> |
110 | _Tp& |
111 | _M_access() |
112 | { return *static_cast<_Tp*>(_M_access()); } |
113 | |
114 | template<typename _Tp> |
115 | const _Tp& |
116 | _M_access() const |
117 | { return *static_cast<const _Tp*>(_M_access()); } |
118 | |
119 | _Nocopy_types _M_unused; |
120 | char _M_pod_data[sizeof(_Nocopy_types)]; |
121 | }; |
122 | |
123 | enum _Manager_operation |
124 | { |
125 | __get_type_info, |
126 | __get_functor_ptr, |
127 | __clone_functor, |
128 | __destroy_functor |
129 | }; |
130 | |
131 | // Simple type wrapper that helps avoid annoying const problems |
132 | // when casting between void pointers and pointers-to-pointers. |
133 | template<typename _Tp> |
134 | struct _Simple_type_wrapper |
135 | { |
136 | _Simple_type_wrapper(_Tp __value) : __value(__value) { } |
137 | |
138 | _Tp __value; |
139 | }; |
140 | |
141 | template<typename _Tp> |
142 | struct __is_location_invariant<_Simple_type_wrapper<_Tp> > |
143 | : __is_location_invariant<_Tp> |
144 | { }; |
145 | |
146 | template<typename _Signature> |
147 | class function; |
148 | |
149 | /// Base class of all polymorphic function object wrappers. |
150 | class _Function_base |
151 | { |
152 | public: |
153 | static const std::size_t _M_max_size = sizeof(_Nocopy_types); |
154 | static const std::size_t _M_max_align = __alignof__(_Nocopy_types); |
155 | |
156 | template<typename _Functor> |
157 | class _Base_manager |
158 | { |
159 | protected: |
160 | static const bool __stored_locally = |
161 | (__is_location_invariant<_Functor>::value |
162 | && sizeof(_Functor) <= _M_max_size |
163 | && __alignof__(_Functor) <= _M_max_align |
164 | && (_M_max_align % __alignof__(_Functor) == 0)); |
165 | |
166 | typedef integral_constant<bool, __stored_locally> _Local_storage; |
167 | |
168 | // Retrieve a pointer to the function object |
169 | static _Functor* |
170 | _M_get_pointer(const _Any_data& __source) |
171 | { |
172 | const _Functor* __ptr = |
173 | __stored_locally? std::__addressof(__source._M_access<_Functor>()) |
174 | /* have stored a pointer */ : __source._M_access<_Functor*>(); |
175 | return const_cast<_Functor*>(__ptr); |
176 | } |
177 | |
178 | // Clone a location-invariant function object that fits within |
179 | // an _Any_data structure. |
180 | static void |
181 | _M_clone(_Any_data& __dest, const _Any_data& __source, true_type) |
182 | { |
183 | ::new (__dest._M_access()) _Functor(__source._M_access<_Functor>()); |
184 | } |
185 | |
186 | // Clone a function object that is not location-invariant or |
187 | // that cannot fit into an _Any_data structure. |
188 | static void |
189 | _M_clone(_Any_data& __dest, const _Any_data& __source, false_type) |
190 | { |
191 | __dest._M_access<_Functor*>() = |
192 | new _Functor(*__source._M_access<_Functor*>()); |
193 | } |
194 | |
195 | // Destroying a location-invariant object may still require |
196 | // destruction. |
197 | static void |
198 | _M_destroy(_Any_data& __victim, true_type) |
199 | { |
200 | __victim._M_access<_Functor>().~_Functor(); |
201 | } |
202 | |
203 | // Destroying an object located on the heap. |
204 | static void |
205 | _M_destroy(_Any_data& __victim, false_type) |
206 | { |
207 | delete __victim._M_access<_Functor*>(); |
208 | } |
209 | |
210 | public: |
211 | static bool |
212 | _M_manager(_Any_data& __dest, const _Any_data& __source, |
213 | _Manager_operation __op) |
214 | { |
215 | switch (__op) |
216 | { |
217 | #if __cpp_rtti199711 |
218 | case __get_type_info: |
219 | __dest._M_access<const type_info*>() = &typeid(_Functor); |
220 | break; |
221 | #endif |
222 | case __get_functor_ptr: |
223 | __dest._M_access<_Functor*>() = _M_get_pointer(__source); |
224 | break; |
225 | |
226 | case __clone_functor: |
227 | _M_clone(__dest, __source, _Local_storage()); |
228 | break; |
229 | |
230 | case __destroy_functor: |
231 | _M_destroy(__dest, _Local_storage()); |
232 | break; |
233 | } |
234 | return false; |
235 | } |
236 | |
237 | static void |
238 | _M_init_functor(_Any_data& __functor, _Functor&& __f) |
239 | { _M_init_functor(__functor, std::move(__f), _Local_storage()); } |
240 | |
241 | template<typename _Signature> |
242 | static bool |
243 | _M_not_empty_function(const function<_Signature>& __f) |
244 | { return static_cast<bool>(__f); } |
245 | |
246 | template<typename _Tp> |
247 | static bool |
248 | _M_not_empty_function(_Tp* __fp) |
249 | { return __fp != nullptr; } |
250 | |
251 | template<typename _Class, typename _Tp> |
252 | static bool |
253 | _M_not_empty_function(_Tp _Class::* __mp) |
254 | { return __mp != nullptr; } |
255 | |
256 | template<typename _Tp> |
257 | static bool |
258 | _M_not_empty_function(const _Tp&) |
259 | { return true; } |
260 | |
261 | private: |
262 | static void |
263 | _M_init_functor(_Any_data& __functor, _Functor&& __f, true_type) |
264 | { ::new (__functor._M_access()) _Functor(std::move(__f)); } |
265 | |
266 | static void |
267 | _M_init_functor(_Any_data& __functor, _Functor&& __f, false_type) |
268 | { __functor._M_access<_Functor*>() = new _Functor(std::move(__f)); } |
269 | }; |
270 | |
271 | _Function_base() : _M_manager(nullptr) { } |
272 | |
273 | ~_Function_base() |
274 | { |
275 | if (_M_manager) |
276 | _M_manager(_M_functor, _M_functor, __destroy_functor); |
277 | } |
278 | |
279 | bool _M_empty() const { return !_M_manager; } |
280 | |
281 | typedef bool (*_Manager_type)(_Any_data&, const _Any_data&, |
282 | _Manager_operation); |
283 | |
284 | _Any_data _M_functor; |
285 | _Manager_type _M_manager; |
286 | }; |
287 | |
288 | template<typename _Signature, typename _Functor> |
289 | class _Function_handler; |
290 | |
291 | template<typename _Res, typename _Functor, typename... _ArgTypes> |
292 | class _Function_handler<_Res(_ArgTypes...), _Functor> |
293 | : public _Function_base::_Base_manager<_Functor> |
294 | { |
295 | typedef _Function_base::_Base_manager<_Functor> _Base; |
296 | |
297 | public: |
298 | static _Res |
299 | _M_invoke(const _Any_data& __functor, _ArgTypes&&... __args) |
300 | { |
301 | return (*_Base::_M_get_pointer(__functor))( |
302 | std::forward<_ArgTypes>(__args)...); |
303 | } |
304 | }; |
305 | |
306 | template<typename _Functor, typename... _ArgTypes> |
307 | class _Function_handler<void(_ArgTypes...), _Functor> |
308 | : public _Function_base::_Base_manager<_Functor> |
309 | { |
310 | typedef _Function_base::_Base_manager<_Functor> _Base; |
311 | |
312 | public: |
313 | static void |
314 | _M_invoke(const _Any_data& __functor, _ArgTypes&&... __args) |
315 | { |
316 | (*_Base::_M_get_pointer(__functor))( |
317 | std::forward<_ArgTypes>(__args)...); |
318 | } |
319 | }; |
320 | |
321 | template<typename _Class, typename _Member, typename _Res, |
322 | typename... _ArgTypes> |
323 | class _Function_handler<_Res(_ArgTypes...), _Member _Class::*> |
324 | : public _Function_handler<void(_ArgTypes...), _Member _Class::*> |
325 | { |
326 | typedef _Function_handler<void(_ArgTypes...), _Member _Class::*> |
327 | _Base; |
328 | |
329 | public: |
330 | static _Res |
331 | _M_invoke(const _Any_data& __functor, _ArgTypes&&... __args) |
332 | { |
333 | return std::__invoke(_Base::_M_get_pointer(__functor)->__value, |
334 | std::forward<_ArgTypes>(__args)...); |
335 | } |
336 | }; |
337 | |
338 | template<typename _Class, typename _Member, typename... _ArgTypes> |
339 | class _Function_handler<void(_ArgTypes...), _Member _Class::*> |
340 | : public _Function_base::_Base_manager< |
341 | _Simple_type_wrapper< _Member _Class::* > > |
342 | { |
343 | typedef _Member _Class::* _Functor; |
344 | typedef _Simple_type_wrapper<_Functor> _Wrapper; |
345 | typedef _Function_base::_Base_manager<_Wrapper> _Base; |
346 | |
347 | public: |
348 | static bool |
349 | _M_manager(_Any_data& __dest, const _Any_data& __source, |
350 | _Manager_operation __op) |
351 | { |
352 | switch (__op) |
353 | { |
354 | #if __cpp_rtti199711 |
355 | case __get_type_info: |
356 | __dest._M_access<const type_info*>() = &typeid(_Functor); |
357 | break; |
358 | #endif |
359 | case __get_functor_ptr: |
360 | __dest._M_access<_Functor*>() = |
361 | &_Base::_M_get_pointer(__source)->__value; |
362 | break; |
363 | |
364 | default: |
365 | _Base::_M_manager(__dest, __source, __op); |
366 | } |
367 | return false; |
368 | } |
369 | |
370 | static void |
371 | _M_invoke(const _Any_data& __functor, _ArgTypes&&... __args) |
372 | { |
373 | std::__invoke(_Base::_M_get_pointer(__functor)->__value, |
374 | std::forward<_ArgTypes>(__args)...); |
375 | } |
376 | }; |
377 | |
378 | template<typename _From, typename _To> |
379 | using __check_func_return_type |
380 | = __or_<is_void<_To>, is_same<_From, _To>, is_convertible<_From, _To>>; |
381 | |
382 | /** |
383 | * @brief Primary class template for std::function. |
384 | * @ingroup functors |
385 | * |
386 | * Polymorphic function wrapper. |
387 | */ |
388 | template<typename _Res, typename... _ArgTypes> |
389 | class function<_Res(_ArgTypes...)> |
390 | : public _Maybe_unary_or_binary_function<_Res, _ArgTypes...>, |
391 | private _Function_base |
392 | { |
393 | template<typename _Func, |
394 | typename _Res2 = typename result_of<_Func&(_ArgTypes...)>::type> |
395 | struct _Callable : __check_func_return_type<_Res2, _Res> { }; |
396 | |
397 | // Used so the return type convertibility checks aren't done when |
398 | // performing overload resolution for copy construction/assignment. |
399 | template<typename _Tp> |
400 | struct _Callable<function, _Tp> : false_type { }; |
401 | |
402 | template<typename _Cond, typename _Tp> |
403 | using _Requires = typename enable_if<_Cond::value, _Tp>::type; |
404 | |
405 | public: |
406 | typedef _Res result_type; |
407 | |
408 | // [3.7.2.1] construct/copy/destroy |
409 | |
410 | /** |
411 | * @brief Default construct creates an empty function call wrapper. |
412 | * @post @c !(bool)*this |
413 | */ |
414 | function() noexcept |
415 | : _Function_base() { } |
416 | |
417 | /** |
418 | * @brief Creates an empty function call wrapper. |
419 | * @post @c !(bool)*this |
420 | */ |
421 | function(nullptr_t) noexcept |
422 | : _Function_base() { } |
423 | |
424 | /** |
425 | * @brief %Function copy constructor. |
426 | * @param __x A %function object with identical call signature. |
427 | * @post @c bool(*this) == bool(__x) |
428 | * |
429 | * The newly-created %function contains a copy of the target of @a |
430 | * __x (if it has one). |
431 | */ |
432 | function(const function& __x); |
433 | |
434 | /** |
435 | * @brief %Function move constructor. |
436 | * @param __x A %function object rvalue with identical call signature. |
437 | * |
438 | * The newly-created %function contains the target of @a __x |
439 | * (if it has one). |
440 | */ |
441 | function(function&& __x) noexcept : _Function_base() |
442 | { |
443 | __x.swap(*this); |
444 | } |
445 | |
446 | /** |
447 | * @brief Builds a %function that targets a copy of the incoming |
448 | * function object. |
449 | * @param __f A %function object that is callable with parameters of |
450 | * type @c T1, @c T2, ..., @c TN and returns a value convertible |
451 | * to @c Res. |
452 | * |
453 | * The newly-created %function object will target a copy of |
454 | * @a __f. If @a __f is @c reference_wrapper<F>, then this function |
455 | * object will contain a reference to the function object @c |
456 | * __f.get(). If @a __f is a NULL function pointer or NULL |
457 | * pointer-to-member, the newly-created object will be empty. |
458 | * |
459 | * If @a __f is a non-NULL function pointer or an object of type @c |
460 | * reference_wrapper<F>, this function will not throw. |
461 | */ |
462 | template<typename _Functor, |
463 | typename = _Requires<__not_<is_same<_Functor, function>>, void>, |
464 | typename = _Requires<_Callable<_Functor>, void>> |
465 | function(_Functor); |
466 | |
467 | /** |
468 | * @brief %Function assignment operator. |
469 | * @param __x A %function with identical call signature. |
470 | * @post @c (bool)*this == (bool)x |
471 | * @returns @c *this |
472 | * |
473 | * The target of @a __x is copied to @c *this. If @a __x has no |
474 | * target, then @c *this will be empty. |
475 | * |
476 | * If @a __x targets a function pointer or a reference to a function |
477 | * object, then this operation will not throw an %exception. |
478 | */ |
479 | function& |
480 | operator=(const function& __x) |
481 | { |
482 | function(__x).swap(*this); |
483 | return *this; |
484 | } |
485 | |
486 | /** |
487 | * @brief %Function move-assignment operator. |
488 | * @param __x A %function rvalue with identical call signature. |
489 | * @returns @c *this |
490 | * |
491 | * The target of @a __x is moved to @c *this. If @a __x has no |
492 | * target, then @c *this will be empty. |
493 | * |
494 | * If @a __x targets a function pointer or a reference to a function |
495 | * object, then this operation will not throw an %exception. |
496 | */ |
497 | function& |
498 | operator=(function&& __x) noexcept |
499 | { |
500 | function(std::move(__x)).swap(*this); |
501 | return *this; |
502 | } |
503 | |
504 | /** |
505 | * @brief %Function assignment to zero. |
506 | * @post @c !(bool)*this |
507 | * @returns @c *this |
508 | * |
509 | * The target of @c *this is deallocated, leaving it empty. |
510 | */ |
511 | function& |
512 | operator=(nullptr_t) noexcept |
513 | { |
514 | if (_M_manager) |
515 | { |
516 | _M_manager(_M_functor, _M_functor, __destroy_functor); |
517 | _M_manager = nullptr; |
518 | _M_invoker = nullptr; |
519 | } |
520 | return *this; |
521 | } |
522 | |
523 | /** |
524 | * @brief %Function assignment to a new target. |
525 | * @param __f A %function object that is callable with parameters of |
526 | * type @c T1, @c T2, ..., @c TN and returns a value convertible |
527 | * to @c Res. |
528 | * @return @c *this |
529 | * |
530 | * This %function object wrapper will target a copy of @a |
531 | * __f. If @a __f is @c reference_wrapper<F>, then this function |
532 | * object will contain a reference to the function object @c |
533 | * __f.get(). If @a __f is a NULL function pointer or NULL |
534 | * pointer-to-member, @c this object will be empty. |
535 | * |
536 | * If @a __f is a non-NULL function pointer or an object of type @c |
537 | * reference_wrapper<F>, this function will not throw. |
538 | */ |
539 | template<typename _Functor> |
540 | _Requires<_Callable<typename decay<_Functor>::type>, function&> |
541 | operator=(_Functor&& __f) |
542 | { |
543 | function(std::forward<_Functor>(__f)).swap(*this); |
544 | return *this; |
545 | } |
546 | |
547 | /// @overload |
548 | template<typename _Functor> |
549 | function& |
550 | operator=(reference_wrapper<_Functor> __f) noexcept |
551 | { |
552 | function(__f).swap(*this); |
553 | return *this; |
554 | } |
555 | |
556 | // [3.7.2.2] function modifiers |
557 | |
558 | /** |
559 | * @brief Swap the targets of two %function objects. |
560 | * @param __x A %function with identical call signature. |
561 | * |
562 | * Swap the targets of @c this function object and @a __f. This |
563 | * function will not throw an %exception. |
564 | */ |
565 | void swap(function& __x) noexcept |
566 | { |
567 | std::swap(_M_functor, __x._M_functor); |
568 | std::swap(_M_manager, __x._M_manager); |
569 | std::swap(_M_invoker, __x._M_invoker); |
570 | } |
571 | |
572 | // [3.7.2.3] function capacity |
573 | |
574 | /** |
575 | * @brief Determine if the %function wrapper has a target. |
576 | * |
577 | * @return @c true when this %function object contains a target, |
578 | * or @c false when it is empty. |
579 | * |
580 | * This function will not throw an %exception. |
581 | */ |
582 | explicit operator bool() const noexcept |
583 | { return !_M_empty(); } |
584 | |
585 | // [3.7.2.4] function invocation |
586 | |
587 | /** |
588 | * @brief Invokes the function targeted by @c *this. |
589 | * @returns the result of the target. |
590 | * @throws bad_function_call when @c !(bool)*this |
591 | * |
592 | * The function call operator invokes the target function object |
593 | * stored by @c this. |
594 | */ |
595 | _Res operator()(_ArgTypes... __args) const; |
596 | |
597 | #if __cpp_rtti199711 |
598 | // [3.7.2.5] function target access |
599 | /** |
600 | * @brief Determine the type of the target of this function object |
601 | * wrapper. |
602 | * |
603 | * @returns the type identifier of the target function object, or |
604 | * @c typeid(void) if @c !(bool)*this. |
605 | * |
606 | * This function will not throw an %exception. |
607 | */ |
608 | const type_info& target_type() const noexcept; |
609 | |
610 | /** |
611 | * @brief Access the stored target function object. |
612 | * |
613 | * @return Returns a pointer to the stored target function object, |
614 | * if @c typeid(_Functor).equals(target_type()); otherwise, a NULL |
615 | * pointer. |
616 | * |
617 | * This function does not throw exceptions. |
618 | * |
619 | * @{ |
620 | */ |
621 | template<typename _Functor> _Functor* target() noexcept; |
622 | |
623 | template<typename _Functor> const _Functor* target() const noexcept; |
624 | // @} |
625 | #endif |
626 | |
627 | private: |
628 | using _Invoker_type = _Res (*)(const _Any_data&, _ArgTypes&&...); |
629 | _Invoker_type _M_invoker; |
630 | }; |
631 | |
632 | #if __cpp_deduction_guides >= 201606 |
633 | template<typename> |
634 | struct __function_guide_helper |
635 | { }; |
636 | |
637 | template<typename _Res, typename _Tp, bool _Nx, typename... _Args> |
638 | struct __function_guide_helper< |
639 | _Res (_Tp::*) (_Args...) noexcept(_Nx) |
640 | > |
641 | { using type = _Res(_Args...); }; |
642 | |
643 | template<typename _Res, typename _Tp, bool _Nx, typename... _Args> |
644 | struct __function_guide_helper< |
645 | _Res (_Tp::*) (_Args...) & noexcept(_Nx) |
646 | > |
647 | { using type = _Res(_Args...); }; |
648 | |
649 | template<typename _Res, typename _Tp, bool _Nx, typename... _Args> |
650 | struct __function_guide_helper< |
651 | _Res (_Tp::*) (_Args...) const noexcept(_Nx) |
652 | > |
653 | { using type = _Res(_Args...); }; |
654 | |
655 | template<typename _Res, typename _Tp, bool _Nx, typename... _Args> |
656 | struct __function_guide_helper< |
657 | _Res (_Tp::*) (_Args...) const & noexcept(_Nx) |
658 | > |
659 | { using type = _Res(_Args...); }; |
660 | |
661 | template<typename _Res, typename... _ArgTypes> |
662 | function(_Res(*)(_ArgTypes...)) -> function<_Res(_ArgTypes...)>; |
663 | |
664 | template<typename _Functor, typename _Signature = typename |
665 | __function_guide_helper<decltype(&_Functor::operator())>::type> |
666 | function(_Functor) -> function<_Signature>; |
667 | #endif |
668 | |
669 | // Out-of-line member definitions. |
670 | template<typename _Res, typename... _ArgTypes> |
671 | function<_Res(_ArgTypes...)>:: |
672 | function(const function& __x) |
673 | : _Function_base() |
674 | { |
675 | if (static_cast<bool>(__x)) |
676 | { |
677 | __x._M_manager(_M_functor, __x._M_functor, __clone_functor); |
678 | _M_invoker = __x._M_invoker; |
679 | _M_manager = __x._M_manager; |
680 | } |
681 | } |
682 | |
683 | template<typename _Res, typename... _ArgTypes> |
684 | template<typename _Functor, typename, typename> |
685 | function<_Res(_ArgTypes...)>:: |
686 | function(_Functor __f) |
687 | : _Function_base() |
688 | { |
689 | typedef _Function_handler<_Res(_ArgTypes...), _Functor> _My_handler; |
690 | |
691 | if (_My_handler::_M_not_empty_function(__f)) |
692 | { |
693 | _My_handler::_M_init_functor(_M_functor, std::move(__f)); |
694 | _M_invoker = &_My_handler::_M_invoke; |
695 | _M_manager = &_My_handler::_M_manager; |
696 | } |
697 | } |
698 | |
699 | template<typename _Res, typename... _ArgTypes> |
700 | _Res |
701 | function<_Res(_ArgTypes...)>:: |
702 | operator()(_ArgTypes... __args) const |
703 | { |
704 | if (_M_empty()) |
705 | __throw_bad_function_call(); |
706 | return _M_invoker(_M_functor, std::forward<_ArgTypes>(__args)...); |
707 | } |
708 | |
709 | #if __cpp_rtti199711 |
710 | template<typename _Res, typename... _ArgTypes> |
711 | const type_info& |
712 | function<_Res(_ArgTypes...)>:: |
713 | target_type() const noexcept |
714 | { |
715 | if (_M_manager) |
716 | { |
717 | _Any_data __typeinfo_result; |
718 | _M_manager(__typeinfo_result, _M_functor, __get_type_info); |
719 | return *__typeinfo_result._M_access<const type_info*>(); |
720 | } |
721 | else |
722 | return typeid(void); |
723 | } |
724 | |
725 | template<typename _Res, typename... _ArgTypes> |
726 | template<typename _Functor> |
727 | _Functor* |
728 | function<_Res(_ArgTypes...)>:: |
729 | target() noexcept |
730 | { |
731 | const function* __const_this = this; |
732 | const _Functor* __func = __const_this->template target<_Functor>(); |
733 | return const_cast<_Functor*>(__func); |
734 | } |
735 | |
736 | template<typename _Res, typename... _ArgTypes> |
737 | template<typename _Functor> |
738 | const _Functor* |
739 | function<_Res(_ArgTypes...)>:: |
740 | target() const noexcept |
741 | { |
742 | if (typeid(_Functor) == target_type() && _M_manager) |
743 | { |
744 | _Any_data __ptr; |
745 | _M_manager(__ptr, _M_functor, __get_functor_ptr); |
746 | return __ptr._M_access<const _Functor*>(); |
747 | } |
748 | else |
749 | return nullptr; |
750 | } |
751 | #endif |
752 | |
753 | // [20.7.15.2.6] null pointer comparisons |
754 | |
755 | /** |
756 | * @brief Compares a polymorphic function object wrapper against 0 |
757 | * (the NULL pointer). |
758 | * @returns @c true if the wrapper has no target, @c false otherwise |
759 | * |
760 | * This function will not throw an %exception. |
761 | */ |
762 | template<typename _Res, typename... _Args> |
763 | inline bool |
764 | operator==(const function<_Res(_Args...)>& __f, nullptr_t) noexcept |
765 | { return !static_cast<bool>(__f); } |
766 | |
767 | /// @overload |
768 | template<typename _Res, typename... _Args> |
769 | inline bool |
770 | operator==(nullptr_t, const function<_Res(_Args...)>& __f) noexcept |
771 | { return !static_cast<bool>(__f); } |
772 | |
773 | /** |
774 | * @brief Compares a polymorphic function object wrapper against 0 |
775 | * (the NULL pointer). |
776 | * @returns @c false if the wrapper has no target, @c true otherwise |
777 | * |
778 | * This function will not throw an %exception. |
779 | */ |
780 | template<typename _Res, typename... _Args> |
781 | inline bool |
782 | operator!=(const function<_Res(_Args...)>& __f, nullptr_t) noexcept |
783 | { return static_cast<bool>(__f); } |
784 | |
785 | /// @overload |
786 | template<typename _Res, typename... _Args> |
787 | inline bool |
788 | operator!=(nullptr_t, const function<_Res(_Args...)>& __f) noexcept |
789 | { return static_cast<bool>(__f); } |
790 | |
791 | |
792 | // [20.7.15.2.7] specialized algorithms |
793 | |
794 | /** |
795 | * @brief Swap the targets of two polymorphic function object wrappers. |
796 | * |
797 | * This function will not throw an %exception. |
798 | */ |
799 | // _GLIBCXX_RESOLVE_LIB_DEFECTS |
800 | // 2062. Effect contradictions w/o no-throw guarantee of std::function swaps |
801 | template<typename _Res, typename... _Args> |
802 | inline void |
803 | swap(function<_Res(_Args...)>& __x, function<_Res(_Args...)>& __y) noexcept |
804 | { __x.swap(__y); } |
805 | |
806 | _GLIBCXX_END_NAMESPACE_VERSION |
807 | } // namespace std |
808 | |
809 | #endif // C++11 |
810 | |
811 | #endif // _GLIBCXX_STD_FUNCTION_H |