File: | src/gnu/usr.bin/clang/liblldbPluginPlatform/../../../llvm/lldb/source/Plugins/Platform/Android/AdbClient.cpp |
Warning: | line 497, column 17 1st function call argument is an uninitialized value |
Press '?' to see keyboard shortcuts
Keyboard shortcuts:
1 | //===-- AdbClient.cpp -----------------------------------------------------===// | |||
2 | // | |||
3 | // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. | |||
4 | // See https://llvm.org/LICENSE.txt for license information. | |||
5 | // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception | |||
6 | // | |||
7 | //===----------------------------------------------------------------------===// | |||
8 | ||||
9 | #include "AdbClient.h" | |||
10 | ||||
11 | #include "llvm/ADT/STLExtras.h" | |||
12 | #include "llvm/ADT/SmallVector.h" | |||
13 | #include "llvm/ADT/StringRef.h" | |||
14 | #include "llvm/Support/FileUtilities.h" | |||
15 | ||||
16 | #include "lldb/Host/ConnectionFileDescriptor.h" | |||
17 | #include "lldb/Host/FileSystem.h" | |||
18 | #include "lldb/Host/PosixApi.h" | |||
19 | #include "lldb/Utility/DataBuffer.h" | |||
20 | #include "lldb/Utility/DataBufferHeap.h" | |||
21 | #include "lldb/Utility/DataEncoder.h" | |||
22 | #include "lldb/Utility/DataExtractor.h" | |||
23 | #include "lldb/Utility/FileSpec.h" | |||
24 | #include "lldb/Utility/StreamString.h" | |||
25 | #include "lldb/Utility/Timeout.h" | |||
26 | ||||
27 | #include <climits> | |||
28 | ||||
29 | #include <algorithm> | |||
30 | #include <cstdlib> | |||
31 | #include <fstream> | |||
32 | #include <sstream> | |||
33 | ||||
34 | // On Windows, transitive dependencies pull in <Windows.h>, which defines a | |||
35 | // macro that clashes with a method name. | |||
36 | #ifdef SendMessage | |||
37 | #undef SendMessage | |||
38 | #endif | |||
39 | ||||
40 | using namespace lldb; | |||
41 | using namespace lldb_private; | |||
42 | using namespace lldb_private::platform_android; | |||
43 | using namespace std::chrono; | |||
44 | ||||
45 | namespace { | |||
46 | ||||
47 | const seconds kReadTimeout(20); | |||
48 | const char *kOKAY = "OKAY"; | |||
49 | const char *kFAIL = "FAIL"; | |||
50 | const char *kDATA = "DATA"; | |||
51 | const char *kDONE = "DONE"; | |||
52 | ||||
53 | const char *kSEND = "SEND"; | |||
54 | const char *kRECV = "RECV"; | |||
55 | const char *kSTAT = "STAT"; | |||
56 | ||||
57 | const size_t kSyncPacketLen = 8; | |||
58 | // Maximum size of a filesync DATA packet. | |||
59 | const size_t kMaxPushData = 2 * 1024; | |||
60 | // Default mode for pushed files. | |||
61 | const uint32_t kDefaultMode = 0100770; // S_IFREG | S_IRWXU | S_IRWXG | |||
62 | ||||
63 | const char *kSocketNamespaceAbstract = "localabstract"; | |||
64 | const char *kSocketNamespaceFileSystem = "localfilesystem"; | |||
65 | ||||
66 | Status ReadAllBytes(Connection &conn, void *buffer, size_t size) { | |||
67 | ||||
68 | Status error; | |||
69 | ConnectionStatus status; | |||
70 | char *read_buffer = static_cast<char *>(buffer); | |||
71 | ||||
72 | auto now = steady_clock::now(); | |||
73 | const auto deadline = now + kReadTimeout; | |||
74 | size_t total_read_bytes = 0; | |||
75 | while (total_read_bytes < size && now < deadline) { | |||
76 | auto read_bytes = | |||
77 | conn.Read(read_buffer + total_read_bytes, size - total_read_bytes, | |||
78 | duration_cast<microseconds>(deadline - now), status, &error); | |||
79 | if (error.Fail()) | |||
80 | return error; | |||
81 | total_read_bytes += read_bytes; | |||
82 | if (status != eConnectionStatusSuccess) | |||
83 | break; | |||
84 | now = steady_clock::now(); | |||
85 | } | |||
86 | if (total_read_bytes < size) | |||
87 | error = Status( | |||
88 | "Unable to read requested number of bytes. Connection status: %d.", | |||
89 | status); | |||
90 | return error; | |||
91 | } | |||
92 | ||||
93 | } // namespace | |||
94 | ||||
95 | Status AdbClient::CreateByDeviceID(const std::string &device_id, | |||
96 | AdbClient &adb) { | |||
97 | Status error; | |||
98 | std::string android_serial; | |||
99 | if (!device_id.empty()) | |||
100 | android_serial = device_id; | |||
101 | else if (const char *env_serial = std::getenv("ANDROID_SERIAL")) | |||
102 | android_serial = env_serial; | |||
103 | ||||
104 | if (android_serial.empty()) { | |||
105 | DeviceIDList connected_devices; | |||
106 | error = adb.GetDevices(connected_devices); | |||
107 | if (error.Fail()) | |||
108 | return error; | |||
109 | ||||
110 | if (connected_devices.size() != 1) | |||
111 | return Status("Expected a single connected device, got instead %zu - try " | |||
112 | "setting 'ANDROID_SERIAL'", | |||
113 | connected_devices.size()); | |||
114 | adb.SetDeviceID(connected_devices.front()); | |||
115 | } else { | |||
116 | adb.SetDeviceID(android_serial); | |||
117 | } | |||
118 | return error; | |||
119 | } | |||
120 | ||||
121 | AdbClient::AdbClient() = default; | |||
122 | ||||
123 | AdbClient::AdbClient(const std::string &device_id) : m_device_id(device_id) {} | |||
124 | ||||
125 | AdbClient::~AdbClient() = default; | |||
126 | ||||
127 | void AdbClient::SetDeviceID(const std::string &device_id) { | |||
128 | m_device_id = device_id; | |||
129 | } | |||
130 | ||||
131 | const std::string &AdbClient::GetDeviceID() const { return m_device_id; } | |||
132 | ||||
133 | Status AdbClient::Connect() { | |||
134 | Status error; | |||
135 | m_conn = std::make_unique<ConnectionFileDescriptor>(); | |||
136 | std::string port = "5037"; | |||
137 | if (const char *env_port = std::getenv("ANDROID_ADB_SERVER_PORT")) { | |||
138 | port = env_port; | |||
139 | } | |||
140 | std::string uri = "connect://127.0.0.1:" + port; | |||
141 | m_conn->Connect(uri.c_str(), &error); | |||
142 | ||||
143 | return error; | |||
144 | } | |||
145 | ||||
146 | Status AdbClient::GetDevices(DeviceIDList &device_list) { | |||
147 | device_list.clear(); | |||
148 | ||||
149 | auto error = SendMessage("host:devices"); | |||
150 | if (error.Fail()) | |||
151 | return error; | |||
152 | ||||
153 | error = ReadResponseStatus(); | |||
154 | if (error.Fail()) | |||
155 | return error; | |||
156 | ||||
157 | std::vector<char> in_buffer; | |||
158 | error = ReadMessage(in_buffer); | |||
159 | ||||
160 | llvm::StringRef response(&in_buffer[0], in_buffer.size()); | |||
161 | llvm::SmallVector<llvm::StringRef, 4> devices; | |||
162 | response.split(devices, "\n", -1, false); | |||
163 | ||||
164 | for (const auto &device : devices) | |||
165 | device_list.push_back(std::string(device.split('\t').first)); | |||
166 | ||||
167 | // Force disconnect since ADB closes connection after host:devices response | |||
168 | // is sent. | |||
169 | m_conn.reset(); | |||
170 | return error; | |||
171 | } | |||
172 | ||||
173 | Status AdbClient::SetPortForwarding(const uint16_t local_port, | |||
174 | const uint16_t remote_port) { | |||
175 | char message[48]; | |||
176 | snprintf(message, sizeof(message), "forward:tcp:%d;tcp:%d", local_port, | |||
177 | remote_port); | |||
178 | ||||
179 | const auto error = SendDeviceMessage(message); | |||
180 | if (error.Fail()) | |||
181 | return error; | |||
182 | ||||
183 | return ReadResponseStatus(); | |||
184 | } | |||
185 | ||||
186 | Status | |||
187 | AdbClient::SetPortForwarding(const uint16_t local_port, | |||
188 | llvm::StringRef remote_socket_name, | |||
189 | const UnixSocketNamespace socket_namespace) { | |||
190 | char message[PATH_MAX1024]; | |||
191 | const char *sock_namespace_str = | |||
192 | (socket_namespace == UnixSocketNamespaceAbstract) | |||
193 | ? kSocketNamespaceAbstract | |||
194 | : kSocketNamespaceFileSystem; | |||
195 | snprintf(message, sizeof(message), "forward:tcp:%d;%s:%s", local_port, | |||
196 | sock_namespace_str, remote_socket_name.str().c_str()); | |||
197 | ||||
198 | const auto error = SendDeviceMessage(message); | |||
199 | if (error.Fail()) | |||
200 | return error; | |||
201 | ||||
202 | return ReadResponseStatus(); | |||
203 | } | |||
204 | ||||
205 | Status AdbClient::DeletePortForwarding(const uint16_t local_port) { | |||
206 | char message[32]; | |||
207 | snprintf(message, sizeof(message), "killforward:tcp:%d", local_port); | |||
208 | ||||
209 | const auto error = SendDeviceMessage(message); | |||
210 | if (error.Fail()) | |||
211 | return error; | |||
212 | ||||
213 | return ReadResponseStatus(); | |||
214 | } | |||
215 | ||||
216 | Status AdbClient::SendMessage(const std::string &packet, const bool reconnect) { | |||
217 | Status error; | |||
218 | if (!m_conn || reconnect) { | |||
219 | error = Connect(); | |||
220 | if (error.Fail()) | |||
221 | return error; | |||
222 | } | |||
223 | ||||
224 | char length_buffer[5]; | |||
225 | snprintf(length_buffer, sizeof(length_buffer), "%04x", | |||
226 | static_cast<int>(packet.size())); | |||
227 | ||||
228 | ConnectionStatus status; | |||
229 | ||||
230 | m_conn->Write(length_buffer, 4, status, &error); | |||
231 | if (error.Fail()) | |||
232 | return error; | |||
233 | ||||
234 | m_conn->Write(packet.c_str(), packet.size(), status, &error); | |||
235 | return error; | |||
236 | } | |||
237 | ||||
238 | Status AdbClient::SendDeviceMessage(const std::string &packet) { | |||
239 | std::ostringstream msg; | |||
240 | msg << "host-serial:" << m_device_id << ":" << packet; | |||
241 | return SendMessage(msg.str()); | |||
242 | } | |||
243 | ||||
244 | Status AdbClient::ReadMessage(std::vector<char> &message) { | |||
245 | message.clear(); | |||
246 | ||||
247 | char buffer[5]; | |||
248 | buffer[4] = 0; | |||
249 | ||||
250 | auto error = ReadAllBytes(buffer, 4); | |||
251 | if (error.Fail()) | |||
252 | return error; | |||
253 | ||||
254 | unsigned int packet_len = 0; | |||
255 | sscanf(buffer, "%x", &packet_len); | |||
256 | ||||
257 | message.resize(packet_len, 0); | |||
258 | error = ReadAllBytes(&message[0], packet_len); | |||
259 | if (error.Fail()) | |||
260 | message.clear(); | |||
261 | ||||
262 | return error; | |||
263 | } | |||
264 | ||||
265 | Status AdbClient::ReadMessageStream(std::vector<char> &message, | |||
266 | milliseconds timeout) { | |||
267 | auto start = steady_clock::now(); | |||
268 | message.clear(); | |||
269 | ||||
270 | Status error; | |||
271 | lldb::ConnectionStatus status = lldb::eConnectionStatusSuccess; | |||
272 | char buffer[1024]; | |||
273 | while (error.Success() && status == lldb::eConnectionStatusSuccess) { | |||
274 | auto end = steady_clock::now(); | |||
275 | auto elapsed = end - start; | |||
276 | if (elapsed >= timeout) | |||
277 | return Status("Timed out"); | |||
278 | ||||
279 | size_t n = m_conn->Read(buffer, sizeof(buffer), | |||
280 | duration_cast<microseconds>(timeout - elapsed), | |||
281 | status, &error); | |||
282 | if (n > 0) | |||
283 | message.insert(message.end(), &buffer[0], &buffer[n]); | |||
284 | } | |||
285 | return error; | |||
286 | } | |||
287 | ||||
288 | Status AdbClient::ReadResponseStatus() { | |||
289 | char response_id[5]; | |||
290 | ||||
291 | static const size_t packet_len = 4; | |||
292 | response_id[packet_len] = 0; | |||
293 | ||||
294 | auto error = ReadAllBytes(response_id, packet_len); | |||
295 | if (error.Fail()) | |||
296 | return error; | |||
297 | ||||
298 | if (strncmp(response_id, kOKAY, packet_len) != 0) | |||
299 | return GetResponseError(response_id); | |||
300 | ||||
301 | return error; | |||
302 | } | |||
303 | ||||
304 | Status AdbClient::GetResponseError(const char *response_id) { | |||
305 | if (strcmp(response_id, kFAIL) != 0) | |||
306 | return Status("Got unexpected response id from adb: \"%s\"", response_id); | |||
307 | ||||
308 | std::vector<char> error_message; | |||
309 | auto error = ReadMessage(error_message); | |||
310 | if (error.Success()) | |||
311 | error.SetErrorString( | |||
312 | std::string(&error_message[0], error_message.size()).c_str()); | |||
313 | ||||
314 | return error; | |||
315 | } | |||
316 | ||||
317 | Status AdbClient::SwitchDeviceTransport() { | |||
318 | std::ostringstream msg; | |||
319 | msg << "host:transport:" << m_device_id; | |||
320 | ||||
321 | auto error = SendMessage(msg.str()); | |||
322 | if (error.Fail()) | |||
323 | return error; | |||
324 | ||||
325 | return ReadResponseStatus(); | |||
326 | } | |||
327 | ||||
328 | Status AdbClient::StartSync() { | |||
329 | auto error = SwitchDeviceTransport(); | |||
330 | if (error.Fail()) | |||
331 | return Status("Failed to switch to device transport: %s", | |||
332 | error.AsCString()); | |||
333 | ||||
334 | error = Sync(); | |||
335 | if (error.Fail()) | |||
336 | return Status("Sync failed: %s", error.AsCString()); | |||
337 | ||||
338 | return error; | |||
339 | } | |||
340 | ||||
341 | Status AdbClient::Sync() { | |||
342 | auto error = SendMessage("sync:", false); | |||
343 | if (error.Fail()) | |||
344 | return error; | |||
345 | ||||
346 | return ReadResponseStatus(); | |||
347 | } | |||
348 | ||||
349 | Status AdbClient::ReadAllBytes(void *buffer, size_t size) { | |||
350 | return ::ReadAllBytes(*m_conn, buffer, size); | |||
351 | } | |||
352 | ||||
353 | Status AdbClient::internalShell(const char *command, milliseconds timeout, | |||
354 | std::vector<char> &output_buf) { | |||
355 | output_buf.clear(); | |||
356 | ||||
357 | auto error = SwitchDeviceTransport(); | |||
358 | if (error.Fail()) | |||
359 | return Status("Failed to switch to device transport: %s", | |||
360 | error.AsCString()); | |||
361 | ||||
362 | StreamString adb_command; | |||
363 | adb_command.Printf("shell:%s", command); | |||
364 | error = SendMessage(std::string(adb_command.GetString()), false); | |||
365 | if (error.Fail()) | |||
366 | return error; | |||
367 | ||||
368 | error = ReadResponseStatus(); | |||
369 | if (error.Fail()) | |||
370 | return error; | |||
371 | ||||
372 | error = ReadMessageStream(output_buf, timeout); | |||
373 | if (error.Fail()) | |||
374 | return error; | |||
375 | ||||
376 | // ADB doesn't propagate return code of shell execution - if | |||
377 | // output starts with /system/bin/sh: most likely command failed. | |||
378 | static const char *kShellPrefix = "/system/bin/sh:"; | |||
379 | if (output_buf.size() > strlen(kShellPrefix)) { | |||
380 | if (!memcmp(&output_buf[0], kShellPrefix, strlen(kShellPrefix))) | |||
381 | return Status("Shell command %s failed: %s", command, | |||
382 | std::string(output_buf.begin(), output_buf.end()).c_str()); | |||
383 | } | |||
384 | ||||
385 | return Status(); | |||
386 | } | |||
387 | ||||
388 | Status AdbClient::Shell(const char *command, milliseconds timeout, | |||
389 | std::string *output) { | |||
390 | std::vector<char> output_buffer; | |||
391 | auto error = internalShell(command, timeout, output_buffer); | |||
392 | if (error.Fail()) | |||
393 | return error; | |||
394 | ||||
395 | if (output) | |||
396 | output->assign(output_buffer.begin(), output_buffer.end()); | |||
397 | return error; | |||
398 | } | |||
399 | ||||
400 | Status AdbClient::ShellToFile(const char *command, milliseconds timeout, | |||
401 | const FileSpec &output_file_spec) { | |||
402 | std::vector<char> output_buffer; | |||
403 | auto error = internalShell(command, timeout, output_buffer); | |||
404 | if (error.Fail()) | |||
405 | return error; | |||
406 | ||||
407 | const auto output_filename = output_file_spec.GetPath(); | |||
408 | std::error_code EC; | |||
409 | llvm::raw_fd_ostream dst(output_filename, EC, llvm::sys::fs::OF_None); | |||
410 | if (EC) | |||
411 | return Status("Unable to open local file %s", output_filename.c_str()); | |||
412 | ||||
413 | dst.write(&output_buffer[0], output_buffer.size()); | |||
414 | dst.close(); | |||
415 | if (dst.has_error()) | |||
416 | return Status("Failed to write file %s", output_filename.c_str()); | |||
417 | return Status(); | |||
418 | } | |||
419 | ||||
420 | std::unique_ptr<AdbClient::SyncService> | |||
421 | AdbClient::GetSyncService(Status &error) { | |||
422 | std::unique_ptr<SyncService> sync_service; | |||
423 | error = StartSync(); | |||
424 | if (error.Success()) | |||
425 | sync_service.reset(new SyncService(std::move(m_conn))); | |||
426 | ||||
427 | return sync_service; | |||
428 | } | |||
429 | ||||
430 | Status AdbClient::SyncService::internalPullFile(const FileSpec &remote_file, | |||
431 | const FileSpec &local_file) { | |||
432 | const auto local_file_path = local_file.GetPath(); | |||
433 | llvm::FileRemover local_file_remover(local_file_path); | |||
434 | ||||
435 | std::error_code EC; | |||
436 | llvm::raw_fd_ostream dst(local_file_path, EC, llvm::sys::fs::OF_None); | |||
437 | if (EC) | |||
438 | return Status("Unable to open local file %s", local_file_path.c_str()); | |||
439 | ||||
440 | const auto remote_file_path = remote_file.GetPath(false); | |||
441 | auto error = SendSyncRequest(kRECV, remote_file_path.length(), | |||
442 | remote_file_path.c_str()); | |||
443 | if (error.Fail()) | |||
444 | return error; | |||
445 | ||||
446 | std::vector<char> chunk; | |||
447 | bool eof = false; | |||
448 | while (!eof) { | |||
449 | error = PullFileChunk(chunk, eof); | |||
450 | if (error.Fail()) | |||
451 | return error; | |||
452 | if (!eof) | |||
453 | dst.write(&chunk[0], chunk.size()); | |||
454 | } | |||
455 | dst.close(); | |||
456 | if (dst.has_error()) | |||
457 | return Status("Failed to write file %s", local_file_path.c_str()); | |||
458 | ||||
459 | local_file_remover.releaseFile(); | |||
460 | return error; | |||
461 | } | |||
462 | ||||
463 | Status AdbClient::SyncService::internalPushFile(const FileSpec &local_file, | |||
464 | const FileSpec &remote_file) { | |||
465 | const auto local_file_path(local_file.GetPath()); | |||
466 | std::ifstream src(local_file_path.c_str(), std::ios::in | std::ios::binary); | |||
467 | if (!src.is_open()) | |||
468 | return Status("Unable to open local file %s", local_file_path.c_str()); | |||
469 | ||||
470 | std::stringstream file_description; | |||
471 | file_description << remote_file.GetPath(false).c_str() << "," << kDefaultMode; | |||
472 | std::string file_description_str = file_description.str(); | |||
473 | auto error = SendSyncRequest(kSEND, file_description_str.length(), | |||
474 | file_description_str.c_str()); | |||
475 | if (error.Fail()) | |||
476 | return error; | |||
477 | ||||
478 | char chunk[kMaxPushData]; | |||
479 | while (!src.eof() && !src.read(chunk, kMaxPushData).bad()) { | |||
480 | size_t chunk_size = src.gcount(); | |||
481 | error = SendSyncRequest(kDATA, chunk_size, chunk); | |||
482 | if (error.Fail()) | |||
483 | return Status("Failed to send file chunk: %s", error.AsCString()); | |||
484 | } | |||
485 | error = SendSyncRequest( | |||
486 | kDONE, llvm::sys::toTimeT(FileSystem::Instance().GetModificationTime(local_file)), | |||
487 | nullptr); | |||
488 | if (error.Fail()) | |||
489 | return error; | |||
490 | ||||
491 | std::string response_id; | |||
492 | uint32_t data_len; | |||
493 | error = ReadSyncHeader(response_id, data_len); | |||
494 | if (error.Fail()) | |||
495 | return Status("Failed to read DONE response: %s", error.AsCString()); | |||
496 | if (response_id == kFAIL) { | |||
497 | std::string error_message(data_len, 0); | |||
| ||||
498 | error = ReadAllBytes(&error_message[0], data_len); | |||
499 | if (error.Fail()) | |||
500 | return Status("Failed to read DONE error message: %s", error.AsCString()); | |||
501 | return Status("Failed to push file: %s", error_message.c_str()); | |||
502 | } else if (response_id != kOKAY) | |||
503 | return Status("Got unexpected DONE response: %s", response_id.c_str()); | |||
504 | ||||
505 | // If there was an error reading the source file, finish the adb file | |||
506 | // transfer first so that adb isn't expecting any more data. | |||
507 | if (src.bad()) | |||
508 | return Status("Failed read on %s", local_file_path.c_str()); | |||
509 | return error; | |||
510 | } | |||
511 | ||||
512 | Status AdbClient::SyncService::internalStat(const FileSpec &remote_file, | |||
513 | uint32_t &mode, uint32_t &size, | |||
514 | uint32_t &mtime) { | |||
515 | const std::string remote_file_path(remote_file.GetPath(false)); | |||
516 | auto error = SendSyncRequest(kSTAT, remote_file_path.length(), | |||
517 | remote_file_path.c_str()); | |||
518 | if (error.Fail()) | |||
519 | return Status("Failed to send request: %s", error.AsCString()); | |||
520 | ||||
521 | static const size_t stat_len = strlen(kSTAT); | |||
522 | static const size_t response_len = stat_len + (sizeof(uint32_t) * 3); | |||
523 | ||||
524 | std::vector<char> buffer(response_len); | |||
525 | error = ReadAllBytes(&buffer[0], buffer.size()); | |||
526 | if (error.Fail()) | |||
527 | return Status("Failed to read response: %s", error.AsCString()); | |||
528 | ||||
529 | DataExtractor extractor(&buffer[0], buffer.size(), eByteOrderLittle, | |||
530 | sizeof(void *)); | |||
531 | offset_t offset = 0; | |||
532 | ||||
533 | const void *command = extractor.GetData(&offset, stat_len); | |||
534 | if (!command) | |||
535 | return Status("Failed to get response command"); | |||
536 | const char *command_str = static_cast<const char *>(command); | |||
537 | if (strncmp(command_str, kSTAT, stat_len)) | |||
538 | return Status("Got invalid stat command: %s", command_str); | |||
539 | ||||
540 | mode = extractor.GetU32(&offset); | |||
541 | size = extractor.GetU32(&offset); | |||
542 | mtime = extractor.GetU32(&offset); | |||
543 | return Status(); | |||
544 | } | |||
545 | ||||
546 | Status AdbClient::SyncService::PullFile(const FileSpec &remote_file, | |||
547 | const FileSpec &local_file) { | |||
548 | return executeCommand([this, &remote_file, &local_file]() { | |||
549 | return internalPullFile(remote_file, local_file); | |||
550 | }); | |||
551 | } | |||
552 | ||||
553 | Status AdbClient::SyncService::PushFile(const FileSpec &local_file, | |||
554 | const FileSpec &remote_file) { | |||
555 | return executeCommand([this, &local_file, &remote_file]() { | |||
| ||||
556 | return internalPushFile(local_file, remote_file); | |||
557 | }); | |||
558 | } | |||
559 | ||||
560 | Status AdbClient::SyncService::Stat(const FileSpec &remote_file, uint32_t &mode, | |||
561 | uint32_t &size, uint32_t &mtime) { | |||
562 | return executeCommand([this, &remote_file, &mode, &size, &mtime]() { | |||
563 | return internalStat(remote_file, mode, size, mtime); | |||
564 | }); | |||
565 | } | |||
566 | ||||
567 | bool AdbClient::SyncService::IsConnected() const { | |||
568 | return m_conn && m_conn->IsConnected(); | |||
569 | } | |||
570 | ||||
571 | AdbClient::SyncService::SyncService(std::unique_ptr<Connection> &&conn) | |||
572 | : m_conn(std::move(conn)) {} | |||
573 | ||||
574 | Status | |||
575 | AdbClient::SyncService::executeCommand(const std::function<Status()> &cmd) { | |||
576 | if (!m_conn) | |||
577 | return Status("SyncService is disconnected"); | |||
578 | ||||
579 | const auto error = cmd(); | |||
580 | if (error.Fail()) | |||
581 | m_conn.reset(); | |||
582 | ||||
583 | return error; | |||
584 | } | |||
585 | ||||
586 | AdbClient::SyncService::~SyncService() = default; | |||
587 | ||||
588 | Status AdbClient::SyncService::SendSyncRequest(const char *request_id, | |||
589 | const uint32_t data_len, | |||
590 | const void *data) { | |||
591 | const DataBufferSP data_sp(new DataBufferHeap(kSyncPacketLen, 0)); | |||
592 | DataEncoder encoder(data_sp, eByteOrderLittle, sizeof(void *)); | |||
593 | auto offset = encoder.PutData(0, request_id, strlen(request_id)); | |||
594 | encoder.PutUnsigned(offset, 4, data_len); | |||
595 | ||||
596 | Status error; | |||
597 | ConnectionStatus status; | |||
598 | m_conn->Write(data_sp->GetBytes(), kSyncPacketLen, status, &error); | |||
599 | if (error.Fail()) | |||
600 | return error; | |||
601 | ||||
602 | if (data) | |||
603 | m_conn->Write(data, data_len, status, &error); | |||
604 | return error; | |||
605 | } | |||
606 | ||||
607 | Status AdbClient::SyncService::ReadSyncHeader(std::string &response_id, | |||
608 | uint32_t &data_len) { | |||
609 | char buffer[kSyncPacketLen]; | |||
610 | ||||
611 | auto error = ReadAllBytes(buffer, kSyncPacketLen); | |||
612 | if (error.Success()) { | |||
613 | response_id.assign(&buffer[0], 4); | |||
614 | DataExtractor extractor(&buffer[4], 4, eByteOrderLittle, sizeof(void *)); | |||
615 | offset_t offset = 0; | |||
616 | data_len = extractor.GetU32(&offset); | |||
617 | } | |||
618 | ||||
619 | return error; | |||
620 | } | |||
621 | ||||
622 | Status AdbClient::SyncService::PullFileChunk(std::vector<char> &buffer, | |||
623 | bool &eof) { | |||
624 | buffer.clear(); | |||
625 | ||||
626 | std::string response_id; | |||
627 | uint32_t data_len; | |||
628 | auto error = ReadSyncHeader(response_id, data_len); | |||
629 | if (error.Fail()) | |||
630 | return error; | |||
631 | ||||
632 | if (response_id == kDATA) { | |||
633 | buffer.resize(data_len, 0); | |||
634 | error = ReadAllBytes(&buffer[0], data_len); | |||
635 | if (error.Fail()) | |||
636 | buffer.clear(); | |||
637 | } else if (response_id == kDONE) { | |||
638 | eof = true; | |||
639 | } else if (response_id == kFAIL) { | |||
640 | std::string error_message(data_len, 0); | |||
641 | error = ReadAllBytes(&error_message[0], data_len); | |||
642 | if (error.Fail()) | |||
643 | return Status("Failed to read pull error message: %s", error.AsCString()); | |||
644 | return Status("Failed to pull file: %s", error_message.c_str()); | |||
645 | } else | |||
646 | return Status("Pull failed with unknown response: %s", response_id.c_str()); | |||
647 | ||||
648 | return Status(); | |||
649 | } | |||
650 | ||||
651 | Status AdbClient::SyncService::ReadAllBytes(void *buffer, size_t size) { | |||
652 | return ::ReadAllBytes(*m_conn, buffer, size); | |||
653 | } |
1 | // -*- C++ -*- |
2 | //===----------------------------------------------------------------------===// |
3 | // |
4 | // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. |
5 | // See https://llvm.org/LICENSE.txt for license information. |
6 | // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception |
7 | // |
8 | //===----------------------------------------------------------------------===// |
9 | |
10 | #ifndef _LIBCPP___FUNCTIONAL_FUNCTION_H |
11 | #define _LIBCPP___FUNCTIONAL_FUNCTION_H |
12 | |
13 | #include <__config> |
14 | #include <__functional/binary_function.h> |
15 | #include <__functional/invoke.h> |
16 | #include <__functional/unary_function.h> |
17 | #include <__iterator/iterator_traits.h> |
18 | #include <__memory/allocator_traits.h> |
19 | #include <__memory/compressed_pair.h> |
20 | #include <__memory/shared_ptr.h> |
21 | #include <exception> |
22 | #include <memory> // TODO: replace with <__memory/__builtin_new_allocator.h> |
23 | #include <type_traits> |
24 | #include <utility> |
25 | |
26 | #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER) |
27 | #pragma GCC system_header |
28 | #endif |
29 | |
30 | _LIBCPP_BEGIN_NAMESPACE_STDnamespace std { inline namespace __1 { |
31 | |
32 | // bad_function_call |
33 | |
34 | class _LIBCPP_EXCEPTION_ABI__attribute__ ((__visibility__("default"))) bad_function_call |
35 | : public exception |
36 | { |
37 | #ifdef _LIBCPP_ABI_BAD_FUNCTION_CALL_KEY_FUNCTION |
38 | public: |
39 | virtual ~bad_function_call() _NOEXCEPTnoexcept; |
40 | |
41 | virtual const char* what() const _NOEXCEPTnoexcept; |
42 | #endif |
43 | }; |
44 | |
45 | _LIBCPP_NORETURN[[noreturn]] inline _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__ )) |
46 | void __throw_bad_function_call() |
47 | { |
48 | #ifndef _LIBCPP_NO_EXCEPTIONS |
49 | throw bad_function_call(); |
50 | #else |
51 | _VSTDstd::__1::abort(); |
52 | #endif |
53 | } |
54 | |
55 | #if defined(_LIBCPP_CXX03_LANG) && !defined(_LIBCPP_DISABLE_DEPRECATION_WARNINGS) && __has_attribute(deprecated)1 |
56 | # define _LIBCPP_DEPRECATED_CXX03_FUNCTION \ |
57 | __attribute__((deprecated("Using std::function in C++03 is not supported anymore. Please upgrade to C++11 or later, or use a different type"))) |
58 | #else |
59 | # define _LIBCPP_DEPRECATED_CXX03_FUNCTION /* nothing */ |
60 | #endif |
61 | |
62 | template<class _Fp> class _LIBCPP_DEPRECATED_CXX03_FUNCTION _LIBCPP_TEMPLATE_VIS__attribute__ ((__type_visibility__("default"))) function; // undefined |
63 | |
64 | namespace __function |
65 | { |
66 | |
67 | template<class _Rp> |
68 | struct __maybe_derive_from_unary_function |
69 | { |
70 | }; |
71 | |
72 | template<class _Rp, class _A1> |
73 | struct __maybe_derive_from_unary_function<_Rp(_A1)> |
74 | : public unary_function<_A1, _Rp> |
75 | { |
76 | }; |
77 | |
78 | template<class _Rp> |
79 | struct __maybe_derive_from_binary_function |
80 | { |
81 | }; |
82 | |
83 | template<class _Rp, class _A1, class _A2> |
84 | struct __maybe_derive_from_binary_function<_Rp(_A1, _A2)> |
85 | : public binary_function<_A1, _A2, _Rp> |
86 | { |
87 | }; |
88 | |
89 | template <class _Fp> |
90 | _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__ )) |
91 | bool __not_null(_Fp const&) { return true; } |
92 | |
93 | template <class _Fp> |
94 | _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__ )) |
95 | bool __not_null(_Fp* __ptr) { return __ptr; } |
96 | |
97 | template <class _Ret, class _Class> |
98 | _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__ )) |
99 | bool __not_null(_Ret _Class::*__ptr) { return __ptr; } |
100 | |
101 | template <class _Fp> |
102 | _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__ )) |
103 | bool __not_null(function<_Fp> const& __f) { return !!__f; } |
104 | |
105 | #ifdef _LIBCPP_HAS_EXTENSION_BLOCKS |
106 | template <class _Rp, class ..._Args> |
107 | _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__ )) |
108 | bool __not_null(_Rp (^__p)(_Args...)) { return __p; } |
109 | #endif |
110 | |
111 | } // namespace __function |
112 | |
113 | #ifndef _LIBCPP_CXX03_LANG |
114 | |
115 | namespace __function { |
116 | |
117 | // __alloc_func holds a functor and an allocator. |
118 | |
119 | template <class _Fp, class _Ap, class _FB> class __alloc_func; |
120 | template <class _Fp, class _FB> |
121 | class __default_alloc_func; |
122 | |
123 | template <class _Fp, class _Ap, class _Rp, class... _ArgTypes> |
124 | class __alloc_func<_Fp, _Ap, _Rp(_ArgTypes...)> |
125 | { |
126 | __compressed_pair<_Fp, _Ap> __f_; |
127 | |
128 | public: |
129 | typedef _LIBCPP_NODEBUG_TYPE__attribute__((nodebug)) _Fp _Target; |
130 | typedef _LIBCPP_NODEBUG_TYPE__attribute__((nodebug)) _Ap _Alloc; |
131 | |
132 | _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__ )) |
133 | const _Target& __target() const { return __f_.first(); } |
134 | |
135 | // WIN32 APIs may define __allocator, so use __get_allocator instead. |
136 | _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__ )) |
137 | const _Alloc& __get_allocator() const { return __f_.second(); } |
138 | |
139 | _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__ )) |
140 | explicit __alloc_func(_Target&& __f) |
141 | : __f_(piecewise_construct, _VSTDstd::__1::forward_as_tuple(_VSTDstd::__1::move(__f)), |
142 | _VSTDstd::__1::forward_as_tuple()) |
143 | { |
144 | } |
145 | |
146 | _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__ )) |
147 | explicit __alloc_func(const _Target& __f, const _Alloc& __a) |
148 | : __f_(piecewise_construct, _VSTDstd::__1::forward_as_tuple(__f), |
149 | _VSTDstd::__1::forward_as_tuple(__a)) |
150 | { |
151 | } |
152 | |
153 | _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__ )) |
154 | explicit __alloc_func(const _Target& __f, _Alloc&& __a) |
155 | : __f_(piecewise_construct, _VSTDstd::__1::forward_as_tuple(__f), |
156 | _VSTDstd::__1::forward_as_tuple(_VSTDstd::__1::move(__a))) |
157 | { |
158 | } |
159 | |
160 | _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__ )) |
161 | explicit __alloc_func(_Target&& __f, _Alloc&& __a) |
162 | : __f_(piecewise_construct, _VSTDstd::__1::forward_as_tuple(_VSTDstd::__1::move(__f)), |
163 | _VSTDstd::__1::forward_as_tuple(_VSTDstd::__1::move(__a))) |
164 | { |
165 | } |
166 | |
167 | _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__ )) |
168 | _Rp operator()(_ArgTypes&&... __arg) |
169 | { |
170 | typedef __invoke_void_return_wrapper<_Rp> _Invoker; |
171 | return _Invoker::__call(__f_.first(), |
172 | _VSTDstd::__1::forward<_ArgTypes>(__arg)...); |
173 | } |
174 | |
175 | _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__ )) |
176 | __alloc_func* __clone() const |
177 | { |
178 | typedef allocator_traits<_Alloc> __alloc_traits; |
179 | typedef |
180 | typename __rebind_alloc_helper<__alloc_traits, __alloc_func>::type |
181 | _AA; |
182 | _AA __a(__f_.second()); |
183 | typedef __allocator_destructor<_AA> _Dp; |
184 | unique_ptr<__alloc_func, _Dp> __hold(__a.allocate(1), _Dp(__a, 1)); |
185 | ::new ((void*)__hold.get()) __alloc_func(__f_.first(), _Alloc(__a)); |
186 | return __hold.release(); |
187 | } |
188 | |
189 | _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__ )) |
190 | void destroy() _NOEXCEPTnoexcept { __f_.~__compressed_pair<_Target, _Alloc>(); } |
191 | |
192 | static void __destroy_and_delete(__alloc_func* __f) { |
193 | typedef allocator_traits<_Alloc> __alloc_traits; |
194 | typedef typename __rebind_alloc_helper<__alloc_traits, __alloc_func>::type |
195 | _FunAlloc; |
196 | _FunAlloc __a(__f->__get_allocator()); |
197 | __f->destroy(); |
198 | __a.deallocate(__f, 1); |
199 | } |
200 | }; |
201 | |
202 | template <class _Fp, class _Rp, class... _ArgTypes> |
203 | class __default_alloc_func<_Fp, _Rp(_ArgTypes...)> { |
204 | _Fp __f_; |
205 | |
206 | public: |
207 | typedef _LIBCPP_NODEBUG_TYPE__attribute__((nodebug)) _Fp _Target; |
208 | |
209 | _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__ )) |
210 | const _Target& __target() const { return __f_; } |
211 | |
212 | _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__ )) |
213 | explicit __default_alloc_func(_Target&& __f) : __f_(_VSTDstd::__1::move(__f)) {} |
214 | |
215 | _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__ )) |
216 | explicit __default_alloc_func(const _Target& __f) : __f_(__f) {} |
217 | |
218 | _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__ )) |
219 | _Rp operator()(_ArgTypes&&... __arg) { |
220 | typedef __invoke_void_return_wrapper<_Rp> _Invoker; |
221 | return _Invoker::__call(__f_, _VSTDstd::__1::forward<_ArgTypes>(__arg)...); |
222 | } |
223 | |
224 | _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__ )) |
225 | __default_alloc_func* __clone() const { |
226 | __builtin_new_allocator::__holder_t __hold = |
227 | __builtin_new_allocator::__allocate_type<__default_alloc_func>(1); |
228 | __default_alloc_func* __res = |
229 | ::new ((void*)__hold.get()) __default_alloc_func(__f_); |
230 | (void)__hold.release(); |
231 | return __res; |
232 | } |
233 | |
234 | _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__ )) |
235 | void destroy() _NOEXCEPTnoexcept { __f_.~_Target(); } |
236 | |
237 | static void __destroy_and_delete(__default_alloc_func* __f) { |
238 | __f->destroy(); |
239 | __builtin_new_allocator::__deallocate_type<__default_alloc_func>(__f, 1); |
240 | } |
241 | }; |
242 | |
243 | // __base provides an abstract interface for copyable functors. |
244 | |
245 | template<class _Fp> class _LIBCPP_TEMPLATE_VIS__attribute__ ((__type_visibility__("default"))) __base; |
246 | |
247 | template<class _Rp, class ..._ArgTypes> |
248 | class __base<_Rp(_ArgTypes...)> |
249 | { |
250 | __base(const __base&); |
251 | __base& operator=(const __base&); |
252 | public: |
253 | _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__ )) __base() {} |
254 | _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__ )) virtual ~__base() {} |
255 | virtual __base* __clone() const = 0; |
256 | virtual void __clone(__base*) const = 0; |
257 | virtual void destroy() _NOEXCEPTnoexcept = 0; |
258 | virtual void destroy_deallocate() _NOEXCEPTnoexcept = 0; |
259 | virtual _Rp operator()(_ArgTypes&& ...) = 0; |
260 | #ifndef _LIBCPP_NO_RTTI |
261 | virtual const void* target(const type_info&) const _NOEXCEPTnoexcept = 0; |
262 | virtual const std::type_info& target_type() const _NOEXCEPTnoexcept = 0; |
263 | #endif // _LIBCPP_NO_RTTI |
264 | }; |
265 | |
266 | // __func implements __base for a given functor type. |
267 | |
268 | template<class _FD, class _Alloc, class _FB> class __func; |
269 | |
270 | template<class _Fp, class _Alloc, class _Rp, class ..._ArgTypes> |
271 | class __func<_Fp, _Alloc, _Rp(_ArgTypes...)> |
272 | : public __base<_Rp(_ArgTypes...)> |
273 | { |
274 | __alloc_func<_Fp, _Alloc, _Rp(_ArgTypes...)> __f_; |
275 | public: |
276 | _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__ )) |
277 | explicit __func(_Fp&& __f) |
278 | : __f_(_VSTDstd::__1::move(__f)) {} |
279 | |
280 | _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__ )) |
281 | explicit __func(const _Fp& __f, const _Alloc& __a) |
282 | : __f_(__f, __a) {} |
283 | |
284 | _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__ )) |
285 | explicit __func(const _Fp& __f, _Alloc&& __a) |
286 | : __f_(__f, _VSTDstd::__1::move(__a)) {} |
287 | |
288 | _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__ )) |
289 | explicit __func(_Fp&& __f, _Alloc&& __a) |
290 | : __f_(_VSTDstd::__1::move(__f), _VSTDstd::__1::move(__a)) {} |
291 | |
292 | virtual __base<_Rp(_ArgTypes...)>* __clone() const; |
293 | virtual void __clone(__base<_Rp(_ArgTypes...)>*) const; |
294 | virtual void destroy() _NOEXCEPTnoexcept; |
295 | virtual void destroy_deallocate() _NOEXCEPTnoexcept; |
296 | virtual _Rp operator()(_ArgTypes&&... __arg); |
297 | #ifndef _LIBCPP_NO_RTTI |
298 | virtual const void* target(const type_info&) const _NOEXCEPTnoexcept; |
299 | virtual const std::type_info& target_type() const _NOEXCEPTnoexcept; |
300 | #endif // _LIBCPP_NO_RTTI |
301 | }; |
302 | |
303 | template<class _Fp, class _Alloc, class _Rp, class ..._ArgTypes> |
304 | __base<_Rp(_ArgTypes...)>* |
305 | __func<_Fp, _Alloc, _Rp(_ArgTypes...)>::__clone() const |
306 | { |
307 | typedef allocator_traits<_Alloc> __alloc_traits; |
308 | typedef typename __rebind_alloc_helper<__alloc_traits, __func>::type _Ap; |
309 | _Ap __a(__f_.__get_allocator()); |
310 | typedef __allocator_destructor<_Ap> _Dp; |
311 | unique_ptr<__func, _Dp> __hold(__a.allocate(1), _Dp(__a, 1)); |
312 | ::new ((void*)__hold.get()) __func(__f_.__target(), _Alloc(__a)); |
313 | return __hold.release(); |
314 | } |
315 | |
316 | template<class _Fp, class _Alloc, class _Rp, class ..._ArgTypes> |
317 | void |
318 | __func<_Fp, _Alloc, _Rp(_ArgTypes...)>::__clone(__base<_Rp(_ArgTypes...)>* __p) const |
319 | { |
320 | ::new ((void*)__p) __func(__f_.__target(), __f_.__get_allocator()); |
321 | } |
322 | |
323 | template<class _Fp, class _Alloc, class _Rp, class ..._ArgTypes> |
324 | void |
325 | __func<_Fp, _Alloc, _Rp(_ArgTypes...)>::destroy() _NOEXCEPTnoexcept |
326 | { |
327 | __f_.destroy(); |
328 | } |
329 | |
330 | template<class _Fp, class _Alloc, class _Rp, class ..._ArgTypes> |
331 | void |
332 | __func<_Fp, _Alloc, _Rp(_ArgTypes...)>::destroy_deallocate() _NOEXCEPTnoexcept |
333 | { |
334 | typedef allocator_traits<_Alloc> __alloc_traits; |
335 | typedef typename __rebind_alloc_helper<__alloc_traits, __func>::type _Ap; |
336 | _Ap __a(__f_.__get_allocator()); |
337 | __f_.destroy(); |
338 | __a.deallocate(this, 1); |
339 | } |
340 | |
341 | template<class _Fp, class _Alloc, class _Rp, class ..._ArgTypes> |
342 | _Rp |
343 | __func<_Fp, _Alloc, _Rp(_ArgTypes...)>::operator()(_ArgTypes&& ... __arg) |
344 | { |
345 | return __f_(_VSTDstd::__1::forward<_ArgTypes>(__arg)...); |
346 | } |
347 | |
348 | #ifndef _LIBCPP_NO_RTTI |
349 | |
350 | template<class _Fp, class _Alloc, class _Rp, class ..._ArgTypes> |
351 | const void* |
352 | __func<_Fp, _Alloc, _Rp(_ArgTypes...)>::target(const type_info& __ti) const _NOEXCEPTnoexcept |
353 | { |
354 | if (__ti == typeid(_Fp)) |
355 | return &__f_.__target(); |
356 | return nullptr; |
357 | } |
358 | |
359 | template<class _Fp, class _Alloc, class _Rp, class ..._ArgTypes> |
360 | const std::type_info& |
361 | __func<_Fp, _Alloc, _Rp(_ArgTypes...)>::target_type() const _NOEXCEPTnoexcept |
362 | { |
363 | return typeid(_Fp); |
364 | } |
365 | |
366 | #endif // _LIBCPP_NO_RTTI |
367 | |
368 | // __value_func creates a value-type from a __func. |
369 | |
370 | template <class _Fp> class __value_func; |
371 | |
372 | template <class _Rp, class... _ArgTypes> class __value_func<_Rp(_ArgTypes...)> |
373 | { |
374 | typename aligned_storage<3 * sizeof(void*)>::type __buf_; |
375 | |
376 | typedef __base<_Rp(_ArgTypes...)> __func; |
377 | __func* __f_; |
378 | |
379 | _LIBCPP_NO_CFI__attribute__((__no_sanitize__("cfi"))) static __func* __as_base(void* p) |
380 | { |
381 | return reinterpret_cast<__func*>(p); |
382 | } |
383 | |
384 | public: |
385 | _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__ )) |
386 | __value_func() _NOEXCEPTnoexcept : __f_(nullptr) {} |
387 | |
388 | template <class _Fp, class _Alloc> |
389 | _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__ )) __value_func(_Fp&& __f, const _Alloc& __a) |
390 | : __f_(nullptr) |
391 | { |
392 | typedef allocator_traits<_Alloc> __alloc_traits; |
393 | typedef __function::__func<_Fp, _Alloc, _Rp(_ArgTypes...)> _Fun; |
394 | typedef typename __rebind_alloc_helper<__alloc_traits, _Fun>::type |
395 | _FunAlloc; |
396 | |
397 | if (__function::__not_null(__f)) |
398 | { |
399 | _FunAlloc __af(__a); |
400 | if (sizeof(_Fun) <= sizeof(__buf_) && |
401 | is_nothrow_copy_constructible<_Fp>::value && |
402 | is_nothrow_copy_constructible<_FunAlloc>::value) |
403 | { |
404 | __f_ = |
405 | ::new ((void*)&__buf_) _Fun(_VSTDstd::__1::move(__f), _Alloc(__af)); |
406 | } |
407 | else |
408 | { |
409 | typedef __allocator_destructor<_FunAlloc> _Dp; |
410 | unique_ptr<__func, _Dp> __hold(__af.allocate(1), _Dp(__af, 1)); |
411 | ::new ((void*)__hold.get()) _Fun(_VSTDstd::__1::move(__f), _Alloc(__a)); |
412 | __f_ = __hold.release(); |
413 | } |
414 | } |
415 | } |
416 | |
417 | template <class _Fp, |
418 | class = typename enable_if<!is_same<typename decay<_Fp>::type, __value_func>::value>::type> |
419 | _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__ )) explicit __value_func(_Fp&& __f) |
420 | : __value_func(_VSTDstd::__1::forward<_Fp>(__f), allocator<_Fp>()) {} |
421 | |
422 | _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__ )) |
423 | __value_func(const __value_func& __f) |
424 | { |
425 | if (__f.__f_ == nullptr) |
426 | __f_ = nullptr; |
427 | else if ((void*)__f.__f_ == &__f.__buf_) |
428 | { |
429 | __f_ = __as_base(&__buf_); |
430 | __f.__f_->__clone(__f_); |
431 | } |
432 | else |
433 | __f_ = __f.__f_->__clone(); |
434 | } |
435 | |
436 | _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__ )) |
437 | __value_func(__value_func&& __f) _NOEXCEPTnoexcept |
438 | { |
439 | if (__f.__f_ == nullptr) |
440 | __f_ = nullptr; |
441 | else if ((void*)__f.__f_ == &__f.__buf_) |
442 | { |
443 | __f_ = __as_base(&__buf_); |
444 | __f.__f_->__clone(__f_); |
445 | } |
446 | else |
447 | { |
448 | __f_ = __f.__f_; |
449 | __f.__f_ = nullptr; |
450 | } |
451 | } |
452 | |
453 | _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__ )) |
454 | ~__value_func() |
455 | { |
456 | if ((void*)__f_ == &__buf_) |
457 | __f_->destroy(); |
458 | else if (__f_) |
459 | __f_->destroy_deallocate(); |
460 | } |
461 | |
462 | _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__ )) |
463 | __value_func& operator=(__value_func&& __f) |
464 | { |
465 | *this = nullptr; |
466 | if (__f.__f_ == nullptr) |
467 | __f_ = nullptr; |
468 | else if ((void*)__f.__f_ == &__f.__buf_) |
469 | { |
470 | __f_ = __as_base(&__buf_); |
471 | __f.__f_->__clone(__f_); |
472 | } |
473 | else |
474 | { |
475 | __f_ = __f.__f_; |
476 | __f.__f_ = nullptr; |
477 | } |
478 | return *this; |
479 | } |
480 | |
481 | _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__ )) |
482 | __value_func& operator=(nullptr_t) |
483 | { |
484 | __func* __f = __f_; |
485 | __f_ = nullptr; |
486 | if ((void*)__f == &__buf_) |
487 | __f->destroy(); |
488 | else if (__f) |
489 | __f->destroy_deallocate(); |
490 | return *this; |
491 | } |
492 | |
493 | _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__ )) |
494 | _Rp operator()(_ArgTypes&&... __args) const |
495 | { |
496 | if (__f_ == nullptr) |
497 | __throw_bad_function_call(); |
498 | return (*__f_)(_VSTDstd::__1::forward<_ArgTypes>(__args)...); |
499 | } |
500 | |
501 | _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__ )) |
502 | void swap(__value_func& __f) _NOEXCEPTnoexcept |
503 | { |
504 | if (&__f == this) |
505 | return; |
506 | if ((void*)__f_ == &__buf_ && (void*)__f.__f_ == &__f.__buf_) |
507 | { |
508 | typename aligned_storage<sizeof(__buf_)>::type __tempbuf; |
509 | __func* __t = __as_base(&__tempbuf); |
510 | __f_->__clone(__t); |
511 | __f_->destroy(); |
512 | __f_ = nullptr; |
513 | __f.__f_->__clone(__as_base(&__buf_)); |
514 | __f.__f_->destroy(); |
515 | __f.__f_ = nullptr; |
516 | __f_ = __as_base(&__buf_); |
517 | __t->__clone(__as_base(&__f.__buf_)); |
518 | __t->destroy(); |
519 | __f.__f_ = __as_base(&__f.__buf_); |
520 | } |
521 | else if ((void*)__f_ == &__buf_) |
522 | { |
523 | __f_->__clone(__as_base(&__f.__buf_)); |
524 | __f_->destroy(); |
525 | __f_ = __f.__f_; |
526 | __f.__f_ = __as_base(&__f.__buf_); |
527 | } |
528 | else if ((void*)__f.__f_ == &__f.__buf_) |
529 | { |
530 | __f.__f_->__clone(__as_base(&__buf_)); |
531 | __f.__f_->destroy(); |
532 | __f.__f_ = __f_; |
533 | __f_ = __as_base(&__buf_); |
534 | } |
535 | else |
536 | _VSTDstd::__1::swap(__f_, __f.__f_); |
537 | } |
538 | |
539 | _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__ )) |
540 | explicit operator bool() const _NOEXCEPTnoexcept { return __f_ != nullptr; } |
541 | |
542 | #ifndef _LIBCPP_NO_RTTI |
543 | _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__ )) |
544 | const std::type_info& target_type() const _NOEXCEPTnoexcept |
545 | { |
546 | if (__f_ == nullptr) |
547 | return typeid(void); |
548 | return __f_->target_type(); |
549 | } |
550 | |
551 | template <typename _Tp> |
552 | _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__ )) const _Tp* target() const _NOEXCEPTnoexcept |
553 | { |
554 | if (__f_ == nullptr) |
555 | return nullptr; |
556 | return (const _Tp*)__f_->target(typeid(_Tp)); |
557 | } |
558 | #endif // _LIBCPP_NO_RTTI |
559 | }; |
560 | |
561 | // Storage for a functor object, to be used with __policy to manage copy and |
562 | // destruction. |
563 | union __policy_storage |
564 | { |
565 | mutable char __small[sizeof(void*) * 2]; |
566 | void* __large; |
567 | }; |
568 | |
569 | // True if _Fun can safely be held in __policy_storage.__small. |
570 | template <typename _Fun> |
571 | struct __use_small_storage |
572 | : public integral_constant< |
573 | bool, sizeof(_Fun) <= sizeof(__policy_storage) && |
574 | _LIBCPP_ALIGNOF(_Fun)alignof(_Fun) <= _LIBCPP_ALIGNOF(__policy_storage)alignof(__policy_storage) && |
575 | is_trivially_copy_constructible<_Fun>::value && |
576 | is_trivially_destructible<_Fun>::value> {}; |
577 | |
578 | // Policy contains information about how to copy, destroy, and move the |
579 | // underlying functor. You can think of it as a vtable of sorts. |
580 | struct __policy |
581 | { |
582 | // Used to copy or destroy __large values. null for trivial objects. |
583 | void* (*const __clone)(const void*); |
584 | void (*const __destroy)(void*); |
585 | |
586 | // True if this is the null policy (no value). |
587 | const bool __is_null; |
588 | |
589 | // The target type. May be null if RTTI is disabled. |
590 | const std::type_info* const __type_info; |
591 | |
592 | // Returns a pointer to a static policy object suitable for the functor |
593 | // type. |
594 | template <typename _Fun> |
595 | _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__ )) static const __policy* __create() |
596 | { |
597 | return __choose_policy<_Fun>(__use_small_storage<_Fun>()); |
598 | } |
599 | |
600 | _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__ )) |
601 | static const __policy* __create_empty() |
602 | { |
603 | static const _LIBCPP_CONSTEXPRconstexpr __policy __policy_ = {nullptr, nullptr, |
604 | true, |
605 | #ifndef _LIBCPP_NO_RTTI |
606 | &typeid(void) |
607 | #else |
608 | nullptr |
609 | #endif |
610 | }; |
611 | return &__policy_; |
612 | } |
613 | |
614 | private: |
615 | template <typename _Fun> static void* __large_clone(const void* __s) |
616 | { |
617 | const _Fun* __f = static_cast<const _Fun*>(__s); |
618 | return __f->__clone(); |
619 | } |
620 | |
621 | template <typename _Fun> |
622 | static void __large_destroy(void* __s) { |
623 | _Fun::__destroy_and_delete(static_cast<_Fun*>(__s)); |
624 | } |
625 | |
626 | template <typename _Fun> |
627 | _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__ )) static const __policy* |
628 | __choose_policy(/* is_small = */ false_type) { |
629 | static const _LIBCPP_CONSTEXPRconstexpr __policy __policy_ = { |
630 | &__large_clone<_Fun>, &__large_destroy<_Fun>, false, |
631 | #ifndef _LIBCPP_NO_RTTI |
632 | &typeid(typename _Fun::_Target) |
633 | #else |
634 | nullptr |
635 | #endif |
636 | }; |
637 | return &__policy_; |
638 | } |
639 | |
640 | template <typename _Fun> |
641 | _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__ )) static const __policy* |
642 | __choose_policy(/* is_small = */ true_type) |
643 | { |
644 | static const _LIBCPP_CONSTEXPRconstexpr __policy __policy_ = { |
645 | nullptr, nullptr, false, |
646 | #ifndef _LIBCPP_NO_RTTI |
647 | &typeid(typename _Fun::_Target) |
648 | #else |
649 | nullptr |
650 | #endif |
651 | }; |
652 | return &__policy_; |
653 | } |
654 | }; |
655 | |
656 | // Used to choose between perfect forwarding or pass-by-value. Pass-by-value is |
657 | // faster for types that can be passed in registers. |
658 | template <typename _Tp> |
659 | using __fast_forward = |
660 | typename conditional<is_scalar<_Tp>::value, _Tp, _Tp&&>::type; |
661 | |
662 | // __policy_invoker calls an instance of __alloc_func held in __policy_storage. |
663 | |
664 | template <class _Fp> struct __policy_invoker; |
665 | |
666 | template <class _Rp, class... _ArgTypes> |
667 | struct __policy_invoker<_Rp(_ArgTypes...)> |
668 | { |
669 | typedef _Rp (*__Call)(const __policy_storage*, |
670 | __fast_forward<_ArgTypes>...); |
671 | |
672 | __Call __call_; |
673 | |
674 | // Creates an invoker that throws bad_function_call. |
675 | _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__ )) |
676 | __policy_invoker() : __call_(&__call_empty) {} |
677 | |
678 | // Creates an invoker that calls the given instance of __func. |
679 | template <typename _Fun> |
680 | _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__ )) static __policy_invoker __create() |
681 | { |
682 | return __policy_invoker(&__call_impl<_Fun>); |
683 | } |
684 | |
685 | private: |
686 | _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__ )) |
687 | explicit __policy_invoker(__Call __c) : __call_(__c) {} |
688 | |
689 | static _Rp __call_empty(const __policy_storage*, |
690 | __fast_forward<_ArgTypes>...) |
691 | { |
692 | __throw_bad_function_call(); |
693 | } |
694 | |
695 | template <typename _Fun> |
696 | static _Rp __call_impl(const __policy_storage* __buf, |
697 | __fast_forward<_ArgTypes>... __args) |
698 | { |
699 | _Fun* __f = reinterpret_cast<_Fun*>(__use_small_storage<_Fun>::value |
700 | ? &__buf->__small |
701 | : __buf->__large); |
702 | return (*__f)(_VSTDstd::__1::forward<_ArgTypes>(__args)...); |
703 | } |
704 | }; |
705 | |
706 | // __policy_func uses a __policy and __policy_invoker to create a type-erased, |
707 | // copyable functor. |
708 | |
709 | template <class _Fp> class __policy_func; |
710 | |
711 | template <class _Rp, class... _ArgTypes> class __policy_func<_Rp(_ArgTypes...)> |
712 | { |
713 | // Inline storage for small objects. |
714 | __policy_storage __buf_; |
715 | |
716 | // Calls the value stored in __buf_. This could technically be part of |
717 | // policy, but storing it here eliminates a level of indirection inside |
718 | // operator(). |
719 | typedef __function::__policy_invoker<_Rp(_ArgTypes...)> __invoker; |
720 | __invoker __invoker_; |
721 | |
722 | // The policy that describes how to move / copy / destroy __buf_. Never |
723 | // null, even if the function is empty. |
724 | const __policy* __policy_; |
725 | |
726 | public: |
727 | _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__ )) |
728 | __policy_func() : __policy_(__policy::__create_empty()) {} |
729 | |
730 | template <class _Fp, class _Alloc> |
731 | _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__ )) __policy_func(_Fp&& __f, const _Alloc& __a) |
732 | : __policy_(__policy::__create_empty()) |
733 | { |
734 | typedef __alloc_func<_Fp, _Alloc, _Rp(_ArgTypes...)> _Fun; |
735 | typedef allocator_traits<_Alloc> __alloc_traits; |
736 | typedef typename __rebind_alloc_helper<__alloc_traits, _Fun>::type |
737 | _FunAlloc; |
738 | |
739 | if (__function::__not_null(__f)) |
740 | { |
741 | __invoker_ = __invoker::template __create<_Fun>(); |
742 | __policy_ = __policy::__create<_Fun>(); |
743 | |
744 | _FunAlloc __af(__a); |
745 | if (__use_small_storage<_Fun>()) |
746 | { |
747 | ::new ((void*)&__buf_.__small) |
748 | _Fun(_VSTDstd::__1::move(__f), _Alloc(__af)); |
749 | } |
750 | else |
751 | { |
752 | typedef __allocator_destructor<_FunAlloc> _Dp; |
753 | unique_ptr<_Fun, _Dp> __hold(__af.allocate(1), _Dp(__af, 1)); |
754 | ::new ((void*)__hold.get()) |
755 | _Fun(_VSTDstd::__1::move(__f), _Alloc(__af)); |
756 | __buf_.__large = __hold.release(); |
757 | } |
758 | } |
759 | } |
760 | |
761 | template <class _Fp, class = typename enable_if<!is_same<typename decay<_Fp>::type, __policy_func>::value>::type> |
762 | _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__ )) explicit __policy_func(_Fp&& __f) |
763 | : __policy_(__policy::__create_empty()) { |
764 | typedef __default_alloc_func<_Fp, _Rp(_ArgTypes...)> _Fun; |
765 | |
766 | if (__function::__not_null(__f)) { |
767 | __invoker_ = __invoker::template __create<_Fun>(); |
768 | __policy_ = __policy::__create<_Fun>(); |
769 | if (__use_small_storage<_Fun>()) { |
770 | ::new ((void*)&__buf_.__small) _Fun(_VSTDstd::__1::move(__f)); |
771 | } else { |
772 | __builtin_new_allocator::__holder_t __hold = |
773 | __builtin_new_allocator::__allocate_type<_Fun>(1); |
774 | __buf_.__large = ::new ((void*)__hold.get()) _Fun(_VSTDstd::__1::move(__f)); |
775 | (void)__hold.release(); |
776 | } |
777 | } |
778 | } |
779 | |
780 | _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__ )) |
781 | __policy_func(const __policy_func& __f) |
782 | : __buf_(__f.__buf_), __invoker_(__f.__invoker_), |
783 | __policy_(__f.__policy_) |
784 | { |
785 | if (__policy_->__clone) |
786 | __buf_.__large = __policy_->__clone(__f.__buf_.__large); |
787 | } |
788 | |
789 | _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__ )) |
790 | __policy_func(__policy_func&& __f) |
791 | : __buf_(__f.__buf_), __invoker_(__f.__invoker_), |
792 | __policy_(__f.__policy_) |
793 | { |
794 | if (__policy_->__destroy) |
795 | { |
796 | __f.__policy_ = __policy::__create_empty(); |
797 | __f.__invoker_ = __invoker(); |
798 | } |
799 | } |
800 | |
801 | _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__ )) |
802 | ~__policy_func() |
803 | { |
804 | if (__policy_->__destroy) |
805 | __policy_->__destroy(__buf_.__large); |
806 | } |
807 | |
808 | _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__ )) |
809 | __policy_func& operator=(__policy_func&& __f) |
810 | { |
811 | *this = nullptr; |
812 | __buf_ = __f.__buf_; |
813 | __invoker_ = __f.__invoker_; |
814 | __policy_ = __f.__policy_; |
815 | __f.__policy_ = __policy::__create_empty(); |
816 | __f.__invoker_ = __invoker(); |
817 | return *this; |
818 | } |
819 | |
820 | _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__ )) |
821 | __policy_func& operator=(nullptr_t) |
822 | { |
823 | const __policy* __p = __policy_; |
824 | __policy_ = __policy::__create_empty(); |
825 | __invoker_ = __invoker(); |
826 | if (__p->__destroy) |
827 | __p->__destroy(__buf_.__large); |
828 | return *this; |
829 | } |
830 | |
831 | _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__ )) |
832 | _Rp operator()(_ArgTypes&&... __args) const |
833 | { |
834 | return __invoker_.__call_(_VSTDstd::__1::addressof(__buf_), |
835 | _VSTDstd::__1::forward<_ArgTypes>(__args)...); |
836 | } |
837 | |
838 | _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__ )) |
839 | void swap(__policy_func& __f) |
840 | { |
841 | _VSTDstd::__1::swap(__invoker_, __f.__invoker_); |
842 | _VSTDstd::__1::swap(__policy_, __f.__policy_); |
843 | _VSTDstd::__1::swap(__buf_, __f.__buf_); |
844 | } |
845 | |
846 | _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__ )) |
847 | explicit operator bool() const _NOEXCEPTnoexcept |
848 | { |
849 | return !__policy_->__is_null; |
850 | } |
851 | |
852 | #ifndef _LIBCPP_NO_RTTI |
853 | _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__ )) |
854 | const std::type_info& target_type() const _NOEXCEPTnoexcept |
855 | { |
856 | return *__policy_->__type_info; |
857 | } |
858 | |
859 | template <typename _Tp> |
860 | _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__ )) const _Tp* target() const _NOEXCEPTnoexcept |
861 | { |
862 | if (__policy_->__is_null || typeid(_Tp) != *__policy_->__type_info) |
863 | return nullptr; |
864 | if (__policy_->__clone) // Out of line storage. |
865 | return reinterpret_cast<const _Tp*>(__buf_.__large); |
866 | else |
867 | return reinterpret_cast<const _Tp*>(&__buf_.__small); |
868 | } |
869 | #endif // _LIBCPP_NO_RTTI |
870 | }; |
871 | |
872 | #if defined(_LIBCPP_HAS_BLOCKS_RUNTIME) && !defined(_LIBCPP_HAS_OBJC_ARC) |
873 | |
874 | extern "C" void *_Block_copy(const void *); |
875 | extern "C" void _Block_release(const void *); |
876 | |
877 | template<class _Rp1, class ..._ArgTypes1, class _Alloc, class _Rp, class ..._ArgTypes> |
878 | class __func<_Rp1(^)(_ArgTypes1...), _Alloc, _Rp(_ArgTypes...)> |
879 | : public __base<_Rp(_ArgTypes...)> |
880 | { |
881 | typedef _Rp1(^__block_type)(_ArgTypes1...); |
882 | __block_type __f_; |
883 | |
884 | public: |
885 | _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__ )) |
886 | explicit __func(__block_type const& __f) |
887 | : __f_(reinterpret_cast<__block_type>(__f ? _Block_copy(__f) : nullptr)) |
888 | { } |
889 | |
890 | // [TODO] add && to save on a retain |
891 | |
892 | _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__ )) |
893 | explicit __func(__block_type __f, const _Alloc& /* unused */) |
894 | : __f_(reinterpret_cast<__block_type>(__f ? _Block_copy(__f) : nullptr)) |
895 | { } |
896 | |
897 | virtual __base<_Rp(_ArgTypes...)>* __clone() const { |
898 | _LIBCPP_ASSERT(false,((void)0) |
899 | "Block pointers are just pointers, so they should always fit into "((void)0) |
900 | "std::function's small buffer optimization. This function should "((void)0) |
901 | "never be invoked.")((void)0); |
902 | return nullptr; |
903 | } |
904 | |
905 | virtual void __clone(__base<_Rp(_ArgTypes...)>* __p) const { |
906 | ::new ((void*)__p) __func(__f_); |
907 | } |
908 | |
909 | virtual void destroy() _NOEXCEPTnoexcept { |
910 | if (__f_) |
911 | _Block_release(__f_); |
912 | __f_ = 0; |
913 | } |
914 | |
915 | virtual void destroy_deallocate() _NOEXCEPTnoexcept { |
916 | _LIBCPP_ASSERT(false,((void)0) |
917 | "Block pointers are just pointers, so they should always fit into "((void)0) |
918 | "std::function's small buffer optimization. This function should "((void)0) |
919 | "never be invoked.")((void)0); |
920 | } |
921 | |
922 | virtual _Rp operator()(_ArgTypes&& ... __arg) { |
923 | return _VSTDstd::__1::__invoke(__f_, _VSTDstd::__1::forward<_ArgTypes>(__arg)...); |
924 | } |
925 | |
926 | #ifndef _LIBCPP_NO_RTTI |
927 | virtual const void* target(type_info const& __ti) const _NOEXCEPTnoexcept { |
928 | if (__ti == typeid(__func::__block_type)) |
929 | return &__f_; |
930 | return (const void*)nullptr; |
931 | } |
932 | |
933 | virtual const std::type_info& target_type() const _NOEXCEPTnoexcept { |
934 | return typeid(__func::__block_type); |
935 | } |
936 | #endif // _LIBCPP_NO_RTTI |
937 | }; |
938 | |
939 | #endif // _LIBCPP_HAS_EXTENSION_BLOCKS && !_LIBCPP_HAS_OBJC_ARC |
940 | |
941 | } // __function |
942 | |
943 | template<class _Rp, class ..._ArgTypes> |
944 | class _LIBCPP_TEMPLATE_VIS__attribute__ ((__type_visibility__("default"))) function<_Rp(_ArgTypes...)> |
945 | #if _LIBCPP_STD_VER14 <= 17 || !defined(_LIBCPP_ABI_NO_BINDER_BASES) |
946 | : public __function::__maybe_derive_from_unary_function<_Rp(_ArgTypes...)>, |
947 | public __function::__maybe_derive_from_binary_function<_Rp(_ArgTypes...)> |
948 | #endif |
949 | { |
950 | #ifndef _LIBCPP_ABI_OPTIMIZED_FUNCTION |
951 | typedef __function::__value_func<_Rp(_ArgTypes...)> __func; |
952 | #else |
953 | typedef __function::__policy_func<_Rp(_ArgTypes...)> __func; |
954 | #endif |
955 | |
956 | __func __f_; |
957 | |
958 | template <class _Fp, bool = _And< |
959 | _IsNotSame<__uncvref_t<_Fp>, function>, |
960 | __invokable<_Fp, _ArgTypes...> |
961 | >::value> |
962 | struct __callable; |
963 | template <class _Fp> |
964 | struct __callable<_Fp, true> |
965 | { |
966 | static const bool value = is_void<_Rp>::value || |
967 | __is_core_convertible<typename __invoke_of<_Fp, _ArgTypes...>::type, |
968 | _Rp>::value; |
969 | }; |
970 | template <class _Fp> |
971 | struct __callable<_Fp, false> |
972 | { |
973 | static const bool value = false; |
974 | }; |
975 | |
976 | template <class _Fp> |
977 | using _EnableIfLValueCallable = typename enable_if<__callable<_Fp&>::value>::type; |
978 | public: |
979 | typedef _Rp result_type; |
980 | |
981 | // construct/copy/destroy: |
982 | _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__ )) |
983 | function() _NOEXCEPTnoexcept { } |
984 | _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__ )) |
985 | function(nullptr_t) _NOEXCEPTnoexcept {} |
986 | function(const function&); |
987 | function(function&&) _NOEXCEPTnoexcept; |
988 | template<class _Fp, class = _EnableIfLValueCallable<_Fp>> |
989 | function(_Fp); |
990 | |
991 | #if _LIBCPP_STD_VER14 <= 14 |
992 | template<class _Alloc> |
993 | _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__ )) |
994 | function(allocator_arg_t, const _Alloc&) _NOEXCEPTnoexcept {} |
995 | template<class _Alloc> |
996 | _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__ )) |
997 | function(allocator_arg_t, const _Alloc&, nullptr_t) _NOEXCEPTnoexcept {} |
998 | template<class _Alloc> |
999 | function(allocator_arg_t, const _Alloc&, const function&); |
1000 | template<class _Alloc> |
1001 | function(allocator_arg_t, const _Alloc&, function&&); |
1002 | template<class _Fp, class _Alloc, class = _EnableIfLValueCallable<_Fp>> |
1003 | function(allocator_arg_t, const _Alloc& __a, _Fp __f); |
1004 | #endif |
1005 | |
1006 | function& operator=(const function&); |
1007 | function& operator=(function&&) _NOEXCEPTnoexcept; |
1008 | function& operator=(nullptr_t) _NOEXCEPTnoexcept; |
1009 | template<class _Fp, class = _EnableIfLValueCallable<typename decay<_Fp>::type>> |
1010 | function& operator=(_Fp&&); |
1011 | |
1012 | ~function(); |
1013 | |
1014 | // function modifiers: |
1015 | void swap(function&) _NOEXCEPTnoexcept; |
1016 | |
1017 | #if _LIBCPP_STD_VER14 <= 14 |
1018 | template<class _Fp, class _Alloc> |
1019 | _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__ )) |
1020 | void assign(_Fp&& __f, const _Alloc& __a) |
1021 | {function(allocator_arg, __a, _VSTDstd::__1::forward<_Fp>(__f)).swap(*this);} |
1022 | #endif |
1023 | |
1024 | // function capacity: |
1025 | _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__ )) |
1026 | explicit operator bool() const _NOEXCEPTnoexcept { |
1027 | return static_cast<bool>(__f_); |
1028 | } |
1029 | |
1030 | // deleted overloads close possible hole in the type system |
1031 | template<class _R2, class... _ArgTypes2> |
1032 | bool operator==(const function<_R2(_ArgTypes2...)>&) const = delete; |
1033 | template<class _R2, class... _ArgTypes2> |
1034 | bool operator!=(const function<_R2(_ArgTypes2...)>&) const = delete; |
1035 | public: |
1036 | // function invocation: |
1037 | _Rp operator()(_ArgTypes...) const; |
1038 | |
1039 | #ifndef _LIBCPP_NO_RTTI |
1040 | // function target access: |
1041 | const std::type_info& target_type() const _NOEXCEPTnoexcept; |
1042 | template <typename _Tp> _Tp* target() _NOEXCEPTnoexcept; |
1043 | template <typename _Tp> const _Tp* target() const _NOEXCEPTnoexcept; |
1044 | #endif // _LIBCPP_NO_RTTI |
1045 | }; |
1046 | |
1047 | #ifndef _LIBCPP_HAS_NO_DEDUCTION_GUIDES |
1048 | template<class _Rp, class ..._Ap> |
1049 | function(_Rp(*)(_Ap...)) -> function<_Rp(_Ap...)>; |
1050 | |
1051 | template<class _Fp> |
1052 | struct __strip_signature; |
1053 | |
1054 | template<class _Rp, class _Gp, class ..._Ap> |
1055 | struct __strip_signature<_Rp (_Gp::*) (_Ap...)> { using type = _Rp(_Ap...); }; |
1056 | template<class _Rp, class _Gp, class ..._Ap> |
1057 | struct __strip_signature<_Rp (_Gp::*) (_Ap...) const> { using type = _Rp(_Ap...); }; |
1058 | template<class _Rp, class _Gp, class ..._Ap> |
1059 | struct __strip_signature<_Rp (_Gp::*) (_Ap...) volatile> { using type = _Rp(_Ap...); }; |
1060 | template<class _Rp, class _Gp, class ..._Ap> |
1061 | struct __strip_signature<_Rp (_Gp::*) (_Ap...) const volatile> { using type = _Rp(_Ap...); }; |
1062 | |
1063 | template<class _Rp, class _Gp, class ..._Ap> |
1064 | struct __strip_signature<_Rp (_Gp::*) (_Ap...) &> { using type = _Rp(_Ap...); }; |
1065 | template<class _Rp, class _Gp, class ..._Ap> |
1066 | struct __strip_signature<_Rp (_Gp::*) (_Ap...) const &> { using type = _Rp(_Ap...); }; |
1067 | template<class _Rp, class _Gp, class ..._Ap> |
1068 | struct __strip_signature<_Rp (_Gp::*) (_Ap...) volatile &> { using type = _Rp(_Ap...); }; |
1069 | template<class _Rp, class _Gp, class ..._Ap> |
1070 | struct __strip_signature<_Rp (_Gp::*) (_Ap...) const volatile &> { using type = _Rp(_Ap...); }; |
1071 | |
1072 | template<class _Rp, class _Gp, class ..._Ap> |
1073 | struct __strip_signature<_Rp (_Gp::*) (_Ap...) noexcept> { using type = _Rp(_Ap...); }; |
1074 | template<class _Rp, class _Gp, class ..._Ap> |
1075 | struct __strip_signature<_Rp (_Gp::*) (_Ap...) const noexcept> { using type = _Rp(_Ap...); }; |
1076 | template<class _Rp, class _Gp, class ..._Ap> |
1077 | struct __strip_signature<_Rp (_Gp::*) (_Ap...) volatile noexcept> { using type = _Rp(_Ap...); }; |
1078 | template<class _Rp, class _Gp, class ..._Ap> |
1079 | struct __strip_signature<_Rp (_Gp::*) (_Ap...) const volatile noexcept> { using type = _Rp(_Ap...); }; |
1080 | |
1081 | template<class _Rp, class _Gp, class ..._Ap> |
1082 | struct __strip_signature<_Rp (_Gp::*) (_Ap...) & noexcept> { using type = _Rp(_Ap...); }; |
1083 | template<class _Rp, class _Gp, class ..._Ap> |
1084 | struct __strip_signature<_Rp (_Gp::*) (_Ap...) const & noexcept> { using type = _Rp(_Ap...); }; |
1085 | template<class _Rp, class _Gp, class ..._Ap> |
1086 | struct __strip_signature<_Rp (_Gp::*) (_Ap...) volatile & noexcept> { using type = _Rp(_Ap...); }; |
1087 | template<class _Rp, class _Gp, class ..._Ap> |
1088 | struct __strip_signature<_Rp (_Gp::*) (_Ap...) const volatile & noexcept> { using type = _Rp(_Ap...); }; |
1089 | |
1090 | template<class _Fp, class _Stripped = typename __strip_signature<decltype(&_Fp::operator())>::type> |
1091 | function(_Fp) -> function<_Stripped>; |
1092 | #endif // !_LIBCPP_HAS_NO_DEDUCTION_GUIDES |
1093 | |
1094 | template<class _Rp, class ..._ArgTypes> |
1095 | function<_Rp(_ArgTypes...)>::function(const function& __f) : __f_(__f.__f_) {} |
1096 | |
1097 | #if _LIBCPP_STD_VER14 <= 14 |
1098 | template<class _Rp, class ..._ArgTypes> |
1099 | template <class _Alloc> |
1100 | function<_Rp(_ArgTypes...)>::function(allocator_arg_t, const _Alloc&, |
1101 | const function& __f) : __f_(__f.__f_) {} |
1102 | #endif |
1103 | |
1104 | template <class _Rp, class... _ArgTypes> |
1105 | function<_Rp(_ArgTypes...)>::function(function&& __f) _NOEXCEPTnoexcept |
1106 | : __f_(_VSTDstd::__1::move(__f.__f_)) {} |
1107 | |
1108 | #if _LIBCPP_STD_VER14 <= 14 |
1109 | template<class _Rp, class ..._ArgTypes> |
1110 | template <class _Alloc> |
1111 | function<_Rp(_ArgTypes...)>::function(allocator_arg_t, const _Alloc&, |
1112 | function&& __f) |
1113 | : __f_(_VSTDstd::__1::move(__f.__f_)) {} |
1114 | #endif |
1115 | |
1116 | template <class _Rp, class... _ArgTypes> |
1117 | template <class _Fp, class> |
1118 | function<_Rp(_ArgTypes...)>::function(_Fp __f) : __f_(_VSTDstd::__1::move(__f)) {} |
1119 | |
1120 | #if _LIBCPP_STD_VER14 <= 14 |
1121 | template <class _Rp, class... _ArgTypes> |
1122 | template <class _Fp, class _Alloc, class> |
1123 | function<_Rp(_ArgTypes...)>::function(allocator_arg_t, const _Alloc& __a, |
1124 | _Fp __f) |
1125 | : __f_(_VSTDstd::__1::move(__f), __a) {} |
1126 | #endif |
1127 | |
1128 | template<class _Rp, class ..._ArgTypes> |
1129 | function<_Rp(_ArgTypes...)>& |
1130 | function<_Rp(_ArgTypes...)>::operator=(const function& __f) |
1131 | { |
1132 | function(__f).swap(*this); |
1133 | return *this; |
1134 | } |
1135 | |
1136 | template<class _Rp, class ..._ArgTypes> |
1137 | function<_Rp(_ArgTypes...)>& |
1138 | function<_Rp(_ArgTypes...)>::operator=(function&& __f) _NOEXCEPTnoexcept |
1139 | { |
1140 | __f_ = _VSTDstd::__1::move(__f.__f_); |
1141 | return *this; |
1142 | } |
1143 | |
1144 | template<class _Rp, class ..._ArgTypes> |
1145 | function<_Rp(_ArgTypes...)>& |
1146 | function<_Rp(_ArgTypes...)>::operator=(nullptr_t) _NOEXCEPTnoexcept |
1147 | { |
1148 | __f_ = nullptr; |
1149 | return *this; |
1150 | } |
1151 | |
1152 | template<class _Rp, class ..._ArgTypes> |
1153 | template <class _Fp, class> |
1154 | function<_Rp(_ArgTypes...)>& |
1155 | function<_Rp(_ArgTypes...)>::operator=(_Fp&& __f) |
1156 | { |
1157 | function(_VSTDstd::__1::forward<_Fp>(__f)).swap(*this); |
1158 | return *this; |
1159 | } |
1160 | |
1161 | template<class _Rp, class ..._ArgTypes> |
1162 | function<_Rp(_ArgTypes...)>::~function() {} |
1163 | |
1164 | template<class _Rp, class ..._ArgTypes> |
1165 | void |
1166 | function<_Rp(_ArgTypes...)>::swap(function& __f) _NOEXCEPTnoexcept |
1167 | { |
1168 | __f_.swap(__f.__f_); |
1169 | } |
1170 | |
1171 | template<class _Rp, class ..._ArgTypes> |
1172 | _Rp |
1173 | function<_Rp(_ArgTypes...)>::operator()(_ArgTypes... __arg) const |
1174 | { |
1175 | return __f_(_VSTDstd::__1::forward<_ArgTypes>(__arg)...); |
1176 | } |
1177 | |
1178 | #ifndef _LIBCPP_NO_RTTI |
1179 | |
1180 | template<class _Rp, class ..._ArgTypes> |
1181 | const std::type_info& |
1182 | function<_Rp(_ArgTypes...)>::target_type() const _NOEXCEPTnoexcept |
1183 | { |
1184 | return __f_.target_type(); |
1185 | } |
1186 | |
1187 | template<class _Rp, class ..._ArgTypes> |
1188 | template <typename _Tp> |
1189 | _Tp* |
1190 | function<_Rp(_ArgTypes...)>::target() _NOEXCEPTnoexcept |
1191 | { |
1192 | return (_Tp*)(__f_.template target<_Tp>()); |
1193 | } |
1194 | |
1195 | template<class _Rp, class ..._ArgTypes> |
1196 | template <typename _Tp> |
1197 | const _Tp* |
1198 | function<_Rp(_ArgTypes...)>::target() const _NOEXCEPTnoexcept |
1199 | { |
1200 | return __f_.template target<_Tp>(); |
1201 | } |
1202 | |
1203 | #endif // _LIBCPP_NO_RTTI |
1204 | |
1205 | template <class _Rp, class... _ArgTypes> |
1206 | inline _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__ )) |
1207 | bool |
1208 | operator==(const function<_Rp(_ArgTypes...)>& __f, nullptr_t) _NOEXCEPTnoexcept {return !__f;} |
1209 | |
1210 | template <class _Rp, class... _ArgTypes> |
1211 | inline _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__ )) |
1212 | bool |
1213 | operator==(nullptr_t, const function<_Rp(_ArgTypes...)>& __f) _NOEXCEPTnoexcept {return !__f;} |
1214 | |
1215 | template <class _Rp, class... _ArgTypes> |
1216 | inline _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__ )) |
1217 | bool |
1218 | operator!=(const function<_Rp(_ArgTypes...)>& __f, nullptr_t) _NOEXCEPTnoexcept {return (bool)__f;} |
1219 | |
1220 | template <class _Rp, class... _ArgTypes> |
1221 | inline _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__ )) |
1222 | bool |
1223 | operator!=(nullptr_t, const function<_Rp(_ArgTypes...)>& __f) _NOEXCEPTnoexcept {return (bool)__f;} |
1224 | |
1225 | template <class _Rp, class... _ArgTypes> |
1226 | inline _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__ )) |
1227 | void |
1228 | swap(function<_Rp(_ArgTypes...)>& __x, function<_Rp(_ArgTypes...)>& __y) _NOEXCEPTnoexcept |
1229 | {return __x.swap(__y);} |
1230 | |
1231 | #else // _LIBCPP_CXX03_LANG |
1232 | |
1233 | namespace __function { |
1234 | |
1235 | template<class _Fp> class __base; |
1236 | |
1237 | template<class _Rp> |
1238 | class __base<_Rp()> |
1239 | { |
1240 | __base(const __base&); |
1241 | __base& operator=(const __base&); |
1242 | public: |
1243 | __base() {} |
1244 | virtual ~__base() {} |
1245 | virtual __base* __clone() const = 0; |
1246 | virtual void __clone(__base*) const = 0; |
1247 | virtual void destroy() = 0; |
1248 | virtual void destroy_deallocate() = 0; |
1249 | virtual _Rp operator()() = 0; |
1250 | #ifndef _LIBCPP_NO_RTTI |
1251 | virtual const void* target(const type_info&) const = 0; |
1252 | virtual const std::type_info& target_type() const = 0; |
1253 | #endif // _LIBCPP_NO_RTTI |
1254 | }; |
1255 | |
1256 | template<class _Rp, class _A0> |
1257 | class __base<_Rp(_A0)> |
1258 | { |
1259 | __base(const __base&); |
1260 | __base& operator=(const __base&); |
1261 | public: |
1262 | __base() {} |
1263 | virtual ~__base() {} |
1264 | virtual __base* __clone() const = 0; |
1265 | virtual void __clone(__base*) const = 0; |
1266 | virtual void destroy() = 0; |
1267 | virtual void destroy_deallocate() = 0; |
1268 | virtual _Rp operator()(_A0) = 0; |
1269 | #ifndef _LIBCPP_NO_RTTI |
1270 | virtual const void* target(const type_info&) const = 0; |
1271 | virtual const std::type_info& target_type() const = 0; |
1272 | #endif // _LIBCPP_NO_RTTI |
1273 | }; |
1274 | |
1275 | template<class _Rp, class _A0, class _A1> |
1276 | class __base<_Rp(_A0, _A1)> |
1277 | { |
1278 | __base(const __base&); |
1279 | __base& operator=(const __base&); |
1280 | public: |
1281 | __base() {} |
1282 | virtual ~__base() {} |
1283 | virtual __base* __clone() const = 0; |
1284 | virtual void __clone(__base*) const = 0; |
1285 | virtual void destroy() = 0; |
1286 | virtual void destroy_deallocate() = 0; |
1287 | virtual _Rp operator()(_A0, _A1) = 0; |
1288 | #ifndef _LIBCPP_NO_RTTI |
1289 | virtual const void* target(const type_info&) const = 0; |
1290 | virtual const std::type_info& target_type() const = 0; |
1291 | #endif // _LIBCPP_NO_RTTI |
1292 | }; |
1293 | |
1294 | template<class _Rp, class _A0, class _A1, class _A2> |
1295 | class __base<_Rp(_A0, _A1, _A2)> |
1296 | { |
1297 | __base(const __base&); |
1298 | __base& operator=(const __base&); |
1299 | public: |
1300 | __base() {} |
1301 | virtual ~__base() {} |
1302 | virtual __base* __clone() const = 0; |
1303 | virtual void __clone(__base*) const = 0; |
1304 | virtual void destroy() = 0; |
1305 | virtual void destroy_deallocate() = 0; |
1306 | virtual _Rp operator()(_A0, _A1, _A2) = 0; |
1307 | #ifndef _LIBCPP_NO_RTTI |
1308 | virtual const void* target(const type_info&) const = 0; |
1309 | virtual const std::type_info& target_type() const = 0; |
1310 | #endif // _LIBCPP_NO_RTTI |
1311 | }; |
1312 | |
1313 | template<class _FD, class _Alloc, class _FB> class __func; |
1314 | |
1315 | template<class _Fp, class _Alloc, class _Rp> |
1316 | class __func<_Fp, _Alloc, _Rp()> |
1317 | : public __base<_Rp()> |
1318 | { |
1319 | __compressed_pair<_Fp, _Alloc> __f_; |
1320 | public: |
1321 | explicit __func(_Fp __f) : __f_(_VSTDstd::__1::move(__f), __default_init_tag()) {} |
1322 | explicit __func(_Fp __f, _Alloc __a) : __f_(_VSTDstd::__1::move(__f), _VSTDstd::__1::move(__a)) {} |
1323 | virtual __base<_Rp()>* __clone() const; |
1324 | virtual void __clone(__base<_Rp()>*) const; |
1325 | virtual void destroy(); |
1326 | virtual void destroy_deallocate(); |
1327 | virtual _Rp operator()(); |
1328 | #ifndef _LIBCPP_NO_RTTI |
1329 | virtual const void* target(const type_info&) const; |
1330 | virtual const std::type_info& target_type() const; |
1331 | #endif // _LIBCPP_NO_RTTI |
1332 | }; |
1333 | |
1334 | template<class _Fp, class _Alloc, class _Rp> |
1335 | __base<_Rp()>* |
1336 | __func<_Fp, _Alloc, _Rp()>::__clone() const |
1337 | { |
1338 | typedef allocator_traits<_Alloc> __alloc_traits; |
1339 | typedef typename __rebind_alloc_helper<__alloc_traits, __func>::type _Ap; |
1340 | _Ap __a(__f_.second()); |
1341 | typedef __allocator_destructor<_Ap> _Dp; |
1342 | unique_ptr<__func, _Dp> __hold(__a.allocate(1), _Dp(__a, 1)); |
1343 | ::new ((void*)__hold.get()) __func(__f_.first(), _Alloc(__a)); |
1344 | return __hold.release(); |
1345 | } |
1346 | |
1347 | template<class _Fp, class _Alloc, class _Rp> |
1348 | void |
1349 | __func<_Fp, _Alloc, _Rp()>::__clone(__base<_Rp()>* __p) const |
1350 | { |
1351 | ::new ((void*)__p) __func(__f_.first(), __f_.second()); |
1352 | } |
1353 | |
1354 | template<class _Fp, class _Alloc, class _Rp> |
1355 | void |
1356 | __func<_Fp, _Alloc, _Rp()>::destroy() |
1357 | { |
1358 | __f_.~__compressed_pair<_Fp, _Alloc>(); |
1359 | } |
1360 | |
1361 | template<class _Fp, class _Alloc, class _Rp> |
1362 | void |
1363 | __func<_Fp, _Alloc, _Rp()>::destroy_deallocate() |
1364 | { |
1365 | typedef allocator_traits<_Alloc> __alloc_traits; |
1366 | typedef typename __rebind_alloc_helper<__alloc_traits, __func>::type _Ap; |
1367 | _Ap __a(__f_.second()); |
1368 | __f_.~__compressed_pair<_Fp, _Alloc>(); |
1369 | __a.deallocate(this, 1); |
1370 | } |
1371 | |
1372 | template<class _Fp, class _Alloc, class _Rp> |
1373 | _Rp |
1374 | __func<_Fp, _Alloc, _Rp()>::operator()() |
1375 | { |
1376 | typedef __invoke_void_return_wrapper<_Rp> _Invoker; |
1377 | return _Invoker::__call(__f_.first()); |
1378 | } |
1379 | |
1380 | #ifndef _LIBCPP_NO_RTTI |
1381 | |
1382 | template<class _Fp, class _Alloc, class _Rp> |
1383 | const void* |
1384 | __func<_Fp, _Alloc, _Rp()>::target(const type_info& __ti) const |
1385 | { |
1386 | if (__ti == typeid(_Fp)) |
1387 | return &__f_.first(); |
1388 | return (const void*)0; |
1389 | } |
1390 | |
1391 | template<class _Fp, class _Alloc, class _Rp> |
1392 | const std::type_info& |
1393 | __func<_Fp, _Alloc, _Rp()>::target_type() const |
1394 | { |
1395 | return typeid(_Fp); |
1396 | } |
1397 | |
1398 | #endif // _LIBCPP_NO_RTTI |
1399 | |
1400 | template<class _Fp, class _Alloc, class _Rp, class _A0> |
1401 | class __func<_Fp, _Alloc, _Rp(_A0)> |
1402 | : public __base<_Rp(_A0)> |
1403 | { |
1404 | __compressed_pair<_Fp, _Alloc> __f_; |
1405 | public: |
1406 | _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__ )) explicit __func(_Fp __f) : __f_(_VSTDstd::__1::move(__f), __default_init_tag()) {} |
1407 | _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__ )) explicit __func(_Fp __f, _Alloc __a) |
1408 | : __f_(_VSTDstd::__1::move(__f), _VSTDstd::__1::move(__a)) {} |
1409 | virtual __base<_Rp(_A0)>* __clone() const; |
1410 | virtual void __clone(__base<_Rp(_A0)>*) const; |
1411 | virtual void destroy(); |
1412 | virtual void destroy_deallocate(); |
1413 | virtual _Rp operator()(_A0); |
1414 | #ifndef _LIBCPP_NO_RTTI |
1415 | virtual const void* target(const type_info&) const; |
1416 | virtual const std::type_info& target_type() const; |
1417 | #endif // _LIBCPP_NO_RTTI |
1418 | }; |
1419 | |
1420 | template<class _Fp, class _Alloc, class _Rp, class _A0> |
1421 | __base<_Rp(_A0)>* |
1422 | __func<_Fp, _Alloc, _Rp(_A0)>::__clone() const |
1423 | { |
1424 | typedef allocator_traits<_Alloc> __alloc_traits; |
1425 | typedef typename __rebind_alloc_helper<__alloc_traits, __func>::type _Ap; |
1426 | _Ap __a(__f_.second()); |
1427 | typedef __allocator_destructor<_Ap> _Dp; |
1428 | unique_ptr<__func, _Dp> __hold(__a.allocate(1), _Dp(__a, 1)); |
1429 | ::new ((void*)__hold.get()) __func(__f_.first(), _Alloc(__a)); |
1430 | return __hold.release(); |
1431 | } |
1432 | |
1433 | template<class _Fp, class _Alloc, class _Rp, class _A0> |
1434 | void |
1435 | __func<_Fp, _Alloc, _Rp(_A0)>::__clone(__base<_Rp(_A0)>* __p) const |
1436 | { |
1437 | ::new ((void*)__p) __func(__f_.first(), __f_.second()); |
1438 | } |
1439 | |
1440 | template<class _Fp, class _Alloc, class _Rp, class _A0> |
1441 | void |
1442 | __func<_Fp, _Alloc, _Rp(_A0)>::destroy() |
1443 | { |
1444 | __f_.~__compressed_pair<_Fp, _Alloc>(); |
1445 | } |
1446 | |
1447 | template<class _Fp, class _Alloc, class _Rp, class _A0> |
1448 | void |
1449 | __func<_Fp, _Alloc, _Rp(_A0)>::destroy_deallocate() |
1450 | { |
1451 | typedef allocator_traits<_Alloc> __alloc_traits; |
1452 | typedef typename __rebind_alloc_helper<__alloc_traits, __func>::type _Ap; |
1453 | _Ap __a(__f_.second()); |
1454 | __f_.~__compressed_pair<_Fp, _Alloc>(); |
1455 | __a.deallocate(this, 1); |
1456 | } |
1457 | |
1458 | template<class _Fp, class _Alloc, class _Rp, class _A0> |
1459 | _Rp |
1460 | __func<_Fp, _Alloc, _Rp(_A0)>::operator()(_A0 __a0) |
1461 | { |
1462 | typedef __invoke_void_return_wrapper<_Rp> _Invoker; |
1463 | return _Invoker::__call(__f_.first(), __a0); |
1464 | } |
1465 | |
1466 | #ifndef _LIBCPP_NO_RTTI |
1467 | |
1468 | template<class _Fp, class _Alloc, class _Rp, class _A0> |
1469 | const void* |
1470 | __func<_Fp, _Alloc, _Rp(_A0)>::target(const type_info& __ti) const |
1471 | { |
1472 | if (__ti == typeid(_Fp)) |
1473 | return &__f_.first(); |
1474 | return (const void*)0; |
1475 | } |
1476 | |
1477 | template<class _Fp, class _Alloc, class _Rp, class _A0> |
1478 | const std::type_info& |
1479 | __func<_Fp, _Alloc, _Rp(_A0)>::target_type() const |
1480 | { |
1481 | return typeid(_Fp); |
1482 | } |
1483 | |
1484 | #endif // _LIBCPP_NO_RTTI |
1485 | |
1486 | template<class _Fp, class _Alloc, class _Rp, class _A0, class _A1> |
1487 | class __func<_Fp, _Alloc, _Rp(_A0, _A1)> |
1488 | : public __base<_Rp(_A0, _A1)> |
1489 | { |
1490 | __compressed_pair<_Fp, _Alloc> __f_; |
1491 | public: |
1492 | _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__ )) explicit __func(_Fp __f) : __f_(_VSTDstd::__1::move(__f), __default_init_tag()) {} |
1493 | _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__ )) explicit __func(_Fp __f, _Alloc __a) |
1494 | : __f_(_VSTDstd::__1::move(__f), _VSTDstd::__1::move(__a)) {} |
1495 | virtual __base<_Rp(_A0, _A1)>* __clone() const; |
1496 | virtual void __clone(__base<_Rp(_A0, _A1)>*) const; |
1497 | virtual void destroy(); |
1498 | virtual void destroy_deallocate(); |
1499 | virtual _Rp operator()(_A0, _A1); |
1500 | #ifndef _LIBCPP_NO_RTTI |
1501 | virtual const void* target(const type_info&) const; |
1502 | virtual const std::type_info& target_type() const; |
1503 | #endif // _LIBCPP_NO_RTTI |
1504 | }; |
1505 | |
1506 | template<class _Fp, class _Alloc, class _Rp, class _A0, class _A1> |
1507 | __base<_Rp(_A0, _A1)>* |
1508 | __func<_Fp, _Alloc, _Rp(_A0, _A1)>::__clone() const |
1509 | { |
1510 | typedef allocator_traits<_Alloc> __alloc_traits; |
1511 | typedef typename __rebind_alloc_helper<__alloc_traits, __func>::type _Ap; |
1512 | _Ap __a(__f_.second()); |
1513 | typedef __allocator_destructor<_Ap> _Dp; |
1514 | unique_ptr<__func, _Dp> __hold(__a.allocate(1), _Dp(__a, 1)); |
1515 | ::new ((void*)__hold.get()) __func(__f_.first(), _Alloc(__a)); |
1516 | return __hold.release(); |
1517 | } |
1518 | |
1519 | template<class _Fp, class _Alloc, class _Rp, class _A0, class _A1> |
1520 | void |
1521 | __func<_Fp, _Alloc, _Rp(_A0, _A1)>::__clone(__base<_Rp(_A0, _A1)>* __p) const |
1522 | { |
1523 | ::new ((void*)__p) __func(__f_.first(), __f_.second()); |
1524 | } |
1525 | |
1526 | template<class _Fp, class _Alloc, class _Rp, class _A0, class _A1> |
1527 | void |
1528 | __func<_Fp, _Alloc, _Rp(_A0, _A1)>::destroy() |
1529 | { |
1530 | __f_.~__compressed_pair<_Fp, _Alloc>(); |
1531 | } |
1532 | |
1533 | template<class _Fp, class _Alloc, class _Rp, class _A0, class _A1> |
1534 | void |
1535 | __func<_Fp, _Alloc, _Rp(_A0, _A1)>::destroy_deallocate() |
1536 | { |
1537 | typedef allocator_traits<_Alloc> __alloc_traits; |
1538 | typedef typename __rebind_alloc_helper<__alloc_traits, __func>::type _Ap; |
1539 | _Ap __a(__f_.second()); |
1540 | __f_.~__compressed_pair<_Fp, _Alloc>(); |
1541 | __a.deallocate(this, 1); |
1542 | } |
1543 | |
1544 | template<class _Fp, class _Alloc, class _Rp, class _A0, class _A1> |
1545 | _Rp |
1546 | __func<_Fp, _Alloc, _Rp(_A0, _A1)>::operator()(_A0 __a0, _A1 __a1) |
1547 | { |
1548 | typedef __invoke_void_return_wrapper<_Rp> _Invoker; |
1549 | return _Invoker::__call(__f_.first(), __a0, __a1); |
1550 | } |
1551 | |
1552 | #ifndef _LIBCPP_NO_RTTI |
1553 | |
1554 | template<class _Fp, class _Alloc, class _Rp, class _A0, class _A1> |
1555 | const void* |
1556 | __func<_Fp, _Alloc, _Rp(_A0, _A1)>::target(const type_info& __ti) const |
1557 | { |
1558 | if (__ti == typeid(_Fp)) |
1559 | return &__f_.first(); |
1560 | return (const void*)0; |
1561 | } |
1562 | |
1563 | template<class _Fp, class _Alloc, class _Rp, class _A0, class _A1> |
1564 | const std::type_info& |
1565 | __func<_Fp, _Alloc, _Rp(_A0, _A1)>::target_type() const |
1566 | { |
1567 | return typeid(_Fp); |
1568 | } |
1569 | |
1570 | #endif // _LIBCPP_NO_RTTI |
1571 | |
1572 | template<class _Fp, class _Alloc, class _Rp, class _A0, class _A1, class _A2> |
1573 | class __func<_Fp, _Alloc, _Rp(_A0, _A1, _A2)> |
1574 | : public __base<_Rp(_A0, _A1, _A2)> |
1575 | { |
1576 | __compressed_pair<_Fp, _Alloc> __f_; |
1577 | public: |
1578 | _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__ )) explicit __func(_Fp __f) : __f_(_VSTDstd::__1::move(__f), __default_init_tag()) {} |
1579 | _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__ )) explicit __func(_Fp __f, _Alloc __a) |
1580 | : __f_(_VSTDstd::__1::move(__f), _VSTDstd::__1::move(__a)) {} |
1581 | virtual __base<_Rp(_A0, _A1, _A2)>* __clone() const; |
1582 | virtual void __clone(__base<_Rp(_A0, _A1, _A2)>*) const; |
1583 | virtual void destroy(); |
1584 | virtual void destroy_deallocate(); |
1585 | virtual _Rp operator()(_A0, _A1, _A2); |
1586 | #ifndef _LIBCPP_NO_RTTI |
1587 | virtual const void* target(const type_info&) const; |
1588 | virtual const std::type_info& target_type() const; |
1589 | #endif // _LIBCPP_NO_RTTI |
1590 | }; |
1591 | |
1592 | template<class _Fp, class _Alloc, class _Rp, class _A0, class _A1, class _A2> |
1593 | __base<_Rp(_A0, _A1, _A2)>* |
1594 | __func<_Fp, _Alloc, _Rp(_A0, _A1, _A2)>::__clone() const |
1595 | { |
1596 | typedef allocator_traits<_Alloc> __alloc_traits; |
1597 | typedef typename __rebind_alloc_helper<__alloc_traits, __func>::type _Ap; |
1598 | _Ap __a(__f_.second()); |
1599 | typedef __allocator_destructor<_Ap> _Dp; |
1600 | unique_ptr<__func, _Dp> __hold(__a.allocate(1), _Dp(__a, 1)); |
1601 | ::new ((void*)__hold.get()) __func(__f_.first(), _Alloc(__a)); |
1602 | return __hold.release(); |
1603 | } |
1604 | |
1605 | template<class _Fp, class _Alloc, class _Rp, class _A0, class _A1, class _A2> |
1606 | void |
1607 | __func<_Fp, _Alloc, _Rp(_A0, _A1, _A2)>::__clone(__base<_Rp(_A0, _A1, _A2)>* __p) const |
1608 | { |
1609 | ::new ((void*)__p) __func(__f_.first(), __f_.second()); |
1610 | } |
1611 | |
1612 | template<class _Fp, class _Alloc, class _Rp, class _A0, class _A1, class _A2> |
1613 | void |
1614 | __func<_Fp, _Alloc, _Rp(_A0, _A1, _A2)>::destroy() |
1615 | { |
1616 | __f_.~__compressed_pair<_Fp, _Alloc>(); |
1617 | } |
1618 | |
1619 | template<class _Fp, class _Alloc, class _Rp, class _A0, class _A1, class _A2> |
1620 | void |
1621 | __func<_Fp, _Alloc, _Rp(_A0, _A1, _A2)>::destroy_deallocate() |
1622 | { |
1623 | typedef allocator_traits<_Alloc> __alloc_traits; |
1624 | typedef typename __rebind_alloc_helper<__alloc_traits, __func>::type _Ap; |
1625 | _Ap __a(__f_.second()); |
1626 | __f_.~__compressed_pair<_Fp, _Alloc>(); |
1627 | __a.deallocate(this, 1); |
1628 | } |
1629 | |
1630 | template<class _Fp, class _Alloc, class _Rp, class _A0, class _A1, class _A2> |
1631 | _Rp |
1632 | __func<_Fp, _Alloc, _Rp(_A0, _A1, _A2)>::operator()(_A0 __a0, _A1 __a1, _A2 __a2) |
1633 | { |
1634 | typedef __invoke_void_return_wrapper<_Rp> _Invoker; |
1635 | return _Invoker::__call(__f_.first(), __a0, __a1, __a2); |
1636 | } |
1637 | |
1638 | #ifndef _LIBCPP_NO_RTTI |
1639 | |
1640 | template<class _Fp, class _Alloc, class _Rp, class _A0, class _A1, class _A2> |
1641 | const void* |
1642 | __func<_Fp, _Alloc, _Rp(_A0, _A1, _A2)>::target(const type_info& __ti) const |
1643 | { |
1644 | if (__ti == typeid(_Fp)) |
1645 | return &__f_.first(); |
1646 | return (const void*)0; |
1647 | } |
1648 | |
1649 | template<class _Fp, class _Alloc, class _Rp, class _A0, class _A1, class _A2> |
1650 | const std::type_info& |
1651 | __func<_Fp, _Alloc, _Rp(_A0, _A1, _A2)>::target_type() const |
1652 | { |
1653 | return typeid(_Fp); |
1654 | } |
1655 | |
1656 | #endif // _LIBCPP_NO_RTTI |
1657 | |
1658 | } // __function |
1659 | |
1660 | template<class _Rp> |
1661 | class _LIBCPP_TEMPLATE_VIS__attribute__ ((__type_visibility__("default"))) function<_Rp()> |
1662 | { |
1663 | typedef __function::__base<_Rp()> __base; |
1664 | aligned_storage<3*sizeof(void*)>::type __buf_; |
1665 | __base* __f_; |
1666 | |
1667 | public: |
1668 | typedef _Rp result_type; |
1669 | |
1670 | // 20.7.16.2.1, construct/copy/destroy: |
1671 | _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__ )) explicit function() : __f_(0) {} |
1672 | _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__ )) function(nullptr_t) : __f_(0) {} |
1673 | function(const function&); |
1674 | template<class _Fp> |
1675 | function(_Fp, |
1676 | typename enable_if<!is_integral<_Fp>::value>::type* = 0); |
1677 | |
1678 | template<class _Alloc> |
1679 | _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__ )) |
1680 | function(allocator_arg_t, const _Alloc&) : __f_(0) {} |
1681 | template<class _Alloc> |
1682 | _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__ )) |
1683 | function(allocator_arg_t, const _Alloc&, nullptr_t) : __f_(0) {} |
1684 | template<class _Alloc> |
1685 | function(allocator_arg_t, const _Alloc&, const function&); |
1686 | template<class _Fp, class _Alloc> |
1687 | function(allocator_arg_t, const _Alloc& __a, _Fp __f, |
1688 | typename enable_if<!is_integral<_Fp>::value>::type* = 0); |
1689 | |
1690 | function& operator=(const function&); |
1691 | function& operator=(nullptr_t); |
1692 | template<class _Fp> |
1693 | typename enable_if |
1694 | < |
1695 | !is_integral<_Fp>::value, |
1696 | function& |
1697 | >::type |
1698 | operator=(_Fp); |
1699 | |
1700 | ~function(); |
1701 | |
1702 | // 20.7.16.2.2, function modifiers: |
1703 | void swap(function&); |
1704 | template<class _Fp, class _Alloc> |
1705 | _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__ )) |
1706 | void assign(_Fp __f, const _Alloc& __a) |
1707 | {function(allocator_arg, __a, __f).swap(*this);} |
1708 | |
1709 | // 20.7.16.2.3, function capacity: |
1710 | _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__ )) explicit operator bool() const {return __f_;} |
1711 | |
1712 | private: |
1713 | // deleted overloads close possible hole in the type system |
1714 | template<class _R2> |
1715 | bool operator==(const function<_R2()>&) const;// = delete; |
1716 | template<class _R2> |
1717 | bool operator!=(const function<_R2()>&) const;// = delete; |
1718 | public: |
1719 | // 20.7.16.2.4, function invocation: |
1720 | _Rp operator()() const; |
1721 | |
1722 | #ifndef _LIBCPP_NO_RTTI |
1723 | // 20.7.16.2.5, function target access: |
1724 | const std::type_info& target_type() const; |
1725 | template <typename _Tp> _Tp* target(); |
1726 | template <typename _Tp> const _Tp* target() const; |
1727 | #endif // _LIBCPP_NO_RTTI |
1728 | }; |
1729 | |
1730 | template<class _Rp> |
1731 | function<_Rp()>::function(const function& __f) |
1732 | { |
1733 | if (__f.__f_ == 0) |
1734 | __f_ = 0; |
1735 | else if (__f.__f_ == (const __base*)&__f.__buf_) |
1736 | { |
1737 | __f_ = (__base*)&__buf_; |
1738 | __f.__f_->__clone(__f_); |
1739 | } |
1740 | else |
1741 | __f_ = __f.__f_->__clone(); |
1742 | } |
1743 | |
1744 | template<class _Rp> |
1745 | template<class _Alloc> |
1746 | function<_Rp()>::function(allocator_arg_t, const _Alloc&, const function& __f) |
1747 | { |
1748 | if (__f.__f_ == 0) |
1749 | __f_ = 0; |
1750 | else if (__f.__f_ == (const __base*)&__f.__buf_) |
1751 | { |
1752 | __f_ = (__base*)&__buf_; |
1753 | __f.__f_->__clone(__f_); |
1754 | } |
1755 | else |
1756 | __f_ = __f.__f_->__clone(); |
1757 | } |
1758 | |
1759 | template<class _Rp> |
1760 | template <class _Fp> |
1761 | function<_Rp()>::function(_Fp __f, |
1762 | typename enable_if<!is_integral<_Fp>::value>::type*) |
1763 | : __f_(0) |
1764 | { |
1765 | if (__function::__not_null(__f)) |
1766 | { |
1767 | typedef __function::__func<_Fp, allocator<_Fp>, _Rp()> _FF; |
1768 | if (sizeof(_FF) <= sizeof(__buf_)) |
1769 | { |
1770 | __f_ = (__base*)&__buf_; |
1771 | ::new ((void*)__f_) _FF(__f); |
1772 | } |
1773 | else |
1774 | { |
1775 | typedef allocator<_FF> _Ap; |
1776 | _Ap __a; |
1777 | typedef __allocator_destructor<_Ap> _Dp; |
1778 | unique_ptr<__base, _Dp> __hold(__a.allocate(1), _Dp(__a, 1)); |
1779 | ::new ((void*)__hold.get()) _FF(__f, allocator<_Fp>(__a)); |
1780 | __f_ = __hold.release(); |
1781 | } |
1782 | } |
1783 | } |
1784 | |
1785 | template<class _Rp> |
1786 | template <class _Fp, class _Alloc> |
1787 | function<_Rp()>::function(allocator_arg_t, const _Alloc& __a0, _Fp __f, |
1788 | typename enable_if<!is_integral<_Fp>::value>::type*) |
1789 | : __f_(0) |
1790 | { |
1791 | typedef allocator_traits<_Alloc> __alloc_traits; |
1792 | if (__function::__not_null(__f)) |
1793 | { |
1794 | typedef __function::__func<_Fp, _Alloc, _Rp()> _FF; |
1795 | if (sizeof(_FF) <= sizeof(__buf_)) |
1796 | { |
1797 | __f_ = (__base*)&__buf_; |
1798 | ::new ((void*)__f_) _FF(__f, __a0); |
1799 | } |
1800 | else |
1801 | { |
1802 | typedef typename __rebind_alloc_helper<__alloc_traits, _FF>::type _Ap; |
1803 | _Ap __a(__a0); |
1804 | typedef __allocator_destructor<_Ap> _Dp; |
1805 | unique_ptr<__base, _Dp> __hold(__a.allocate(1), _Dp(__a, 1)); |
1806 | ::new ((void*)__hold.get()) _FF(__f, _Alloc(__a)); |
1807 | __f_ = __hold.release(); |
1808 | } |
1809 | } |
1810 | } |
1811 | |
1812 | template<class _Rp> |
1813 | function<_Rp()>& |
1814 | function<_Rp()>::operator=(const function& __f) |
1815 | { |
1816 | if (__f) |
1817 | function(__f).swap(*this); |
1818 | else |
1819 | *this = nullptr; |
1820 | return *this; |
1821 | } |
1822 | |
1823 | template<class _Rp> |
1824 | function<_Rp()>& |
1825 | function<_Rp()>::operator=(nullptr_t) |
1826 | { |
1827 | __base* __t = __f_; |
1828 | __f_ = 0; |
1829 | if (__t == (__base*)&__buf_) |
1830 | __t->destroy(); |
1831 | else if (__t) |
1832 | __t->destroy_deallocate(); |
1833 | return *this; |
1834 | } |
1835 | |
1836 | template<class _Rp> |
1837 | template <class _Fp> |
1838 | typename enable_if |
1839 | < |
1840 | !is_integral<_Fp>::value, |
1841 | function<_Rp()>& |
1842 | >::type |
1843 | function<_Rp()>::operator=(_Fp __f) |
1844 | { |
1845 | function(_VSTDstd::__1::move(__f)).swap(*this); |
1846 | return *this; |
1847 | } |
1848 | |
1849 | template<class _Rp> |
1850 | function<_Rp()>::~function() |
1851 | { |
1852 | if (__f_ == (__base*)&__buf_) |
1853 | __f_->destroy(); |
1854 | else if (__f_) |
1855 | __f_->destroy_deallocate(); |
1856 | } |
1857 | |
1858 | template<class _Rp> |
1859 | void |
1860 | function<_Rp()>::swap(function& __f) |
1861 | { |
1862 | if (_VSTDstd::__1::addressof(__f) == this) |
1863 | return; |
1864 | if (__f_ == (__base*)&__buf_ && __f.__f_ == (__base*)&__f.__buf_) |
1865 | { |
1866 | typename aligned_storage<sizeof(__buf_)>::type __tempbuf; |
1867 | __base* __t = (__base*)&__tempbuf; |
1868 | __f_->__clone(__t); |
1869 | __f_->destroy(); |
1870 | __f_ = 0; |
1871 | __f.__f_->__clone((__base*)&__buf_); |
1872 | __f.__f_->destroy(); |
1873 | __f.__f_ = 0; |
1874 | __f_ = (__base*)&__buf_; |
1875 | __t->__clone((__base*)&__f.__buf_); |
1876 | __t->destroy(); |
1877 | __f.__f_ = (__base*)&__f.__buf_; |
1878 | } |
1879 | else if (__f_ == (__base*)&__buf_) |
1880 | { |
1881 | __f_->__clone((__base*)&__f.__buf_); |
1882 | __f_->destroy(); |
1883 | __f_ = __f.__f_; |
1884 | __f.__f_ = (__base*)&__f.__buf_; |
1885 | } |
1886 | else if (__f.__f_ == (__base*)&__f.__buf_) |
1887 | { |
1888 | __f.__f_->__clone((__base*)&__buf_); |
1889 | __f.__f_->destroy(); |
1890 | __f.__f_ = __f_; |
1891 | __f_ = (__base*)&__buf_; |
1892 | } |
1893 | else |
1894 | _VSTDstd::__1::swap(__f_, __f.__f_); |
1895 | } |
1896 | |
1897 | template<class _Rp> |
1898 | _Rp |
1899 | function<_Rp()>::operator()() const |
1900 | { |
1901 | if (__f_ == 0) |
1902 | __throw_bad_function_call(); |
1903 | return (*__f_)(); |
1904 | } |
1905 | |
1906 | #ifndef _LIBCPP_NO_RTTI |
1907 | |
1908 | template<class _Rp> |
1909 | const std::type_info& |
1910 | function<_Rp()>::target_type() const |
1911 | { |
1912 | if (__f_ == 0) |
1913 | return typeid(void); |
1914 | return __f_->target_type(); |
1915 | } |
1916 | |
1917 | template<class _Rp> |
1918 | template <typename _Tp> |
1919 | _Tp* |
1920 | function<_Rp()>::target() |
1921 | { |
1922 | if (__f_ == 0) |
1923 | return (_Tp*)0; |
1924 | return (_Tp*) const_cast<void *>(__f_->target(typeid(_Tp))); |
1925 | } |
1926 | |
1927 | template<class _Rp> |
1928 | template <typename _Tp> |
1929 | const _Tp* |
1930 | function<_Rp()>::target() const |
1931 | { |
1932 | if (__f_ == 0) |
1933 | return (const _Tp*)0; |
1934 | return (const _Tp*)__f_->target(typeid(_Tp)); |
1935 | } |
1936 | |
1937 | #endif // _LIBCPP_NO_RTTI |
1938 | |
1939 | template<class _Rp, class _A0> |
1940 | class _LIBCPP_TEMPLATE_VIS__attribute__ ((__type_visibility__("default"))) function<_Rp(_A0)> |
1941 | : public unary_function<_A0, _Rp> |
1942 | { |
1943 | typedef __function::__base<_Rp(_A0)> __base; |
1944 | aligned_storage<3*sizeof(void*)>::type __buf_; |
1945 | __base* __f_; |
1946 | |
1947 | public: |
1948 | typedef _Rp result_type; |
1949 | |
1950 | // 20.7.16.2.1, construct/copy/destroy: |
1951 | _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__ )) explicit function() : __f_(0) {} |
1952 | _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__ )) function(nullptr_t) : __f_(0) {} |
1953 | function(const function&); |
1954 | template<class _Fp> |
1955 | function(_Fp, |
1956 | typename enable_if<!is_integral<_Fp>::value>::type* = 0); |
1957 | |
1958 | template<class _Alloc> |
1959 | _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__ )) |
1960 | function(allocator_arg_t, const _Alloc&) : __f_(0) {} |
1961 | template<class _Alloc> |
1962 | _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__ )) |
1963 | function(allocator_arg_t, const _Alloc&, nullptr_t) : __f_(0) {} |
1964 | template<class _Alloc> |
1965 | function(allocator_arg_t, const _Alloc&, const function&); |
1966 | template<class _Fp, class _Alloc> |
1967 | function(allocator_arg_t, const _Alloc& __a, _Fp __f, |
1968 | typename enable_if<!is_integral<_Fp>::value>::type* = 0); |
1969 | |
1970 | function& operator=(const function&); |
1971 | function& operator=(nullptr_t); |
1972 | template<class _Fp> |
1973 | typename enable_if |
1974 | < |
1975 | !is_integral<_Fp>::value, |
1976 | function& |
1977 | >::type |
1978 | operator=(_Fp); |
1979 | |
1980 | ~function(); |
1981 | |
1982 | // 20.7.16.2.2, function modifiers: |
1983 | void swap(function&); |
1984 | template<class _Fp, class _Alloc> |
1985 | _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__ )) |
1986 | void assign(_Fp __f, const _Alloc& __a) |
1987 | {function(allocator_arg, __a, __f).swap(*this);} |
1988 | |
1989 | // 20.7.16.2.3, function capacity: |
1990 | _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__ )) explicit operator bool() const {return __f_;} |
1991 | |
1992 | private: |
1993 | // deleted overloads close possible hole in the type system |
1994 | template<class _R2, class _B0> |
1995 | bool operator==(const function<_R2(_B0)>&) const;// = delete; |
1996 | template<class _R2, class _B0> |
1997 | bool operator!=(const function<_R2(_B0)>&) const;// = delete; |
1998 | public: |
1999 | // 20.7.16.2.4, function invocation: |
2000 | _Rp operator()(_A0) const; |
2001 | |
2002 | #ifndef _LIBCPP_NO_RTTI |
2003 | // 20.7.16.2.5, function target access: |
2004 | const std::type_info& target_type() const; |
2005 | template <typename _Tp> _Tp* target(); |
2006 | template <typename _Tp> const _Tp* target() const; |
2007 | #endif // _LIBCPP_NO_RTTI |
2008 | }; |
2009 | |
2010 | template<class _Rp, class _A0> |
2011 | function<_Rp(_A0)>::function(const function& __f) |
2012 | { |
2013 | if (__f.__f_ == 0) |
2014 | __f_ = 0; |
2015 | else if (__f.__f_ == (const __base*)&__f.__buf_) |
2016 | { |
2017 | __f_ = (__base*)&__buf_; |
2018 | __f.__f_->__clone(__f_); |
2019 | } |
2020 | else |
2021 | __f_ = __f.__f_->__clone(); |
2022 | } |
2023 | |
2024 | template<class _Rp, class _A0> |
2025 | template<class _Alloc> |
2026 | function<_Rp(_A0)>::function(allocator_arg_t, const _Alloc&, const function& __f) |
2027 | { |
2028 | if (__f.__f_ == 0) |
2029 | __f_ = 0; |
2030 | else if (__f.__f_ == (const __base*)&__f.__buf_) |
2031 | { |
2032 | __f_ = (__base*)&__buf_; |
2033 | __f.__f_->__clone(__f_); |
2034 | } |
2035 | else |
2036 | __f_ = __f.__f_->__clone(); |
2037 | } |
2038 | |
2039 | template<class _Rp, class _A0> |
2040 | template <class _Fp> |
2041 | function<_Rp(_A0)>::function(_Fp __f, |
2042 | typename enable_if<!is_integral<_Fp>::value>::type*) |
2043 | : __f_(0) |
2044 | { |
2045 | if (__function::__not_null(__f)) |
2046 | { |
2047 | typedef __function::__func<_Fp, allocator<_Fp>, _Rp(_A0)> _FF; |
2048 | if (sizeof(_FF) <= sizeof(__buf_)) |
2049 | { |
2050 | __f_ = (__base*)&__buf_; |
2051 | ::new ((void*)__f_) _FF(__f); |
2052 | } |
2053 | else |
2054 | { |
2055 | typedef allocator<_FF> _Ap; |
2056 | _Ap __a; |
2057 | typedef __allocator_destructor<_Ap> _Dp; |
2058 | unique_ptr<__base, _Dp> __hold(__a.allocate(1), _Dp(__a, 1)); |
2059 | ::new ((void*)__hold.get()) _FF(__f, allocator<_Fp>(__a)); |
2060 | __f_ = __hold.release(); |
2061 | } |
2062 | } |
2063 | } |
2064 | |
2065 | template<class _Rp, class _A0> |
2066 | template <class _Fp, class _Alloc> |
2067 | function<_Rp(_A0)>::function(allocator_arg_t, const _Alloc& __a0, _Fp __f, |
2068 | typename enable_if<!is_integral<_Fp>::value>::type*) |
2069 | : __f_(0) |
2070 | { |
2071 | typedef allocator_traits<_Alloc> __alloc_traits; |
2072 | if (__function::__not_null(__f)) |
2073 | { |
2074 | typedef __function::__func<_Fp, _Alloc, _Rp(_A0)> _FF; |
2075 | if (sizeof(_FF) <= sizeof(__buf_)) |
2076 | { |
2077 | __f_ = (__base*)&__buf_; |
2078 | ::new ((void*)__f_) _FF(__f, __a0); |
2079 | } |
2080 | else |
2081 | { |
2082 | typedef typename __rebind_alloc_helper<__alloc_traits, _FF>::type _Ap; |
2083 | _Ap __a(__a0); |
2084 | typedef __allocator_destructor<_Ap> _Dp; |
2085 | unique_ptr<__base, _Dp> __hold(__a.allocate(1), _Dp(__a, 1)); |
2086 | ::new ((void*)__hold.get()) _FF(__f, _Alloc(__a)); |
2087 | __f_ = __hold.release(); |
2088 | } |
2089 | } |
2090 | } |
2091 | |
2092 | template<class _Rp, class _A0> |
2093 | function<_Rp(_A0)>& |
2094 | function<_Rp(_A0)>::operator=(const function& __f) |
2095 | { |
2096 | if (__f) |
2097 | function(__f).swap(*this); |
2098 | else |
2099 | *this = nullptr; |
2100 | return *this; |
2101 | } |
2102 | |
2103 | template<class _Rp, class _A0> |
2104 | function<_Rp(_A0)>& |
2105 | function<_Rp(_A0)>::operator=(nullptr_t) |
2106 | { |
2107 | __base* __t = __f_; |
2108 | __f_ = 0; |
2109 | if (__t == (__base*)&__buf_) |
2110 | __t->destroy(); |
2111 | else if (__t) |
2112 | __t->destroy_deallocate(); |
2113 | return *this; |
2114 | } |
2115 | |
2116 | template<class _Rp, class _A0> |
2117 | template <class _Fp> |
2118 | typename enable_if |
2119 | < |
2120 | !is_integral<_Fp>::value, |
2121 | function<_Rp(_A0)>& |
2122 | >::type |
2123 | function<_Rp(_A0)>::operator=(_Fp __f) |
2124 | { |
2125 | function(_VSTDstd::__1::move(__f)).swap(*this); |
2126 | return *this; |
2127 | } |
2128 | |
2129 | template<class _Rp, class _A0> |
2130 | function<_Rp(_A0)>::~function() |
2131 | { |
2132 | if (__f_ == (__base*)&__buf_) |
2133 | __f_->destroy(); |
2134 | else if (__f_) |
2135 | __f_->destroy_deallocate(); |
2136 | } |
2137 | |
2138 | template<class _Rp, class _A0> |
2139 | void |
2140 | function<_Rp(_A0)>::swap(function& __f) |
2141 | { |
2142 | if (_VSTDstd::__1::addressof(__f) == this) |
2143 | return; |
2144 | if (__f_ == (__base*)&__buf_ && __f.__f_ == (__base*)&__f.__buf_) |
2145 | { |
2146 | typename aligned_storage<sizeof(__buf_)>::type __tempbuf; |
2147 | __base* __t = (__base*)&__tempbuf; |
2148 | __f_->__clone(__t); |
2149 | __f_->destroy(); |
2150 | __f_ = 0; |
2151 | __f.__f_->__clone((__base*)&__buf_); |
2152 | __f.__f_->destroy(); |
2153 | __f.__f_ = 0; |
2154 | __f_ = (__base*)&__buf_; |
2155 | __t->__clone((__base*)&__f.__buf_); |
2156 | __t->destroy(); |
2157 | __f.__f_ = (__base*)&__f.__buf_; |
2158 | } |
2159 | else if (__f_ == (__base*)&__buf_) |
2160 | { |
2161 | __f_->__clone((__base*)&__f.__buf_); |
2162 | __f_->destroy(); |
2163 | __f_ = __f.__f_; |
2164 | __f.__f_ = (__base*)&__f.__buf_; |
2165 | } |
2166 | else if (__f.__f_ == (__base*)&__f.__buf_) |
2167 | { |
2168 | __f.__f_->__clone((__base*)&__buf_); |
2169 | __f.__f_->destroy(); |
2170 | __f.__f_ = __f_; |
2171 | __f_ = (__base*)&__buf_; |
2172 | } |
2173 | else |
2174 | _VSTDstd::__1::swap(__f_, __f.__f_); |
2175 | } |
2176 | |
2177 | template<class _Rp, class _A0> |
2178 | _Rp |
2179 | function<_Rp(_A0)>::operator()(_A0 __a0) const |
2180 | { |
2181 | if (__f_ == 0) |
2182 | __throw_bad_function_call(); |
2183 | return (*__f_)(__a0); |
2184 | } |
2185 | |
2186 | #ifndef _LIBCPP_NO_RTTI |
2187 | |
2188 | template<class _Rp, class _A0> |
2189 | const std::type_info& |
2190 | function<_Rp(_A0)>::target_type() const |
2191 | { |
2192 | if (__f_ == 0) |
2193 | return typeid(void); |
2194 | return __f_->target_type(); |
2195 | } |
2196 | |
2197 | template<class _Rp, class _A0> |
2198 | template <typename _Tp> |
2199 | _Tp* |
2200 | function<_Rp(_A0)>::target() |
2201 | { |
2202 | if (__f_ == 0) |
2203 | return (_Tp*)0; |
2204 | return (_Tp*) const_cast<void *>(__f_->target(typeid(_Tp))); |
2205 | } |
2206 | |
2207 | template<class _Rp, class _A0> |
2208 | template <typename _Tp> |
2209 | const _Tp* |
2210 | function<_Rp(_A0)>::target() const |
2211 | { |
2212 | if (__f_ == 0) |
2213 | return (const _Tp*)0; |
2214 | return (const _Tp*)__f_->target(typeid(_Tp)); |
2215 | } |
2216 | |
2217 | #endif // _LIBCPP_NO_RTTI |
2218 | |
2219 | template<class _Rp, class _A0, class _A1> |
2220 | class _LIBCPP_TEMPLATE_VIS__attribute__ ((__type_visibility__("default"))) function<_Rp(_A0, _A1)> |
2221 | : public binary_function<_A0, _A1, _Rp> |
2222 | { |
2223 | typedef __function::__base<_Rp(_A0, _A1)> __base; |
2224 | aligned_storage<3*sizeof(void*)>::type __buf_; |
2225 | __base* __f_; |
2226 | |
2227 | public: |
2228 | typedef _Rp result_type; |
2229 | |
2230 | // 20.7.16.2.1, construct/copy/destroy: |
2231 | _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__ )) explicit function() : __f_(0) {} |
2232 | _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__ )) function(nullptr_t) : __f_(0) {} |
2233 | function(const function&); |
2234 | template<class _Fp> |
2235 | function(_Fp, |
2236 | typename enable_if<!is_integral<_Fp>::value>::type* = 0); |
2237 | |
2238 | template<class _Alloc> |
2239 | _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__ )) |
2240 | function(allocator_arg_t, const _Alloc&) : __f_(0) {} |
2241 | template<class _Alloc> |
2242 | _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__ )) |
2243 | function(allocator_arg_t, const _Alloc&, nullptr_t) : __f_(0) {} |
2244 | template<class _Alloc> |
2245 | function(allocator_arg_t, const _Alloc&, const function&); |
2246 | template<class _Fp, class _Alloc> |
2247 | function(allocator_arg_t, const _Alloc& __a, _Fp __f, |
2248 | typename enable_if<!is_integral<_Fp>::value>::type* = 0); |
2249 | |
2250 | function& operator=(const function&); |
2251 | function& operator=(nullptr_t); |
2252 | template<class _Fp> |
2253 | typename enable_if |
2254 | < |
2255 | !is_integral<_Fp>::value, |
2256 | function& |
2257 | >::type |
2258 | operator=(_Fp); |
2259 | |
2260 | ~function(); |
2261 | |
2262 | // 20.7.16.2.2, function modifiers: |
2263 | void swap(function&); |
2264 | template<class _Fp, class _Alloc> |
2265 | _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__ )) |
2266 | void assign(_Fp __f, const _Alloc& __a) |
2267 | {function(allocator_arg, __a, __f).swap(*this);} |
2268 | |
2269 | // 20.7.16.2.3, function capacity: |
2270 | _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__ )) explicit operator bool() const {return __f_;} |
2271 | |
2272 | private: |
2273 | // deleted overloads close possible hole in the type system |
2274 | template<class _R2, class _B0, class _B1> |
2275 | bool operator==(const function<_R2(_B0, _B1)>&) const;// = delete; |
2276 | template<class _R2, class _B0, class _B1> |
2277 | bool operator!=(const function<_R2(_B0, _B1)>&) const;// = delete; |
2278 | public: |
2279 | // 20.7.16.2.4, function invocation: |
2280 | _Rp operator()(_A0, _A1) const; |
2281 | |
2282 | #ifndef _LIBCPP_NO_RTTI |
2283 | // 20.7.16.2.5, function target access: |
2284 | const std::type_info& target_type() const; |
2285 | template <typename _Tp> _Tp* target(); |
2286 | template <typename _Tp> const _Tp* target() const; |
2287 | #endif // _LIBCPP_NO_RTTI |
2288 | }; |
2289 | |
2290 | template<class _Rp, class _A0, class _A1> |
2291 | function<_Rp(_A0, _A1)>::function(const function& __f) |
2292 | { |
2293 | if (__f.__f_ == 0) |
2294 | __f_ = 0; |
2295 | else if (__f.__f_ == (const __base*)&__f.__buf_) |
2296 | { |
2297 | __f_ = (__base*)&__buf_; |
2298 | __f.__f_->__clone(__f_); |
2299 | } |
2300 | else |
2301 | __f_ = __f.__f_->__clone(); |
2302 | } |
2303 | |
2304 | template<class _Rp, class _A0, class _A1> |
2305 | template<class _Alloc> |
2306 | function<_Rp(_A0, _A1)>::function(allocator_arg_t, const _Alloc&, const function& __f) |
2307 | { |
2308 | if (__f.__f_ == 0) |
2309 | __f_ = 0; |
2310 | else if (__f.__f_ == (const __base*)&__f.__buf_) |
2311 | { |
2312 | __f_ = (__base*)&__buf_; |
2313 | __f.__f_->__clone(__f_); |
2314 | } |
2315 | else |
2316 | __f_ = __f.__f_->__clone(); |
2317 | } |
2318 | |
2319 | template<class _Rp, class _A0, class _A1> |
2320 | template <class _Fp> |
2321 | function<_Rp(_A0, _A1)>::function(_Fp __f, |
2322 | typename enable_if<!is_integral<_Fp>::value>::type*) |
2323 | : __f_(0) |
2324 | { |
2325 | if (__function::__not_null(__f)) |
2326 | { |
2327 | typedef __function::__func<_Fp, allocator<_Fp>, _Rp(_A0, _A1)> _FF; |
2328 | if (sizeof(_FF) <= sizeof(__buf_)) |
2329 | { |
2330 | __f_ = (__base*)&__buf_; |
2331 | ::new ((void*)__f_) _FF(__f); |
2332 | } |
2333 | else |
2334 | { |
2335 | typedef allocator<_FF> _Ap; |
2336 | _Ap __a; |
2337 | typedef __allocator_destructor<_Ap> _Dp; |
2338 | unique_ptr<__base, _Dp> __hold(__a.allocate(1), _Dp(__a, 1)); |
2339 | ::new ((void*)__hold.get()) _FF(__f, allocator<_Fp>(__a)); |
2340 | __f_ = __hold.release(); |
2341 | } |
2342 | } |
2343 | } |
2344 | |
2345 | template<class _Rp, class _A0, class _A1> |
2346 | template <class _Fp, class _Alloc> |
2347 | function<_Rp(_A0, _A1)>::function(allocator_arg_t, const _Alloc& __a0, _Fp __f, |
2348 | typename enable_if<!is_integral<_Fp>::value>::type*) |
2349 | : __f_(0) |
2350 | { |
2351 | typedef allocator_traits<_Alloc> __alloc_traits; |
2352 | if (__function::__not_null(__f)) |
2353 | { |
2354 | typedef __function::__func<_Fp, _Alloc, _Rp(_A0, _A1)> _FF; |
2355 | if (sizeof(_FF) <= sizeof(__buf_)) |
2356 | { |
2357 | __f_ = (__base*)&__buf_; |
2358 | ::new ((void*)__f_) _FF(__f, __a0); |
2359 | } |
2360 | else |
2361 | { |
2362 | typedef typename __rebind_alloc_helper<__alloc_traits, _FF>::type _Ap; |
2363 | _Ap __a(__a0); |
2364 | typedef __allocator_destructor<_Ap> _Dp; |
2365 | unique_ptr<__base, _Dp> __hold(__a.allocate(1), _Dp(__a, 1)); |
2366 | ::new ((void*)__hold.get()) _FF(__f, _Alloc(__a)); |
2367 | __f_ = __hold.release(); |
2368 | } |
2369 | } |
2370 | } |
2371 | |
2372 | template<class _Rp, class _A0, class _A1> |
2373 | function<_Rp(_A0, _A1)>& |
2374 | function<_Rp(_A0, _A1)>::operator=(const function& __f) |
2375 | { |
2376 | if (__f) |
2377 | function(__f).swap(*this); |
2378 | else |
2379 | *this = nullptr; |
2380 | return *this; |
2381 | } |
2382 | |
2383 | template<class _Rp, class _A0, class _A1> |
2384 | function<_Rp(_A0, _A1)>& |
2385 | function<_Rp(_A0, _A1)>::operator=(nullptr_t) |
2386 | { |
2387 | __base* __t = __f_; |
2388 | __f_ = 0; |
2389 | if (__t == (__base*)&__buf_) |
2390 | __t->destroy(); |
2391 | else if (__t) |
2392 | __t->destroy_deallocate(); |
2393 | return *this; |
2394 | } |
2395 | |
2396 | template<class _Rp, class _A0, class _A1> |
2397 | template <class _Fp> |
2398 | typename enable_if |
2399 | < |
2400 | !is_integral<_Fp>::value, |
2401 | function<_Rp(_A0, _A1)>& |
2402 | >::type |
2403 | function<_Rp(_A0, _A1)>::operator=(_Fp __f) |
2404 | { |
2405 | function(_VSTDstd::__1::move(__f)).swap(*this); |
2406 | return *this; |
2407 | } |
2408 | |
2409 | template<class _Rp, class _A0, class _A1> |
2410 | function<_Rp(_A0, _A1)>::~function() |
2411 | { |
2412 | if (__f_ == (__base*)&__buf_) |
2413 | __f_->destroy(); |
2414 | else if (__f_) |
2415 | __f_->destroy_deallocate(); |
2416 | } |
2417 | |
2418 | template<class _Rp, class _A0, class _A1> |
2419 | void |
2420 | function<_Rp(_A0, _A1)>::swap(function& __f) |
2421 | { |
2422 | if (_VSTDstd::__1::addressof(__f) == this) |
2423 | return; |
2424 | if (__f_ == (__base*)&__buf_ && __f.__f_ == (__base*)&__f.__buf_) |
2425 | { |
2426 | typename aligned_storage<sizeof(__buf_)>::type __tempbuf; |
2427 | __base* __t = (__base*)&__tempbuf; |
2428 | __f_->__clone(__t); |
2429 | __f_->destroy(); |
2430 | __f_ = 0; |
2431 | __f.__f_->__clone((__base*)&__buf_); |
2432 | __f.__f_->destroy(); |
2433 | __f.__f_ = 0; |
2434 | __f_ = (__base*)&__buf_; |
2435 | __t->__clone((__base*)&__f.__buf_); |
2436 | __t->destroy(); |
2437 | __f.__f_ = (__base*)&__f.__buf_; |
2438 | } |
2439 | else if (__f_ == (__base*)&__buf_) |
2440 | { |
2441 | __f_->__clone((__base*)&__f.__buf_); |
2442 | __f_->destroy(); |
2443 | __f_ = __f.__f_; |
2444 | __f.__f_ = (__base*)&__f.__buf_; |
2445 | } |
2446 | else if (__f.__f_ == (__base*)&__f.__buf_) |
2447 | { |
2448 | __f.__f_->__clone((__base*)&__buf_); |
2449 | __f.__f_->destroy(); |
2450 | __f.__f_ = __f_; |
2451 | __f_ = (__base*)&__buf_; |
2452 | } |
2453 | else |
2454 | _VSTDstd::__1::swap(__f_, __f.__f_); |
2455 | } |
2456 | |
2457 | template<class _Rp, class _A0, class _A1> |
2458 | _Rp |
2459 | function<_Rp(_A0, _A1)>::operator()(_A0 __a0, _A1 __a1) const |
2460 | { |
2461 | if (__f_ == 0) |
2462 | __throw_bad_function_call(); |
2463 | return (*__f_)(__a0, __a1); |
2464 | } |
2465 | |
2466 | #ifndef _LIBCPP_NO_RTTI |
2467 | |
2468 | template<class _Rp, class _A0, class _A1> |
2469 | const std::type_info& |
2470 | function<_Rp(_A0, _A1)>::target_type() const |
2471 | { |
2472 | if (__f_ == 0) |
2473 | return typeid(void); |
2474 | return __f_->target_type(); |
2475 | } |
2476 | |
2477 | template<class _Rp, class _A0, class _A1> |
2478 | template <typename _Tp> |
2479 | _Tp* |
2480 | function<_Rp(_A0, _A1)>::target() |
2481 | { |
2482 | if (__f_ == 0) |
2483 | return (_Tp*)0; |
2484 | return (_Tp*) const_cast<void *>(__f_->target(typeid(_Tp))); |
2485 | } |
2486 | |
2487 | template<class _Rp, class _A0, class _A1> |
2488 | template <typename _Tp> |
2489 | const _Tp* |
2490 | function<_Rp(_A0, _A1)>::target() const |
2491 | { |
2492 | if (__f_ == 0) |
2493 | return (const _Tp*)0; |
2494 | return (const _Tp*)__f_->target(typeid(_Tp)); |
2495 | } |
2496 | |
2497 | #endif // _LIBCPP_NO_RTTI |
2498 | |
2499 | template<class _Rp, class _A0, class _A1, class _A2> |
2500 | class _LIBCPP_TEMPLATE_VIS__attribute__ ((__type_visibility__("default"))) function<_Rp(_A0, _A1, _A2)> |
2501 | { |
2502 | typedef __function::__base<_Rp(_A0, _A1, _A2)> __base; |
2503 | aligned_storage<3*sizeof(void*)>::type __buf_; |
2504 | __base* __f_; |
2505 | |
2506 | public: |
2507 | typedef _Rp result_type; |
2508 | |
2509 | // 20.7.16.2.1, construct/copy/destroy: |
2510 | _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__ )) explicit function() : __f_(0) {} |
2511 | _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__ )) function(nullptr_t) : __f_(0) {} |
2512 | function(const function&); |
2513 | template<class _Fp> |
2514 | function(_Fp, |
2515 | typename enable_if<!is_integral<_Fp>::value>::type* = 0); |
2516 | |
2517 | template<class _Alloc> |
2518 | _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__ )) |
2519 | function(allocator_arg_t, const _Alloc&) : __f_(0) {} |
2520 | template<class _Alloc> |
2521 | _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__ )) |
2522 | function(allocator_arg_t, const _Alloc&, nullptr_t) : __f_(0) {} |
2523 | template<class _Alloc> |
2524 | function(allocator_arg_t, const _Alloc&, const function&); |
2525 | template<class _Fp, class _Alloc> |
2526 | function(allocator_arg_t, const _Alloc& __a, _Fp __f, |
2527 | typename enable_if<!is_integral<_Fp>::value>::type* = 0); |
2528 | |
2529 | function& operator=(const function&); |
2530 | function& operator=(nullptr_t); |
2531 | template<class _Fp> |
2532 | typename enable_if |
2533 | < |
2534 | !is_integral<_Fp>::value, |
2535 | function& |
2536 | >::type |
2537 | operator=(_Fp); |
2538 | |
2539 | ~function(); |
2540 | |
2541 | // 20.7.16.2.2, function modifiers: |
2542 | void swap(function&); |
2543 | template<class _Fp, class _Alloc> |
2544 | _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__ )) |
2545 | void assign(_Fp __f, const _Alloc& __a) |
2546 | {function(allocator_arg, __a, __f).swap(*this);} |
2547 | |
2548 | // 20.7.16.2.3, function capacity: |
2549 | _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__ )) explicit operator bool() const {return __f_;} |
2550 | |
2551 | private: |
2552 | // deleted overloads close possible hole in the type system |
2553 | template<class _R2, class _B0, class _B1, class _B2> |
2554 | bool operator==(const function<_R2(_B0, _B1, _B2)>&) const;// = delete; |
2555 | template<class _R2, class _B0, class _B1, class _B2> |
2556 | bool operator!=(const function<_R2(_B0, _B1, _B2)>&) const;// = delete; |
2557 | public: |
2558 | // 20.7.16.2.4, function invocation: |
2559 | _Rp operator()(_A0, _A1, _A2) const; |
2560 | |
2561 | #ifndef _LIBCPP_NO_RTTI |
2562 | // 20.7.16.2.5, function target access: |
2563 | const std::type_info& target_type() const; |
2564 | template <typename _Tp> _Tp* target(); |
2565 | template <typename _Tp> const _Tp* target() const; |
2566 | #endif // _LIBCPP_NO_RTTI |
2567 | }; |
2568 | |
2569 | template<class _Rp, class _A0, class _A1, class _A2> |
2570 | function<_Rp(_A0, _A1, _A2)>::function(const function& __f) |
2571 | { |
2572 | if (__f.__f_ == 0) |
2573 | __f_ = 0; |
2574 | else if (__f.__f_ == (const __base*)&__f.__buf_) |
2575 | { |
2576 | __f_ = (__base*)&__buf_; |
2577 | __f.__f_->__clone(__f_); |
2578 | } |
2579 | else |
2580 | __f_ = __f.__f_->__clone(); |
2581 | } |
2582 | |
2583 | template<class _Rp, class _A0, class _A1, class _A2> |
2584 | template<class _Alloc> |
2585 | function<_Rp(_A0, _A1, _A2)>::function(allocator_arg_t, const _Alloc&, |
2586 | const function& __f) |
2587 | { |
2588 | if (__f.__f_ == 0) |
2589 | __f_ = 0; |
2590 | else if (__f.__f_ == (const __base*)&__f.__buf_) |
2591 | { |
2592 | __f_ = (__base*)&__buf_; |
2593 | __f.__f_->__clone(__f_); |
2594 | } |
2595 | else |
2596 | __f_ = __f.__f_->__clone(); |
2597 | } |
2598 | |
2599 | template<class _Rp, class _A0, class _A1, class _A2> |
2600 | template <class _Fp> |
2601 | function<_Rp(_A0, _A1, _A2)>::function(_Fp __f, |
2602 | typename enable_if<!is_integral<_Fp>::value>::type*) |
2603 | : __f_(0) |
2604 | { |
2605 | if (__function::__not_null(__f)) |
2606 | { |
2607 | typedef __function::__func<_Fp, allocator<_Fp>, _Rp(_A0, _A1, _A2)> _FF; |
2608 | if (sizeof(_FF) <= sizeof(__buf_)) |
2609 | { |
2610 | __f_ = (__base*)&__buf_; |
2611 | ::new ((void*)__f_) _FF(__f); |
2612 | } |
2613 | else |
2614 | { |
2615 | typedef allocator<_FF> _Ap; |
2616 | _Ap __a; |
2617 | typedef __allocator_destructor<_Ap> _Dp; |
2618 | unique_ptr<__base, _Dp> __hold(__a.allocate(1), _Dp(__a, 1)); |
2619 | ::new ((void*)__hold.get()) _FF(__f, allocator<_Fp>(__a)); |
2620 | __f_ = __hold.release(); |
2621 | } |
2622 | } |
2623 | } |
2624 | |
2625 | template<class _Rp, class _A0, class _A1, class _A2> |
2626 | template <class _Fp, class _Alloc> |
2627 | function<_Rp(_A0, _A1, _A2)>::function(allocator_arg_t, const _Alloc& __a0, _Fp __f, |
2628 | typename enable_if<!is_integral<_Fp>::value>::type*) |
2629 | : __f_(0) |
2630 | { |
2631 | typedef allocator_traits<_Alloc> __alloc_traits; |
2632 | if (__function::__not_null(__f)) |
2633 | { |
2634 | typedef __function::__func<_Fp, _Alloc, _Rp(_A0, _A1, _A2)> _FF; |
2635 | if (sizeof(_FF) <= sizeof(__buf_)) |
2636 | { |
2637 | __f_ = (__base*)&__buf_; |
2638 | ::new ((void*)__f_) _FF(__f, __a0); |
2639 | } |
2640 | else |
2641 | { |
2642 | typedef typename __rebind_alloc_helper<__alloc_traits, _FF>::type _Ap; |
2643 | _Ap __a(__a0); |
2644 | typedef __allocator_destructor<_Ap> _Dp; |
2645 | unique_ptr<__base, _Dp> __hold(__a.allocate(1), _Dp(__a, 1)); |
2646 | ::new ((void*)__hold.get()) _FF(__f, _Alloc(__a)); |
2647 | __f_ = __hold.release(); |
2648 | } |
2649 | } |
2650 | } |
2651 | |
2652 | template<class _Rp, class _A0, class _A1, class _A2> |
2653 | function<_Rp(_A0, _A1, _A2)>& |
2654 | function<_Rp(_A0, _A1, _A2)>::operator=(const function& __f) |
2655 | { |
2656 | if (__f) |
2657 | function(__f).swap(*this); |
2658 | else |
2659 | *this = nullptr; |
2660 | return *this; |
2661 | } |
2662 | |
2663 | template<class _Rp, class _A0, class _A1, class _A2> |
2664 | function<_Rp(_A0, _A1, _A2)>& |
2665 | function<_Rp(_A0, _A1, _A2)>::operator=(nullptr_t) |
2666 | { |
2667 | __base* __t = __f_; |
2668 | __f_ = 0; |
2669 | if (__t == (__base*)&__buf_) |
2670 | __t->destroy(); |
2671 | else if (__t) |
2672 | __t->destroy_deallocate(); |
2673 | return *this; |
2674 | } |
2675 | |
2676 | template<class _Rp, class _A0, class _A1, class _A2> |
2677 | template <class _Fp> |
2678 | typename enable_if |
2679 | < |
2680 | !is_integral<_Fp>::value, |
2681 | function<_Rp(_A0, _A1, _A2)>& |
2682 | >::type |
2683 | function<_Rp(_A0, _A1, _A2)>::operator=(_Fp __f) |
2684 | { |
2685 | function(_VSTDstd::__1::move(__f)).swap(*this); |
2686 | return *this; |
2687 | } |
2688 | |
2689 | template<class _Rp, class _A0, class _A1, class _A2> |
2690 | function<_Rp(_A0, _A1, _A2)>::~function() |
2691 | { |
2692 | if (__f_ == (__base*)&__buf_) |
2693 | __f_->destroy(); |
2694 | else if (__f_) |
2695 | __f_->destroy_deallocate(); |
2696 | } |
2697 | |
2698 | template<class _Rp, class _A0, class _A1, class _A2> |
2699 | void |
2700 | function<_Rp(_A0, _A1, _A2)>::swap(function& __f) |
2701 | { |
2702 | if (_VSTDstd::__1::addressof(__f) == this) |
2703 | return; |
2704 | if (__f_ == (__base*)&__buf_ && __f.__f_ == (__base*)&__f.__buf_) |
2705 | { |
2706 | typename aligned_storage<sizeof(__buf_)>::type __tempbuf; |
2707 | __base* __t = (__base*)&__tempbuf; |
2708 | __f_->__clone(__t); |
2709 | __f_->destroy(); |
2710 | __f_ = 0; |
2711 | __f.__f_->__clone((__base*)&__buf_); |
2712 | __f.__f_->destroy(); |
2713 | __f.__f_ = 0; |
2714 | __f_ = (__base*)&__buf_; |
2715 | __t->__clone((__base*)&__f.__buf_); |
2716 | __t->destroy(); |
2717 | __f.__f_ = (__base*)&__f.__buf_; |
2718 | } |
2719 | else if (__f_ == (__base*)&__buf_) |
2720 | { |
2721 | __f_->__clone((__base*)&__f.__buf_); |
2722 | __f_->destroy(); |
2723 | __f_ = __f.__f_; |
2724 | __f.__f_ = (__base*)&__f.__buf_; |
2725 | } |
2726 | else if (__f.__f_ == (__base*)&__f.__buf_) |
2727 | { |
2728 | __f.__f_->__clone((__base*)&__buf_); |
2729 | __f.__f_->destroy(); |
2730 | __f.__f_ = __f_; |
2731 | __f_ = (__base*)&__buf_; |
2732 | } |
2733 | else |
2734 | _VSTDstd::__1::swap(__f_, __f.__f_); |
2735 | } |
2736 | |
2737 | template<class _Rp, class _A0, class _A1, class _A2> |
2738 | _Rp |
2739 | function<_Rp(_A0, _A1, _A2)>::operator()(_A0 __a0, _A1 __a1, _A2 __a2) const |
2740 | { |
2741 | if (__f_ == 0) |
2742 | __throw_bad_function_call(); |
2743 | return (*__f_)(__a0, __a1, __a2); |
2744 | } |
2745 | |
2746 | #ifndef _LIBCPP_NO_RTTI |
2747 | |
2748 | template<class _Rp, class _A0, class _A1, class _A2> |
2749 | const std::type_info& |
2750 | function<_Rp(_A0, _A1, _A2)>::target_type() const |
2751 | { |
2752 | if (__f_ == 0) |
2753 | return typeid(void); |
2754 | return __f_->target_type(); |
2755 | } |
2756 | |
2757 | template<class _Rp, class _A0, class _A1, class _A2> |
2758 | template <typename _Tp> |
2759 | _Tp* |
2760 | function<_Rp(_A0, _A1, _A2)>::target() |
2761 | { |
2762 | if (__f_ == 0) |
2763 | return (_Tp*)0; |
2764 | return (_Tp*) const_cast<void *>(__f_->target(typeid(_Tp))); |
2765 | } |
2766 | |
2767 | template<class _Rp, class _A0, class _A1, class _A2> |
2768 | template <typename _Tp> |
2769 | const _Tp* |
2770 | function<_Rp(_A0, _A1, _A2)>::target() const |
2771 | { |
2772 | if (__f_ == 0) |
2773 | return (const _Tp*)0; |
2774 | return (const _Tp*)__f_->target(typeid(_Tp)); |
2775 | } |
2776 | |
2777 | #endif // _LIBCPP_NO_RTTI |
2778 | |
2779 | template <class _Fp> |
2780 | inline _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__ )) |
2781 | bool |
2782 | operator==(const function<_Fp>& __f, nullptr_t) {return !__f;} |
2783 | |
2784 | template <class _Fp> |
2785 | inline _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__ )) |
2786 | bool |
2787 | operator==(nullptr_t, const function<_Fp>& __f) {return !__f;} |
2788 | |
2789 | template <class _Fp> |
2790 | inline _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__ )) |
2791 | bool |
2792 | operator!=(const function<_Fp>& __f, nullptr_t) {return (bool)__f;} |
2793 | |
2794 | template <class _Fp> |
2795 | inline _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__ )) |
2796 | bool |
2797 | operator!=(nullptr_t, const function<_Fp>& __f) {return (bool)__f;} |
2798 | |
2799 | template <class _Fp> |
2800 | inline _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__ )) |
2801 | void |
2802 | swap(function<_Fp>& __x, function<_Fp>& __y) |
2803 | {return __x.swap(__y);} |
2804 | |
2805 | #endif |
2806 | |
2807 | _LIBCPP_END_NAMESPACE_STD} } |
2808 | |
2809 | #endif // _LIBCPP___FUNCTIONAL_FUNCTION_H |
1 | // -*- C++ -*- |
2 | //===----------------------------------------------------------------------===// |
3 | // |
4 | // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. |
5 | // See https://llvm.org/LICENSE.txt for license information. |
6 | // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception |
7 | // |
8 | //===----------------------------------------------------------------------===// |
9 | |
10 | #ifndef _LIBCPP___FUNCTIONAL_INVOKE_H |
11 | #define _LIBCPP___FUNCTIONAL_INVOKE_H |
12 | |
13 | #include <__config> |
14 | #include <__functional/weak_result_type.h> |
15 | #include <__utility/forward.h> |
16 | #include <type_traits> |
17 | |
18 | #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER) |
19 | #pragma GCC system_header |
20 | #endif |
21 | |
22 | _LIBCPP_BEGIN_NAMESPACE_STDnamespace std { inline namespace __1 { |
23 | |
24 | template <class _Ret, bool = is_void<_Ret>::value> |
25 | struct __invoke_void_return_wrapper |
26 | { |
27 | #ifndef _LIBCPP_CXX03_LANG |
28 | template <class ..._Args> |
29 | static _Ret __call(_Args&&... __args) { |
30 | return _VSTDstd::__1::__invoke(_VSTDstd::__1::forward<_Args>(__args)...); |
31 | } |
32 | #else |
33 | template <class _Fn> |
34 | static _Ret __call(_Fn __f) { |
35 | return _VSTDstd::__1::__invoke(__f); |
36 | } |
37 | |
38 | template <class _Fn, class _A0> |
39 | static _Ret __call(_Fn __f, _A0& __a0) { |
40 | return _VSTDstd::__1::__invoke(__f, __a0); |
41 | } |
42 | |
43 | template <class _Fn, class _A0, class _A1> |
44 | static _Ret __call(_Fn __f, _A0& __a0, _A1& __a1) { |
45 | return _VSTDstd::__1::__invoke(__f, __a0, __a1); |
46 | } |
47 | |
48 | template <class _Fn, class _A0, class _A1, class _A2> |
49 | static _Ret __call(_Fn __f, _A0& __a0, _A1& __a1, _A2& __a2){ |
50 | return _VSTDstd::__1::__invoke(__f, __a0, __a1, __a2); |
51 | } |
52 | #endif |
53 | }; |
54 | |
55 | template <class _Ret> |
56 | struct __invoke_void_return_wrapper<_Ret, true> |
57 | { |
58 | #ifndef _LIBCPP_CXX03_LANG |
59 | template <class ..._Args> |
60 | static void __call(_Args&&... __args) { |
61 | _VSTDstd::__1::__invoke(_VSTDstd::__1::forward<_Args>(__args)...); |
62 | } |
63 | #else |
64 | template <class _Fn> |
65 | static void __call(_Fn __f) { |
66 | _VSTDstd::__1::__invoke(__f); |
67 | } |
68 | |
69 | template <class _Fn, class _A0> |
70 | static void __call(_Fn __f, _A0& __a0) { |
71 | _VSTDstd::__1::__invoke(__f, __a0); |
72 | } |
73 | |
74 | template <class _Fn, class _A0, class _A1> |
75 | static void __call(_Fn __f, _A0& __a0, _A1& __a1) { |
76 | _VSTDstd::__1::__invoke(__f, __a0, __a1); |
77 | } |
78 | |
79 | template <class _Fn, class _A0, class _A1, class _A2> |
80 | static void __call(_Fn __f, _A0& __a0, _A1& __a1, _A2& __a2) { |
81 | _VSTDstd::__1::__invoke(__f, __a0, __a1, __a2); |
82 | } |
83 | #endif |
84 | }; |
85 | |
86 | #if _LIBCPP_STD_VER14 > 14 |
87 | |
88 | template <class _Fn, class ..._Args> |
89 | _LIBCPP_CONSTEXPR_AFTER_CXX17 invoke_result_t<_Fn, _Args...> |
90 | invoke(_Fn&& __f, _Args&&... __args) |
91 | noexcept(is_nothrow_invocable_v<_Fn, _Args...>) |
92 | { |
93 | return _VSTDstd::__1::__invoke(_VSTDstd::__1::forward<_Fn>(__f), _VSTDstd::__1::forward<_Args>(__args)...); |
94 | } |
95 | |
96 | #endif // _LIBCPP_STD_VER > 14 |
97 | |
98 | _LIBCPP_END_NAMESPACE_STD} } |
99 | |
100 | #endif // _LIBCPP___FUNCTIONAL_INVOKE_H |
1 | // -*- C++ -*- |
2 | //===------------------------ type_traits ---------------------------------===// |
3 | // |
4 | // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. |
5 | // See https://llvm.org/LICENSE.txt for license information. |
6 | // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception |
7 | // |
8 | //===----------------------------------------------------------------------===// |
9 | |
10 | #ifndef _LIBCPP_TYPE_TRAITS |
11 | #define _LIBCPP_TYPE_TRAITS |
12 | |
13 | /* |
14 | type_traits synopsis |
15 | |
16 | namespace std |
17 | { |
18 | |
19 | // helper class: |
20 | template <class T, T v> struct integral_constant; |
21 | typedef integral_constant<bool, true> true_type; // C++11 |
22 | typedef integral_constant<bool, false> false_type; // C++11 |
23 | |
24 | template <bool B> // C++14 |
25 | using bool_constant = integral_constant<bool, B>; // C++14 |
26 | typedef bool_constant<true> true_type; // C++14 |
27 | typedef bool_constant<false> false_type; // C++14 |
28 | |
29 | // helper traits |
30 | template <bool, class T = void> struct enable_if; |
31 | template <bool, class T, class F> struct conditional; |
32 | |
33 | // Primary classification traits: |
34 | template <class T> struct is_void; |
35 | template <class T> struct is_null_pointer; // C++14 |
36 | template <class T> struct is_integral; |
37 | template <class T> struct is_floating_point; |
38 | template <class T> struct is_array; |
39 | template <class T> struct is_pointer; |
40 | template <class T> struct is_lvalue_reference; |
41 | template <class T> struct is_rvalue_reference; |
42 | template <class T> struct is_member_object_pointer; |
43 | template <class T> struct is_member_function_pointer; |
44 | template <class T> struct is_enum; |
45 | template <class T> struct is_union; |
46 | template <class T> struct is_class; |
47 | template <class T> struct is_function; |
48 | |
49 | // Secondary classification traits: |
50 | template <class T> struct is_reference; |
51 | template <class T> struct is_arithmetic; |
52 | template <class T> struct is_fundamental; |
53 | template <class T> struct is_member_pointer; |
54 | template <class T> struct is_scoped_enum; // C++2b |
55 | template <class T> struct is_scalar; |
56 | template <class T> struct is_object; |
57 | template <class T> struct is_compound; |
58 | |
59 | // Const-volatile properties and transformations: |
60 | template <class T> struct is_const; |
61 | template <class T> struct is_volatile; |
62 | template <class T> struct remove_const; |
63 | template <class T> struct remove_volatile; |
64 | template <class T> struct remove_cv; |
65 | template <class T> struct add_const; |
66 | template <class T> struct add_volatile; |
67 | template <class T> struct add_cv; |
68 | |
69 | // Reference transformations: |
70 | template <class T> struct remove_reference; |
71 | template <class T> struct add_lvalue_reference; |
72 | template <class T> struct add_rvalue_reference; |
73 | |
74 | // Pointer transformations: |
75 | template <class T> struct remove_pointer; |
76 | template <class T> struct add_pointer; |
77 | |
78 | template<class T> struct type_identity; // C++20 |
79 | template<class T> |
80 | using type_identity_t = typename type_identity<T>::type; // C++20 |
81 | |
82 | // Integral properties: |
83 | template <class T> struct is_signed; |
84 | template <class T> struct is_unsigned; |
85 | template <class T> struct make_signed; |
86 | template <class T> struct make_unsigned; |
87 | |
88 | // Array properties and transformations: |
89 | template <class T> struct rank; |
90 | template <class T, unsigned I = 0> struct extent; |
91 | template <class T> struct remove_extent; |
92 | template <class T> struct remove_all_extents; |
93 | |
94 | template <class T> struct is_bounded_array; // C++20 |
95 | template <class T> struct is_unbounded_array; // C++20 |
96 | |
97 | // Member introspection: |
98 | template <class T> struct is_pod; |
99 | template <class T> struct is_trivial; |
100 | template <class T> struct is_trivially_copyable; |
101 | template <class T> struct is_standard_layout; |
102 | template <class T> struct is_literal_type; // Deprecated in C++17; removed in C++20 |
103 | template <class T> struct is_empty; |
104 | template <class T> struct is_polymorphic; |
105 | template <class T> struct is_abstract; |
106 | template <class T> struct is_final; // C++14 |
107 | template <class T> struct is_aggregate; // C++17 |
108 | |
109 | template <class T, class... Args> struct is_constructible; |
110 | template <class T> struct is_default_constructible; |
111 | template <class T> struct is_copy_constructible; |
112 | template <class T> struct is_move_constructible; |
113 | template <class T, class U> struct is_assignable; |
114 | template <class T> struct is_copy_assignable; |
115 | template <class T> struct is_move_assignable; |
116 | template <class T, class U> struct is_swappable_with; // C++17 |
117 | template <class T> struct is_swappable; // C++17 |
118 | template <class T> struct is_destructible; |
119 | |
120 | template <class T, class... Args> struct is_trivially_constructible; |
121 | template <class T> struct is_trivially_default_constructible; |
122 | template <class T> struct is_trivially_copy_constructible; |
123 | template <class T> struct is_trivially_move_constructible; |
124 | template <class T, class U> struct is_trivially_assignable; |
125 | template <class T> struct is_trivially_copy_assignable; |
126 | template <class T> struct is_trivially_move_assignable; |
127 | template <class T> struct is_trivially_destructible; |
128 | |
129 | template <class T, class... Args> struct is_nothrow_constructible; |
130 | template <class T> struct is_nothrow_default_constructible; |
131 | template <class T> struct is_nothrow_copy_constructible; |
132 | template <class T> struct is_nothrow_move_constructible; |
133 | template <class T, class U> struct is_nothrow_assignable; |
134 | template <class T> struct is_nothrow_copy_assignable; |
135 | template <class T> struct is_nothrow_move_assignable; |
136 | template <class T, class U> struct is_nothrow_swappable_with; // C++17 |
137 | template <class T> struct is_nothrow_swappable; // C++17 |
138 | template <class T> struct is_nothrow_destructible; |
139 | |
140 | template <class T> struct has_virtual_destructor; |
141 | |
142 | template<class T> struct has_unique_object_representations; // C++17 |
143 | |
144 | // Relationships between types: |
145 | template <class T, class U> struct is_same; |
146 | template <class Base, class Derived> struct is_base_of; |
147 | |
148 | template <class From, class To> struct is_convertible; |
149 | template <typename From, typename To> struct is_nothrow_convertible; // C++20 |
150 | template <typename From, typename To> inline constexpr bool is_nothrow_convertible_v; // C++20 |
151 | |
152 | template <class Fn, class... ArgTypes> struct is_invocable; |
153 | template <class R, class Fn, class... ArgTypes> struct is_invocable_r; |
154 | |
155 | template <class Fn, class... ArgTypes> struct is_nothrow_invocable; |
156 | template <class R, class Fn, class... ArgTypes> struct is_nothrow_invocable_r; |
157 | |
158 | // Alignment properties and transformations: |
159 | template <class T> struct alignment_of; |
160 | template <size_t Len, size_t Align = most_stringent_alignment_requirement> |
161 | struct aligned_storage; |
162 | template <size_t Len, class... Types> struct aligned_union; |
163 | template <class T> struct remove_cvref; // C++20 |
164 | |
165 | template <class T> struct decay; |
166 | template <class... T> struct common_type; |
167 | template <class T> struct underlying_type; |
168 | template <class> class result_of; // undefined; deprecated in C++17; removed in C++20 |
169 | template <class Fn, class... ArgTypes> class result_of<Fn(ArgTypes...)>; // deprecated in C++17; removed in C++20 |
170 | template <class Fn, class... ArgTypes> struct invoke_result; // C++17 |
171 | |
172 | // const-volatile modifications: |
173 | template <class T> |
174 | using remove_const_t = typename remove_const<T>::type; // C++14 |
175 | template <class T> |
176 | using remove_volatile_t = typename remove_volatile<T>::type; // C++14 |
177 | template <class T> |
178 | using remove_cv_t = typename remove_cv<T>::type; // C++14 |
179 | template <class T> |
180 | using add_const_t = typename add_const<T>::type; // C++14 |
181 | template <class T> |
182 | using add_volatile_t = typename add_volatile<T>::type; // C++14 |
183 | template <class T> |
184 | using add_cv_t = typename add_cv<T>::type; // C++14 |
185 | |
186 | // reference modifications: |
187 | template <class T> |
188 | using remove_reference_t = typename remove_reference<T>::type; // C++14 |
189 | template <class T> |
190 | using add_lvalue_reference_t = typename add_lvalue_reference<T>::type; // C++14 |
191 | template <class T> |
192 | using add_rvalue_reference_t = typename add_rvalue_reference<T>::type; // C++14 |
193 | |
194 | // sign modifications: |
195 | template <class T> |
196 | using make_signed_t = typename make_signed<T>::type; // C++14 |
197 | template <class T> |
198 | using make_unsigned_t = typename make_unsigned<T>::type; // C++14 |
199 | |
200 | // array modifications: |
201 | template <class T> |
202 | using remove_extent_t = typename remove_extent<T>::type; // C++14 |
203 | template <class T> |
204 | using remove_all_extents_t = typename remove_all_extents<T>::type; // C++14 |
205 | |
206 | template <class T> |
207 | inline constexpr bool is_bounded_array_v |
208 | = is_bounded_array<T>::value; // C++20 |
209 | inline constexpr bool is_unbounded_array_v |
210 | = is_unbounded_array<T>::value; // C++20 |
211 | |
212 | // pointer modifications: |
213 | template <class T> |
214 | using remove_pointer_t = typename remove_pointer<T>::type; // C++14 |
215 | template <class T> |
216 | using add_pointer_t = typename add_pointer<T>::type; // C++14 |
217 | |
218 | // other transformations: |
219 | template <size_t Len, size_t Align=default-alignment> |
220 | using aligned_storage_t = typename aligned_storage<Len,Align>::type; // C++14 |
221 | template <size_t Len, class... Types> |
222 | using aligned_union_t = typename aligned_union<Len,Types...>::type; // C++14 |
223 | template <class T> |
224 | using remove_cvref_t = typename remove_cvref<T>::type; // C++20 |
225 | template <class T> |
226 | using decay_t = typename decay<T>::type; // C++14 |
227 | template <bool b, class T=void> |
228 | using enable_if_t = typename enable_if<b,T>::type; // C++14 |
229 | template <bool b, class T, class F> |
230 | using conditional_t = typename conditional<b,T,F>::type; // C++14 |
231 | template <class... T> |
232 | using common_type_t = typename common_type<T...>::type; // C++14 |
233 | template <class T> |
234 | using underlying_type_t = typename underlying_type<T>::type; // C++14 |
235 | template <class T> |
236 | using result_of_t = typename result_of<T>::type; // C++14; deprecated in C++17; removed in C++20 |
237 | template <class Fn, class... ArgTypes> |
238 | using invoke_result_t = typename invoke_result<Fn, ArgTypes...>::type; // C++17 |
239 | |
240 | template <class...> |
241 | using void_t = void; // C++17 |
242 | |
243 | // See C++14 20.10.4.1, primary type categories |
244 | template <class T> inline constexpr bool is_void_v |
245 | = is_void<T>::value; // C++17 |
246 | template <class T> inline constexpr bool is_null_pointer_v |
247 | = is_null_pointer<T>::value; // C++17 |
248 | template <class T> inline constexpr bool is_integral_v |
249 | = is_integral<T>::value; // C++17 |
250 | template <class T> inline constexpr bool is_floating_point_v |
251 | = is_floating_point<T>::value; // C++17 |
252 | template <class T> inline constexpr bool is_array_v |
253 | = is_array<T>::value; // C++17 |
254 | template <class T> inline constexpr bool is_pointer_v |
255 | = is_pointer<T>::value; // C++17 |
256 | template <class T> inline constexpr bool is_lvalue_reference_v |
257 | = is_lvalue_reference<T>::value; // C++17 |
258 | template <class T> inline constexpr bool is_rvalue_reference_v |
259 | = is_rvalue_reference<T>::value; // C++17 |
260 | template <class T> inline constexpr bool is_member_object_pointer_v |
261 | = is_member_object_pointer<T>::value; // C++17 |
262 | template <class T> inline constexpr bool is_member_function_pointer_v |
263 | = is_member_function_pointer<T>::value; // C++17 |
264 | template <class T> inline constexpr bool is_enum_v |
265 | = is_enum<T>::value; // C++17 |
266 | template <class T> inline constexpr bool is_union_v |
267 | = is_union<T>::value; // C++17 |
268 | template <class T> inline constexpr bool is_class_v |
269 | = is_class<T>::value; // C++17 |
270 | template <class T> inline constexpr bool is_function_v |
271 | = is_function<T>::value; // C++17 |
272 | |
273 | // See C++14 20.10.4.2, composite type categories |
274 | template <class T> inline constexpr bool is_reference_v |
275 | = is_reference<T>::value; // C++17 |
276 | template <class T> inline constexpr bool is_arithmetic_v |
277 | = is_arithmetic<T>::value; // C++17 |
278 | template <class T> inline constexpr bool is_fundamental_v |
279 | = is_fundamental<T>::value; // C++17 |
280 | template <class T> inline constexpr bool is_object_v |
281 | = is_object<T>::value; // C++17 |
282 | template <class T> inline constexpr bool is_scalar_v |
283 | = is_scalar<T>::value; // C++17 |
284 | template <class T> inline constexpr bool is_compound_v |
285 | = is_compound<T>::value; // C++17 |
286 | template <class T> inline constexpr bool is_member_pointer_v |
287 | = is_member_pointer<T>::value; // C++17 |
288 | template <class T> inline constexpr bool is_scoped_enum_v |
289 | = is_scoped_enum<T>::value; // C++2b |
290 | |
291 | // See C++14 20.10.4.3, type properties |
292 | template <class T> inline constexpr bool is_const_v |
293 | = is_const<T>::value; // C++17 |
294 | template <class T> inline constexpr bool is_volatile_v |
295 | = is_volatile<T>::value; // C++17 |
296 | template <class T> inline constexpr bool is_trivial_v |
297 | = is_trivial<T>::value; // C++17 |
298 | template <class T> inline constexpr bool is_trivially_copyable_v |
299 | = is_trivially_copyable<T>::value; // C++17 |
300 | template <class T> inline constexpr bool is_standard_layout_v |
301 | = is_standard_layout<T>::value; // C++17 |
302 | template <class T> inline constexpr bool is_pod_v |
303 | = is_pod<T>::value; // C++17 |
304 | template <class T> inline constexpr bool is_literal_type_v |
305 | = is_literal_type<T>::value; // C++17; deprecated in C++17; removed in C++20 |
306 | template <class T> inline constexpr bool is_empty_v |
307 | = is_empty<T>::value; // C++17 |
308 | template <class T> inline constexpr bool is_polymorphic_v |
309 | = is_polymorphic<T>::value; // C++17 |
310 | template <class T> inline constexpr bool is_abstract_v |
311 | = is_abstract<T>::value; // C++17 |
312 | template <class T> inline constexpr bool is_final_v |
313 | = is_final<T>::value; // C++17 |
314 | template <class T> inline constexpr bool is_aggregate_v |
315 | = is_aggregate<T>::value; // C++17 |
316 | template <class T> inline constexpr bool is_signed_v |
317 | = is_signed<T>::value; // C++17 |
318 | template <class T> inline constexpr bool is_unsigned_v |
319 | = is_unsigned<T>::value; // C++17 |
320 | template <class T, class... Args> inline constexpr bool is_constructible_v |
321 | = is_constructible<T, Args...>::value; // C++17 |
322 | template <class T> inline constexpr bool is_default_constructible_v |
323 | = is_default_constructible<T>::value; // C++17 |
324 | template <class T> inline constexpr bool is_copy_constructible_v |
325 | = is_copy_constructible<T>::value; // C++17 |
326 | template <class T> inline constexpr bool is_move_constructible_v |
327 | = is_move_constructible<T>::value; // C++17 |
328 | template <class T, class U> inline constexpr bool is_assignable_v |
329 | = is_assignable<T, U>::value; // C++17 |
330 | template <class T> inline constexpr bool is_copy_assignable_v |
331 | = is_copy_assignable<T>::value; // C++17 |
332 | template <class T> inline constexpr bool is_move_assignable_v |
333 | = is_move_assignable<T>::value; // C++17 |
334 | template <class T, class U> inline constexpr bool is_swappable_with_v |
335 | = is_swappable_with<T, U>::value; // C++17 |
336 | template <class T> inline constexpr bool is_swappable_v |
337 | = is_swappable<T>::value; // C++17 |
338 | template <class T> inline constexpr bool is_destructible_v |
339 | = is_destructible<T>::value; // C++17 |
340 | template <class T, class... Args> inline constexpr bool is_trivially_constructible_v |
341 | = is_trivially_constructible<T, Args...>::value; // C++17 |
342 | template <class T> inline constexpr bool is_trivially_default_constructible_v |
343 | = is_trivially_default_constructible<T>::value; // C++17 |
344 | template <class T> inline constexpr bool is_trivially_copy_constructible_v |
345 | = is_trivially_copy_constructible<T>::value; // C++17 |
346 | template <class T> inline constexpr bool is_trivially_move_constructible_v |
347 | = is_trivially_move_constructible<T>::value; // C++17 |
348 | template <class T, class U> inline constexpr bool is_trivially_assignable_v |
349 | = is_trivially_assignable<T, U>::value; // C++17 |
350 | template <class T> inline constexpr bool is_trivially_copy_assignable_v |
351 | = is_trivially_copy_assignable<T>::value; // C++17 |
352 | template <class T> inline constexpr bool is_trivially_move_assignable_v |
353 | = is_trivially_move_assignable<T>::value; // C++17 |
354 | template <class T> inline constexpr bool is_trivially_destructible_v |
355 | = is_trivially_destructible<T>::value; // C++17 |
356 | template <class T, class... Args> inline constexpr bool is_nothrow_constructible_v |
357 | = is_nothrow_constructible<T, Args...>::value; // C++17 |
358 | template <class T> inline constexpr bool is_nothrow_default_constructible_v |
359 | = is_nothrow_default_constructible<T>::value; // C++17 |
360 | template <class T> inline constexpr bool is_nothrow_copy_constructible_v |
361 | = is_nothrow_copy_constructible<T>::value; // C++17 |
362 | template <class T> inline constexpr bool is_nothrow_move_constructible_v |
363 | = is_nothrow_move_constructible<T>::value; // C++17 |
364 | template <class T, class U> inline constexpr bool is_nothrow_assignable_v |
365 | = is_nothrow_assignable<T, U>::value; // C++17 |
366 | template <class T> inline constexpr bool is_nothrow_copy_assignable_v |
367 | = is_nothrow_copy_assignable<T>::value; // C++17 |
368 | template <class T> inline constexpr bool is_nothrow_move_assignable_v |
369 | = is_nothrow_move_assignable<T>::value; // C++17 |
370 | template <class T, class U> inline constexpr bool is_nothrow_swappable_with_v |
371 | = is_nothrow_swappable_with<T, U>::value; // C++17 |
372 | template <class T> inline constexpr bool is_nothrow_swappable_v |
373 | = is_nothrow_swappable<T>::value; // C++17 |
374 | template <class T> inline constexpr bool is_nothrow_destructible_v |
375 | = is_nothrow_destructible<T>::value; // C++17 |
376 | template <class T> inline constexpr bool has_virtual_destructor_v |
377 | = has_virtual_destructor<T>::value; // C++17 |
378 | template<class T> inline constexpr bool has_unique_object_representations_v // C++17 |
379 | = has_unique_object_representations<T>::value; |
380 | |
381 | // See C++14 20.10.5, type property queries |
382 | template <class T> inline constexpr size_t alignment_of_v |
383 | = alignment_of<T>::value; // C++17 |
384 | template <class T> inline constexpr size_t rank_v |
385 | = rank<T>::value; // C++17 |
386 | template <class T, unsigned I = 0> inline constexpr size_t extent_v |
387 | = extent<T, I>::value; // C++17 |
388 | |
389 | // See C++14 20.10.6, type relations |
390 | template <class T, class U> inline constexpr bool is_same_v |
391 | = is_same<T, U>::value; // C++17 |
392 | template <class Base, class Derived> inline constexpr bool is_base_of_v |
393 | = is_base_of<Base, Derived>::value; // C++17 |
394 | template <class From, class To> inline constexpr bool is_convertible_v |
395 | = is_convertible<From, To>::value; // C++17 |
396 | template <class Fn, class... ArgTypes> inline constexpr bool is_invocable_v |
397 | = is_invocable<Fn, ArgTypes...>::value; // C++17 |
398 | template <class R, class Fn, class... ArgTypes> inline constexpr bool is_invocable_r_v |
399 | = is_invocable_r<R, Fn, ArgTypes...>::value; // C++17 |
400 | template <class Fn, class... ArgTypes> inline constexpr bool is_nothrow_invocable_v |
401 | = is_nothrow_invocable<Fn, ArgTypes...>::value; // C++17 |
402 | template <class R, class Fn, class... ArgTypes> inline constexpr bool is_nothrow_invocable_r_v |
403 | = is_nothrow_invocable_r<R, Fn, ArgTypes...>::value; // C++17 |
404 | |
405 | // [meta.logical], logical operator traits: |
406 | template<class... B> struct conjunction; // C++17 |
407 | template<class... B> |
408 | inline constexpr bool conjunction_v = conjunction<B...>::value; // C++17 |
409 | template<class... B> struct disjunction; // C++17 |
410 | template<class... B> |
411 | inline constexpr bool disjunction_v = disjunction<B...>::value; // C++17 |
412 | template<class B> struct negation; // C++17 |
413 | template<class B> |
414 | inline constexpr bool negation_v = negation<B>::value; // C++17 |
415 | |
416 | } |
417 | |
418 | */ |
419 | #include <__config> |
420 | #include <cstddef> |
421 | #include <version> |
422 | |
423 | #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER) |
424 | #pragma GCC system_header |
425 | #endif |
426 | |
427 | _LIBCPP_BEGIN_NAMESPACE_STDnamespace std { inline namespace __1 { |
428 | |
429 | template <class _T1, class _T2> struct _LIBCPP_TEMPLATE_VIS__attribute__ ((__type_visibility__("default"))) pair; |
430 | template <class _Tp> class _LIBCPP_TEMPLATE_VIS__attribute__ ((__type_visibility__("default"))) reference_wrapper; |
431 | template <class _Tp> struct _LIBCPP_TEMPLATE_VIS__attribute__ ((__type_visibility__("default"))) hash; |
432 | |
433 | template <class _Tp, _Tp __v> |
434 | struct _LIBCPP_TEMPLATE_VIS__attribute__ ((__type_visibility__("default"))) integral_constant |
435 | { |
436 | static _LIBCPP_CONSTEXPRconstexpr const _Tp value = __v; |
437 | typedef _Tp value_type; |
438 | typedef integral_constant type; |
439 | _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__ )) |
440 | _LIBCPP_CONSTEXPRconstexpr operator value_type() const _NOEXCEPTnoexcept {return value;} |
441 | #if _LIBCPP_STD_VER14 > 11 |
442 | _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__ )) |
443 | constexpr value_type operator ()() const _NOEXCEPTnoexcept {return value;} |
444 | #endif |
445 | }; |
446 | |
447 | template <class _Tp, _Tp __v> |
448 | _LIBCPP_CONSTEXPRconstexpr const _Tp integral_constant<_Tp, __v>::value; |
449 | |
450 | #if _LIBCPP_STD_VER14 > 14 |
451 | template <bool __b> |
452 | using bool_constant = integral_constant<bool, __b>; |
453 | #define _LIBCPP_BOOL_CONSTANT(__b)integral_constant<bool,(__b)> bool_constant<(__b)> |
454 | #else |
455 | #define _LIBCPP_BOOL_CONSTANT(__b)integral_constant<bool,(__b)> integral_constant<bool,(__b)> |
456 | #endif |
457 | |
458 | typedef _LIBCPP_BOOL_CONSTANT(true)integral_constant<bool,(true)> true_type; |
459 | typedef _LIBCPP_BOOL_CONSTANT(false)integral_constant<bool,(false)> false_type; |
460 | |
461 | template <bool _Val> |
462 | using _BoolConstant _LIBCPP_NODEBUG_TYPE__attribute__((nodebug)) = integral_constant<bool, _Val>; |
463 | |
464 | template <bool> struct _MetaBase; |
465 | template <> |
466 | struct _MetaBase<true> { |
467 | template <class _Tp, class _Up> |
468 | using _SelectImpl _LIBCPP_NODEBUG_TYPE__attribute__((nodebug)) = _Tp; |
469 | template <template <class...> class _FirstFn, template <class...> class, class ..._Args> |
470 | using _SelectApplyImpl _LIBCPP_NODEBUG_TYPE__attribute__((nodebug)) = _FirstFn<_Args...>; |
471 | template <class _First, class...> |
472 | using _FirstImpl _LIBCPP_NODEBUG_TYPE__attribute__((nodebug)) = _First; |
473 | template <class, class _Second, class...> |
474 | using _SecondImpl _LIBCPP_NODEBUG_TYPE__attribute__((nodebug)) = _Second; |
475 | template <class _Tp = void> |
476 | using _EnableIfImpl _LIBCPP_NODEBUG_TYPE__attribute__((nodebug)) = _Tp; |
477 | template <class _Result, class _First, class ..._Rest> |
478 | using _OrImpl _LIBCPP_NODEBUG_TYPE__attribute__((nodebug)) = typename _MetaBase<_First::value != true && sizeof...(_Rest) != 0>::template _OrImpl<_First, _Rest...>; |
479 | }; |
480 | |
481 | template <> |
482 | struct _MetaBase<false> { |
483 | template <class _Tp, class _Up> |
484 | using _SelectImpl _LIBCPP_NODEBUG_TYPE__attribute__((nodebug)) = _Up; |
485 | template <template <class...> class, template <class...> class _SecondFn, class ..._Args> |
486 | using _SelectApplyImpl _LIBCPP_NODEBUG_TYPE__attribute__((nodebug)) = _SecondFn<_Args...>; |
487 | template <class _Result, class ...> |
488 | using _OrImpl _LIBCPP_NODEBUG_TYPE__attribute__((nodebug)) = _Result; |
489 | }; |
490 | template <bool _Cond, class _Ret = void> |
491 | using _EnableIf _LIBCPP_NODEBUG_TYPE__attribute__((nodebug)) = typename _MetaBase<_Cond>::template _EnableIfImpl<_Ret>; |
492 | template <bool _Cond, class _IfRes, class _ElseRes> |
493 | using _If _LIBCPP_NODEBUG_TYPE__attribute__((nodebug)) = typename _MetaBase<_Cond>::template _SelectImpl<_IfRes, _ElseRes>; |
494 | template <class ..._Rest> |
495 | using _Or _LIBCPP_NODEBUG_TYPE__attribute__((nodebug)) = typename _MetaBase< sizeof...(_Rest) != 0 >::template _OrImpl<false_type, _Rest...>; |
496 | template <class _Pred> |
497 | struct _Not : _BoolConstant<!_Pred::value> {}; |
498 | template <class ..._Args> |
499 | using _FirstType _LIBCPP_NODEBUG_TYPE__attribute__((nodebug)) = typename _MetaBase<(sizeof...(_Args) >= 1)>::template _FirstImpl<_Args...>; |
500 | template <class ..._Args> |
501 | using _SecondType _LIBCPP_NODEBUG_TYPE__attribute__((nodebug)) = typename _MetaBase<(sizeof...(_Args) >= 2)>::template _SecondImpl<_Args...>; |
502 | |
503 | template <class ...> using __expand_to_true = true_type; |
504 | template <class ..._Pred> |
505 | __expand_to_true<_EnableIf<_Pred::value>...> __and_helper(int); |
506 | template <class ...> |
507 | false_type __and_helper(...); |
508 | template <class ..._Pred> |
509 | using _And _LIBCPP_NODEBUG_TYPE__attribute__((nodebug)) = decltype(__and_helper<_Pred...>(0)); |
510 | |
511 | template <template <class...> class _Func, class ..._Args> |
512 | struct _Lazy : _Func<_Args...> {}; |
513 | |
514 | // Member detector base |
515 | |
516 | template <template <class...> class _Templ, class ..._Args, class = _Templ<_Args...> > |
517 | true_type __sfinae_test_impl(int); |
518 | template <template <class...> class, class ...> |
519 | false_type __sfinae_test_impl(...); |
520 | |
521 | template <template <class ...> class _Templ, class ..._Args> |
522 | using _IsValidExpansion _LIBCPP_NODEBUG_TYPE__attribute__((nodebug)) = decltype(__sfinae_test_impl<_Templ, _Args...>(0)); |
523 | |
524 | template <class> |
525 | struct __void_t { typedef void type; }; |
526 | |
527 | template <class _Tp> |
528 | struct __identity { typedef _Tp type; }; |
529 | |
530 | template <class _Tp> |
531 | using __identity_t _LIBCPP_NODEBUG_TYPE__attribute__((nodebug)) = typename __identity<_Tp>::type; |
532 | |
533 | template <class _Tp, bool> |
534 | struct _LIBCPP_TEMPLATE_VIS__attribute__ ((__type_visibility__("default"))) __dependent_type : public _Tp {}; |
535 | |
536 | |
537 | template <bool _Bp, class _If, class _Then> |
538 | struct _LIBCPP_TEMPLATE_VIS__attribute__ ((__type_visibility__("default"))) conditional {typedef _If type;}; |
539 | template <class _If, class _Then> |
540 | struct _LIBCPP_TEMPLATE_VIS__attribute__ ((__type_visibility__("default"))) conditional<false, _If, _Then> {typedef _Then type;}; |
541 | |
542 | #if _LIBCPP_STD_VER14 > 11 |
543 | template <bool _Bp, class _If, class _Then> using conditional_t = typename conditional<_Bp, _If, _Then>::type; |
544 | #endif |
545 | |
546 | template <bool, class _Tp = void> struct _LIBCPP_TEMPLATE_VIS__attribute__ ((__type_visibility__("default"))) enable_if {}; |
547 | template <class _Tp> struct _LIBCPP_TEMPLATE_VIS__attribute__ ((__type_visibility__("default"))) enable_if<true, _Tp> {typedef _Tp type;}; |
548 | |
549 | #if _LIBCPP_STD_VER14 > 11 |
550 | template <bool _Bp, class _Tp = void> using enable_if_t = typename enable_if<_Bp, _Tp>::type; |
551 | #endif |
552 | |
553 | // is_same |
554 | |
555 | #if __has_keyword(__is_same)!(0) |
556 | |
557 | template <class _Tp, class _Up> |
558 | struct _LIBCPP_TEMPLATE_VIS__attribute__ ((__type_visibility__("default"))) is_same : _BoolConstant<__is_same(_Tp, _Up)> { }; |
559 | |
560 | #if _LIBCPP_STD_VER14 > 14 && !defined(_LIBCPP_HAS_NO_VARIABLE_TEMPLATES) |
561 | template <class _Tp, class _Up> |
562 | _LIBCPP_INLINE_VAR _LIBCPP_CONSTEXPRconstexpr bool is_same_v = __is_same(_Tp, _Up); |
563 | #endif |
564 | |
565 | #else |
566 | |
567 | template <class _Tp, class _Up> struct _LIBCPP_TEMPLATE_VIS__attribute__ ((__type_visibility__("default"))) is_same : public false_type {}; |
568 | template <class _Tp> struct _LIBCPP_TEMPLATE_VIS__attribute__ ((__type_visibility__("default"))) is_same<_Tp, _Tp> : public true_type {}; |
569 | |
570 | #if _LIBCPP_STD_VER14 > 14 && !defined(_LIBCPP_HAS_NO_VARIABLE_TEMPLATES) |
571 | template <class _Tp, class _Up> |
572 | _LIBCPP_INLINE_VAR _LIBCPP_CONSTEXPRconstexpr bool is_same_v |
573 | = is_same<_Tp, _Up>::value; |
574 | #endif |
575 | |
576 | #endif // __is_same |
577 | |
578 | template <class _Tp, class _Up> |
579 | using _IsSame = _BoolConstant< |
580 | #ifdef __clang__1 |
581 | __is_same(_Tp, _Up) |
582 | #else |
583 | is_same<_Tp, _Up>::value |
584 | #endif |
585 | >; |
586 | |
587 | template <class _Tp, class _Up> |
588 | using _IsNotSame = _BoolConstant< |
589 | #ifdef __clang__1 |
590 | !__is_same(_Tp, _Up) |
591 | #else |
592 | !is_same<_Tp, _Up>::value |
593 | #endif |
594 | >; |
595 | |
596 | |
597 | template <class _Tp> |
598 | using __test_for_primary_template = _EnableIf< |
599 | _IsSame<_Tp, typename _Tp::__primary_template>::value |
600 | >; |
601 | template <class _Tp> |
602 | using __is_primary_template = _IsValidExpansion< |
603 | __test_for_primary_template, _Tp |
604 | >; |
605 | |
606 | struct __two {char __lx[2];}; |
607 | |
608 | // helper class: |
609 | |
610 | // is_const |
611 | |
612 | #if __has_keyword(__is_const)!(0) |
613 | |
614 | template <class _Tp> |
615 | struct _LIBCPP_TEMPLATE_VIS__attribute__ ((__type_visibility__("default"))) is_const : _BoolConstant<__is_const(_Tp)> { }; |
616 | |
617 | #if _LIBCPP_STD_VER14 > 14 && !defined(_LIBCPP_HAS_NO_VARIABLE_TEMPLATES) |
618 | template <class _Tp> |
619 | _LIBCPP_INLINE_VAR _LIBCPP_CONSTEXPRconstexpr bool is_const_v = __is_const(_Tp); |
620 | #endif |
621 | |
622 | #else |
623 | |
624 | template <class _Tp> struct _LIBCPP_TEMPLATE_VIS__attribute__ ((__type_visibility__("default"))) is_const : public false_type {}; |
625 | template <class _Tp> struct _LIBCPP_TEMPLATE_VIS__attribute__ ((__type_visibility__("default"))) is_const<_Tp const> : public true_type {}; |
626 | |
627 | #if _LIBCPP_STD_VER14 > 14 && !defined(_LIBCPP_HAS_NO_VARIABLE_TEMPLATES) |
628 | template <class _Tp> |
629 | _LIBCPP_INLINE_VAR _LIBCPP_CONSTEXPRconstexpr bool is_const_v |
630 | = is_const<_Tp>::value; |
631 | #endif |
632 | |
633 | #endif // __has_keyword(__is_const) |
634 | |
635 | // is_volatile |
636 | |
637 | #if __has_keyword(__is_volatile)!(0) |
638 | |
639 | template <class _Tp> |
640 | struct _LIBCPP_TEMPLATE_VIS__attribute__ ((__type_visibility__("default"))) is_volatile : _BoolConstant<__is_volatile(_Tp)> { }; |
641 | |
642 | #if _LIBCPP_STD_VER14 > 14 && !defined(_LIBCPP_HAS_NO_VARIABLE_TEMPLATES) |
643 | template <class _Tp> |
644 | _LIBCPP_INLINE_VAR _LIBCPP_CONSTEXPRconstexpr bool is_volatile_v = __is_volatile(_Tp); |
645 | #endif |
646 | |
647 | #else |
648 | |
649 | template <class _Tp> struct _LIBCPP_TEMPLATE_VIS__attribute__ ((__type_visibility__("default"))) is_volatile : public false_type {}; |
650 | template <class _Tp> struct _LIBCPP_TEMPLATE_VIS__attribute__ ((__type_visibility__("default"))) is_volatile<_Tp volatile> : public true_type {}; |
651 | |
652 | #if _LIBCPP_STD_VER14 > 14 && !defined(_LIBCPP_HAS_NO_VARIABLE_TEMPLATES) |
653 | template <class _Tp> |
654 | _LIBCPP_INLINE_VAR _LIBCPP_CONSTEXPRconstexpr bool is_volatile_v |
655 | = is_volatile<_Tp>::value; |
656 | #endif |
657 | |
658 | #endif // __has_keyword(__is_volatile) |
659 | |
660 | // remove_const |
661 | |
662 | #if __has_keyword(__remove_const)!(1) |
663 | |
664 | template <class _Tp> |
665 | struct _LIBCPP_TEMPLATE_VIS__attribute__ ((__type_visibility__("default"))) remove_const {typedef __remove_const(_Tp) type;}; |
666 | |
667 | #if _LIBCPP_STD_VER14 > 11 |
668 | template <class _Tp> using remove_const_t = __remove_const(_Tp); |
669 | #endif |
670 | |
671 | #else |
672 | |
673 | template <class _Tp> struct _LIBCPP_TEMPLATE_VIS__attribute__ ((__type_visibility__("default"))) remove_const {typedef _Tp type;}; |
674 | template <class _Tp> struct _LIBCPP_TEMPLATE_VIS__attribute__ ((__type_visibility__("default"))) remove_const<const _Tp> {typedef _Tp type;}; |
675 | #if _LIBCPP_STD_VER14 > 11 |
676 | template <class _Tp> using remove_const_t = typename remove_const<_Tp>::type; |
677 | #endif |
678 | |
679 | #endif // __has_keyword(__remove_const) |
680 | |
681 | // remove_volatile |
682 | |
683 | #if __has_keyword(__remove_volatile)!(1) |
684 | |
685 | template <class _Tp> |
686 | struct _LIBCPP_TEMPLATE_VIS__attribute__ ((__type_visibility__("default"))) remove_volatile {typedef __remove_volatile(_Tp) type;}; |
687 | |
688 | #if _LIBCPP_STD_VER14 > 11 |
689 | template <class _Tp> using remove_volatile_t = __remove_volatile(_Tp); |
690 | #endif |
691 | |
692 | #else |
693 | |
694 | template <class _Tp> struct _LIBCPP_TEMPLATE_VIS__attribute__ ((__type_visibility__("default"))) remove_volatile {typedef _Tp type;}; |
695 | template <class _Tp> struct _LIBCPP_TEMPLATE_VIS__attribute__ ((__type_visibility__("default"))) remove_volatile<volatile _Tp> {typedef _Tp type;}; |
696 | #if _LIBCPP_STD_VER14 > 11 |
697 | template <class _Tp> using remove_volatile_t = typename remove_volatile<_Tp>::type; |
698 | #endif |
699 | |
700 | #endif // __has_keyword(__remove_volatile) |
701 | |
702 | // remove_cv |
703 | |
704 | #if __has_keyword(__remove_cv)!(1) |
705 | |
706 | template <class _Tp> |
707 | struct _LIBCPP_TEMPLATE_VIS__attribute__ ((__type_visibility__("default"))) remove_cv {typedef __remove_cv(_Tp) type;}; |
708 | |
709 | #if _LIBCPP_STD_VER14 > 11 |
710 | template <class _Tp> using remove_cv_t = __remove_cv(_Tp); |
711 | #endif |
712 | |
713 | #else |
714 | |
715 | template <class _Tp> struct _LIBCPP_TEMPLATE_VIS__attribute__ ((__type_visibility__("default"))) remove_cv |
716 | {typedef typename remove_volatile<typename remove_const<_Tp>::type>::type type;}; |
717 | #if _LIBCPP_STD_VER14 > 11 |
718 | template <class _Tp> using remove_cv_t = typename remove_cv<_Tp>::type; |
719 | #endif |
720 | |
721 | #endif // __has_keyword(__remove_cv) |
722 | |
723 | // is_void |
724 | |
725 | #if __has_keyword(__is_void)!(0) |
726 | |
727 | template <class _Tp> |
728 | struct _LIBCPP_TEMPLATE_VIS__attribute__ ((__type_visibility__("default"))) is_void : _BoolConstant<__is_void(_Tp)> { }; |
729 | |
730 | #if _LIBCPP_STD_VER14 > 14 && !defined(_LIBCPP_HAS_NO_VARIABLE_TEMPLATES) |
731 | template <class _Tp> |
732 | _LIBCPP_INLINE_VAR _LIBCPP_CONSTEXPRconstexpr bool is_void_v = __is_void(_Tp); |
733 | #endif |
734 | |
735 | #else |
736 | |
737 | template <class _Tp> struct _LIBCPP_TEMPLATE_VIS__attribute__ ((__type_visibility__("default"))) is_void |
738 | : public is_same<typename remove_cv<_Tp>::type, void> {}; |
739 | |
740 | #if _LIBCPP_STD_VER14 > 14 && !defined(_LIBCPP_HAS_NO_VARIABLE_TEMPLATES) |
741 | template <class _Tp> |
742 | _LIBCPP_INLINE_VAR _LIBCPP_CONSTEXPRconstexpr bool is_void_v |
743 | = is_void<_Tp>::value; |
744 | #endif |
745 | |
746 | #endif // __has_keyword(__is_void) |
747 | |
748 | // __is_nullptr_t |
749 | |
750 | template <class _Tp> struct __is_nullptr_t_impl : public false_type {}; |
751 | template <> struct __is_nullptr_t_impl<nullptr_t> : public true_type {}; |
752 | |
753 | template <class _Tp> struct _LIBCPP_TEMPLATE_VIS__attribute__ ((__type_visibility__("default"))) __is_nullptr_t |
754 | : public __is_nullptr_t_impl<typename remove_cv<_Tp>::type> {}; |
755 | |
756 | #if _LIBCPP_STD_VER14 > 11 |
757 | template <class _Tp> struct _LIBCPP_TEMPLATE_VIS__attribute__ ((__type_visibility__("default"))) is_null_pointer |
758 | : public __is_nullptr_t_impl<typename remove_cv<_Tp>::type> {}; |
759 | |
760 | #if _LIBCPP_STD_VER14 > 14 && !defined(_LIBCPP_HAS_NO_VARIABLE_TEMPLATES) |
761 | template <class _Tp> |
762 | _LIBCPP_INLINE_VAR _LIBCPP_CONSTEXPRconstexpr bool is_null_pointer_v |
763 | = is_null_pointer<_Tp>::value; |
764 | #endif |
765 | #endif // _LIBCPP_STD_VER > 11 |
766 | |
767 | // is_integral |
768 | |
769 | #if __has_keyword(__is_integral)!(0) |
770 | |
771 | template <class _Tp> |
772 | struct _LIBCPP_TEMPLATE_VIS__attribute__ ((__type_visibility__("default"))) is_integral : _BoolConstant<__is_integral(_Tp)> { }; |
773 | |
774 | #if _LIBCPP_STD_VER14 > 14 |
775 | template <class _Tp> |
776 | _LIBCPP_INLINE_VAR _LIBCPP_CONSTEXPRconstexpr bool is_integral_v = __is_integral(_Tp); |
777 | #endif |
778 | |
779 | #else |
780 | |
781 | template <class _Tp> struct _LIBCPP_TEMPLATE_VIS__attribute__ ((__type_visibility__("default"))) is_integral |
782 | : public _BoolConstant<__libcpp_is_integral<typename remove_cv<_Tp>::type>::value> {}; |
783 | |
784 | #if _LIBCPP_STD_VER14 > 14 && !defined(_LIBCPP_HAS_NO_VARIABLE_TEMPLATES) |
785 | template <class _Tp> |
786 | _LIBCPP_INLINE_VAR _LIBCPP_CONSTEXPRconstexpr bool is_integral_v |
787 | = is_integral<_Tp>::value; |
788 | #endif |
789 | |
790 | #endif // __has_keyword(__is_integral) |
791 | |
792 | // __libcpp_is_signed_integer, __libcpp_is_unsigned_integer |
793 | |
794 | // [basic.fundamental] defines five standard signed integer types; |
795 | // __int128_t is an extended signed integer type. |
796 | // The signed and unsigned integer types, plus bool and the |
797 | // five types with "char" in their name, compose the "integral" types. |
798 | |
799 | template <class _Tp> struct __libcpp_is_signed_integer : public false_type {}; |
800 | template <> struct __libcpp_is_signed_integer<signed char> : public true_type {}; |
801 | template <> struct __libcpp_is_signed_integer<signed short> : public true_type {}; |
802 | template <> struct __libcpp_is_signed_integer<signed int> : public true_type {}; |
803 | template <> struct __libcpp_is_signed_integer<signed long> : public true_type {}; |
804 | template <> struct __libcpp_is_signed_integer<signed long long> : public true_type {}; |
805 | #ifndef _LIBCPP_HAS_NO_INT128 |
806 | template <> struct __libcpp_is_signed_integer<__int128_t> : public true_type {}; |
807 | #endif |
808 | |
809 | template <class _Tp> struct __libcpp_is_unsigned_integer : public false_type {}; |
810 | template <> struct __libcpp_is_unsigned_integer<unsigned char> : public true_type {}; |
811 | template <> struct __libcpp_is_unsigned_integer<unsigned short> : public true_type {}; |
812 | template <> struct __libcpp_is_unsigned_integer<unsigned int> : public true_type {}; |
813 | template <> struct __libcpp_is_unsigned_integer<unsigned long> : public true_type {}; |
814 | template <> struct __libcpp_is_unsigned_integer<unsigned long long> : public true_type {}; |
815 | #ifndef _LIBCPP_HAS_NO_INT128 |
816 | template <> struct __libcpp_is_unsigned_integer<__uint128_t> : public true_type {}; |
817 | #endif |
818 | |
819 | // is_floating_point |
820 | |
821 | template <class _Tp> struct __libcpp_is_floating_point : public false_type {}; |
822 | template <> struct __libcpp_is_floating_point<float> : public true_type {}; |
823 | template <> struct __libcpp_is_floating_point<double> : public true_type {}; |
824 | template <> struct __libcpp_is_floating_point<long double> : public true_type {}; |
825 | |
826 | template <class _Tp> struct _LIBCPP_TEMPLATE_VIS__attribute__ ((__type_visibility__("default"))) is_floating_point |
827 | : public __libcpp_is_floating_point<typename remove_cv<_Tp>::type> {}; |
828 | |
829 | #if _LIBCPP_STD_VER14 > 14 && !defined(_LIBCPP_HAS_NO_VARIABLE_TEMPLATES) |
830 | template <class _Tp> |
831 | _LIBCPP_INLINE_VAR _LIBCPP_CONSTEXPRconstexpr bool is_floating_point_v |
832 | = is_floating_point<_Tp>::value; |
833 | #endif |
834 | |
835 | // is_array |
836 | |
837 | #if __has_keyword(__is_array)!(0) |
838 | |
839 | template <class _Tp> |
840 | struct _LIBCPP_TEMPLATE_VIS__attribute__ ((__type_visibility__("default"))) is_array : _BoolConstant<__is_array(_Tp)> { }; |
841 | |
842 | #if _LIBCPP_STD_VER14 > 14 && !defined(_LIBCPP_HAS_NO_VARIABLE_TEMPLATES) |
843 | template <class _Tp> |
844 | _LIBCPP_INLINE_VAR _LIBCPP_CONSTEXPRconstexpr bool is_array_v = __is_array(_Tp); |
845 | #endif |
846 | |
847 | #else |
848 | |
849 | template <class _Tp> struct _LIBCPP_TEMPLATE_VIS__attribute__ ((__type_visibility__("default"))) is_array |
850 | : public false_type {}; |
851 | template <class _Tp> struct _LIBCPP_TEMPLATE_VIS__attribute__ ((__type_visibility__("default"))) is_array<_Tp[]> |
852 | : public true_type {}; |
853 | template <class _Tp, size_t _Np> struct _LIBCPP_TEMPLATE_VIS__attribute__ ((__type_visibility__("default"))) is_array<_Tp[_Np]> |
854 | : public true_type {}; |
855 | |
856 | #if _LIBCPP_STD_VER14 > 14 && !defined(_LIBCPP_HAS_NO_VARIABLE_TEMPLATES) |
857 | template <class _Tp> |
858 | _LIBCPP_INLINE_VAR _LIBCPP_CONSTEXPRconstexpr bool is_array_v |
859 | = is_array<_Tp>::value; |
860 | #endif |
861 | |
862 | #endif // __has_keyword(__is_array) |
863 | |
864 | // is_pointer |
865 | |
866 | // Before Clang 11 / AppleClang 12.0.5, __is_pointer didn't work for Objective-C types. |
867 | #if __has_keyword(__is_pointer)!(0) && \ |
868 | !(defined(_LIBCPP_CLANG_VER(13 * 100 + 0)) && _LIBCPP_CLANG_VER(13 * 100 + 0) < 1100) && \ |
869 | !(defined(_LIBCPP_APPLE_CLANG_VER) && _LIBCPP_APPLE_CLANG_VER < 1205) |
870 | |
871 | template<class _Tp> |
872 | struct _LIBCPP_TEMPLATE_VIS__attribute__ ((__type_visibility__("default"))) is_pointer : _BoolConstant<__is_pointer(_Tp)> { }; |
873 | |
874 | #if _LIBCPP_STD_VER14 > 14 && !defined(_LIBCPP_HAS_NO_VARIABLE_TEMPLATES) |
875 | template <class _Tp> |
876 | _LIBCPP_INLINE_VAR _LIBCPP_CONSTEXPRconstexpr bool is_pointer_v = __is_pointer(_Tp); |
877 | #endif |
878 | |
879 | #else // __has_keyword(__is_pointer) |
880 | |
881 | template <class _Tp> struct __libcpp_is_pointer : public false_type {}; |
882 | template <class _Tp> struct __libcpp_is_pointer<_Tp*> : public true_type {}; |
883 | |
884 | template <class _Tp> struct __libcpp_remove_objc_qualifiers { typedef _Tp type; }; |
885 | #if defined(_LIBCPP_HAS_OBJC_ARC) |
886 | template <class _Tp> struct __libcpp_remove_objc_qualifiers<_Tp __strong> { typedef _Tp type; }; |
887 | template <class _Tp> struct __libcpp_remove_objc_qualifiers<_Tp __weak> { typedef _Tp type; }; |
888 | template <class _Tp> struct __libcpp_remove_objc_qualifiers<_Tp __autoreleasing> { typedef _Tp type; }; |
889 | template <class _Tp> struct __libcpp_remove_objc_qualifiers<_Tp __unsafe_unretained> { typedef _Tp type; }; |
890 | #endif |
891 | |
892 | template <class _Tp> struct _LIBCPP_TEMPLATE_VIS__attribute__ ((__type_visibility__("default"))) is_pointer |
893 | : public __libcpp_is_pointer<typename __libcpp_remove_objc_qualifiers<typename remove_cv<_Tp>::type>::type> {}; |
894 | |
895 | #if _LIBCPP_STD_VER14 > 14 && !defined(_LIBCPP_HAS_NO_VARIABLE_TEMPLATES) |
896 | template <class _Tp> |
897 | _LIBCPP_INLINE_VAR _LIBCPP_CONSTEXPRconstexpr bool is_pointer_v |
898 | = is_pointer<_Tp>::value; |
899 | #endif |
900 | |
901 | #endif // __has_keyword(__is_pointer) |
902 | |
903 | // is_reference |
904 | |
905 | #if __has_keyword(__is_lvalue_reference)!(0) && \ |
906 | __has_keyword(__is_rvalue_reference)!(0) && \ |
907 | __has_keyword(__is_reference)!(0) |
908 | |
909 | template<class _Tp> |
910 | struct _LIBCPP_TEMPLATE_VIS__attribute__ ((__type_visibility__("default"))) is_lvalue_reference : _BoolConstant<__is_lvalue_reference(_Tp)> { }; |
911 | |
912 | template<class _Tp> |
913 | struct _LIBCPP_TEMPLATE_VIS__attribute__ ((__type_visibility__("default"))) is_rvalue_reference : _BoolConstant<__is_rvalue_reference(_Tp)> { }; |
914 | |
915 | template<class _Tp> |
916 | struct _LIBCPP_TEMPLATE_VIS__attribute__ ((__type_visibility__("default"))) is_reference : _BoolConstant<__is_reference(_Tp)> { }; |
917 | |
918 | #if _LIBCPP_STD_VER14 > 14 && !defined(_LIBCPP_HAS_NO_VARIABLE_TEMPLATES) |
919 | template <class _Tp> |
920 | _LIBCPP_INLINE_VAR _LIBCPP_CONSTEXPRconstexpr bool is_reference_v = __is_reference(_Tp); |
921 | |
922 | template <class _Tp> |
923 | _LIBCPP_INLINE_VAR _LIBCPP_CONSTEXPRconstexpr bool is_lvalue_reference_v = __is_lvalue_reference(_Tp); |
924 | |
925 | template <class _Tp> |
926 | _LIBCPP_INLINE_VAR _LIBCPP_CONSTEXPRconstexpr bool is_rvalue_reference_v = __is_rvalue_reference(_Tp); |
927 | #endif |
928 | |
929 | #else // __has_keyword(__is_lvalue_reference) && etc... |
930 | |
931 | template <class _Tp> struct _LIBCPP_TEMPLATE_VIS__attribute__ ((__type_visibility__("default"))) is_lvalue_reference : public false_type {}; |
932 | template <class _Tp> struct _LIBCPP_TEMPLATE_VIS__attribute__ ((__type_visibility__("default"))) is_lvalue_reference<_Tp&> : public true_type {}; |
933 | |
934 | template <class _Tp> struct _LIBCPP_TEMPLATE_VIS__attribute__ ((__type_visibility__("default"))) is_rvalue_reference : public false_type {}; |
935 | template <class _Tp> struct _LIBCPP_TEMPLATE_VIS__attribute__ ((__type_visibility__("default"))) is_rvalue_reference<_Tp&&> : public true_type {}; |
936 | |
937 | template <class _Tp> struct _LIBCPP_TEMPLATE_VIS__attribute__ ((__type_visibility__("default"))) is_reference : public false_type {}; |
938 | template <class _Tp> struct _LIBCPP_TEMPLATE_VIS__attribute__ ((__type_visibility__("default"))) is_reference<_Tp&> : public true_type {}; |
939 | template <class _Tp> struct _LIBCPP_TEMPLATE_VIS__attribute__ ((__type_visibility__("default"))) is_reference<_Tp&&> : public true_type {}; |
940 | |
941 | #if _LIBCPP_STD_VER14 > 14 && !defined(_LIBCPP_HAS_NO_VARIABLE_TEMPLATES) |
942 | template <class _Tp> |
943 | _LIBCPP_INLINE_VAR _LIBCPP_CONSTEXPRconstexpr bool is_reference_v |
944 | = is_reference<_Tp>::value; |
945 | |
946 | template <class _Tp> |
947 | _LIBCPP_INLINE_VAR _LIBCPP_CONSTEXPRconstexpr bool is_lvalue_reference_v |
948 | = is_lvalue_reference<_Tp>::value; |
949 | |
950 | template <class _Tp> |
951 | _LIBCPP_INLINE_VAR _LIBCPP_CONSTEXPRconstexpr bool is_rvalue_reference_v |
952 | = is_rvalue_reference<_Tp>::value; |
953 | #endif |
954 | |
955 | #endif // __has_keyword(__is_lvalue_reference) && etc... |
956 | |
957 | // is_union |
958 | |
959 | #if __has_feature(is_union)1 || defined(_LIBCPP_COMPILER_GCC) |
960 | |
961 | template <class _Tp> struct _LIBCPP_TEMPLATE_VIS__attribute__ ((__type_visibility__("default"))) is_union |
962 | : public integral_constant<bool, __is_union(_Tp)> {}; |
963 | |
964 | #else |
965 | |
966 | template <class _Tp> struct __libcpp_union : public false_type {}; |
967 | template <class _Tp> struct _LIBCPP_TEMPLATE_VIS__attribute__ ((__type_visibility__("default"))) is_union |
968 | : public __libcpp_union<typename remove_cv<_Tp>::type> {}; |
969 | |
970 | #endif |
971 | |
972 | #if _LIBCPP_STD_VER14 > 14 && !defined(_LIBCPP_HAS_NO_VARIABLE_TEMPLATES) |
973 | template <class _Tp> |
974 | _LIBCPP_INLINE_VAR _LIBCPP_CONSTEXPRconstexpr bool is_union_v |
975 | = is_union<_Tp>::value; |
976 | #endif |
977 | |
978 | // is_class |
979 | |
980 | #if __has_feature(is_class)1 || defined(_LIBCPP_COMPILER_GCC) |
981 | |
982 | template <class _Tp> struct _LIBCPP_TEMPLATE_VIS__attribute__ ((__type_visibility__("default"))) is_class |
983 | : public integral_constant<bool, __is_class(_Tp)> {}; |
984 | |
985 | #else |
986 | |
987 | namespace __is_class_imp |
988 | { |
989 | template <class _Tp> char __test(int _Tp::*); |
990 | template <class _Tp> __two __test(...); |
991 | } |
992 | |
993 | template <class _Tp> struct _LIBCPP_TEMPLATE_VIS__attribute__ ((__type_visibility__("default"))) is_class |
994 | : public integral_constant<bool, sizeof(__is_class_imp::__test<_Tp>(0)) == 1 && !is_union<_Tp>::value> {}; |
995 | |
996 | #endif |
997 | |
998 | #if _LIBCPP_STD_VER14 > 14 && !defined(_LIBCPP_HAS_NO_VARIABLE_TEMPLATES) |
999 | template <class _Tp> |
1000 | _LIBCPP_INLINE_VAR _LIBCPP_CONSTEXPRconstexpr bool is_class_v |
1001 | = is_class<_Tp>::value; |
1002 | #endif |
1003 | |
1004 | // is_function |
1005 | |
1006 | template <class _Tp> struct _LIBCPP_TEMPLATE_VIS__attribute__ ((__type_visibility__("default"))) is_function |
1007 | : public _BoolConstant< |
1008 | #ifdef __clang__1 |
1009 | __is_function(_Tp) |
1010 | #else |
1011 | !(is_reference<_Tp>::value || is_const<const _Tp>::value) |
1012 | #endif |
1013 | > {}; |
1014 | |
1015 | |
1016 | #if _LIBCPP_STD_VER14 > 14 && !defined(_LIBCPP_HAS_NO_VARIABLE_TEMPLATES) |
1017 | template <class _Tp> |
1018 | _LIBCPP_INLINE_VAR _LIBCPP_CONSTEXPRconstexpr bool is_function_v |
1019 | = is_function<_Tp>::value; |
1020 | #endif |
1021 | |
1022 | template <class _Tp> struct __libcpp_is_member_pointer { |
1023 | enum { |
1024 | __is_member = false, |
1025 | __is_func = false, |
1026 | __is_obj = false |
1027 | }; |
1028 | }; |
1029 | template <class _Tp, class _Up> struct __libcpp_is_member_pointer<_Tp _Up::*> { |
1030 | enum { |
1031 | __is_member = true, |
1032 | __is_func = is_function<_Tp>::value, |
1033 | __is_obj = !__is_func, |
1034 | }; |
1035 | }; |
1036 | |
1037 | #if __has_keyword(__is_member_function_pointer)!(0) |
1038 | |
1039 | template<class _Tp> |
1040 | struct _LIBCPP_TEMPLATE_VIS__attribute__ ((__type_visibility__("default"))) is_member_function_pointer |
1041 | : _BoolConstant<__is_member_function_pointer(_Tp)> { }; |
1042 | |
1043 | #if _LIBCPP_STD_VER14 > 14 && !defined(_LIBCPP_HAS_NO_VARIABLE_TEMPLATES) |
1044 | template <class _Tp> |
1045 | _LIBCPP_INLINE_VAR _LIBCPP_CONSTEXPRconstexpr bool is_member_function_pointer_v |
1046 | = __is_member_function_pointer(_Tp); |
1047 | #endif |
1048 | |
1049 | #else // __has_keyword(__is_member_function_pointer) |
1050 | |
1051 | template <class _Tp> struct _LIBCPP_TEMPLATE_VIS__attribute__ ((__type_visibility__("default"))) is_member_function_pointer |
1052 | : public _BoolConstant< __libcpp_is_member_pointer<typename remove_cv<_Tp>::type>::__is_func > {}; |
1053 | |
1054 | #if _LIBCPP_STD_VER14 > 14 && !defined(_LIBCPP_HAS_NO_VARIABLE_TEMPLATES) |
1055 | template <class _Tp> |
1056 | _LIBCPP_INLINE_VAR _LIBCPP_CONSTEXPRconstexpr bool is_member_function_pointer_v |
1057 | = is_member_function_pointer<_Tp>::value; |
1058 | #endif |
1059 | |
1060 | #endif // __has_keyword(__is_member_function_pointer) |
1061 | |
1062 | // is_member_pointer |
1063 | |
1064 | #if __has_keyword(__is_member_pointer)!(0) |
1065 | |
1066 | template<class _Tp> |
1067 | struct _LIBCPP_TEMPLATE_VIS__attribute__ ((__type_visibility__("default"))) is_member_pointer : _BoolConstant<__is_member_pointer(_Tp)> { }; |
1068 | |
1069 | #if _LIBCPP_STD_VER14 > 14 && !defined(_LIBCPP_HAS_NO_VARIABLE_TEMPLATES) |
1070 | template <class _Tp> |
1071 | _LIBCPP_INLINE_VAR _LIBCPP_CONSTEXPRconstexpr bool is_member_pointer_v = __is_member_pointer(_Tp); |
1072 | #endif |
1073 | |
1074 | #else // __has_keyword(__is_member_pointer) |
1075 | |
1076 | template <class _Tp> struct _LIBCPP_TEMPLATE_VIS__attribute__ ((__type_visibility__("default"))) is_member_pointer |
1077 | : public _BoolConstant< __libcpp_is_member_pointer<typename remove_cv<_Tp>::type>::__is_member > {}; |
1078 | |
1079 | #if _LIBCPP_STD_VER14 > 14 && !defined(_LIBCPP_HAS_NO_VARIABLE_TEMPLATES) |
1080 | template <class _Tp> |
1081 | _LIBCPP_INLINE_VAR _LIBCPP_CONSTEXPRconstexpr bool is_member_pointer_v |
1082 | = is_member_pointer<_Tp>::value; |
1083 | #endif |
1084 | |
1085 | #endif // __has_keyword(__is_member_pointer) |
1086 | |
1087 | // is_member_object_pointer |
1088 | |
1089 | #if __has_keyword(__is_member_object_pointer)!(0) |
1090 | |
1091 | template<class _Tp> |
1092 | struct _LIBCPP_TEMPLATE_VIS__attribute__ ((__type_visibility__("default"))) is_member_object_pointer |
1093 | : _BoolConstant<__is_member_object_pointer(_Tp)> { }; |
1094 | |
1095 | #if _LIBCPP_STD_VER14 > 14 && !defined(_LIBCPP_HAS_NO_VARIABLE_TEMPLATES) |
1096 | template <class _Tp> |
1097 | _LIBCPP_INLINE_VAR _LIBCPP_CONSTEXPRconstexpr bool is_member_object_pointer_v |
1098 | = __is_member_object_pointer(_Tp); |
1099 | #endif |
1100 | |
1101 | #else // __has_keyword(__is_member_object_pointer) |
1102 | |
1103 | template <class _Tp> struct _LIBCPP_TEMPLATE_VIS__attribute__ ((__type_visibility__("default"))) is_member_object_pointer |
1104 | : public _BoolConstant< __libcpp_is_member_pointer<typename remove_cv<_Tp>::type>::__is_obj > {}; |
1105 | |
1106 | #if _LIBCPP_STD_VER14 > 14 && !defined(_LIBCPP_HAS_NO_VARIABLE_TEMPLATES) |
1107 | template <class _Tp> |
1108 | _LIBCPP_INLINE_VAR _LIBCPP_CONSTEXPRconstexpr bool is_member_object_pointer_v |
1109 | = is_member_object_pointer<_Tp>::value; |
1110 | #endif |
1111 | |
1112 | #endif // __has_keyword(__is_member_object_pointer) |
1113 | |
1114 | // is_enum |
1115 | |
1116 | #if __has_feature(is_enum)1 || defined(_LIBCPP_COMPILER_GCC) |
1117 | |
1118 | template <class _Tp> struct _LIBCPP_TEMPLATE_VIS__attribute__ ((__type_visibility__("default"))) is_enum |
1119 | : public integral_constant<bool, __is_enum(_Tp)> {}; |
1120 | |
1121 | #if _LIBCPP_STD_VER14 > 14 && !defined(_LIBCPP_HAS_NO_VARIABLE_TEMPLATES) |
1122 | template <class _Tp> |
1123 | _LIBCPP_INLINE_VAR _LIBCPP_CONSTEXPRconstexpr bool is_enum_v = __is_enum(_Tp); |
1124 | #endif |
1125 | |
1126 | #else |
1127 | |
1128 | template <class _Tp> struct _LIBCPP_TEMPLATE_VIS__attribute__ ((__type_visibility__("default"))) is_enum |
1129 | : public integral_constant<bool, !is_void<_Tp>::value && |
1130 | !is_integral<_Tp>::value && |
1131 | !is_floating_point<_Tp>::value && |
1132 | !is_array<_Tp>::value && |
1133 | !is_pointer<_Tp>::value && |
1134 | !is_reference<_Tp>::value && |
1135 | !is_member_pointer<_Tp>::value && |
1136 | !is_union<_Tp>::value && |
1137 | !is_class<_Tp>::value && |
1138 | !is_function<_Tp>::value > {}; |
1139 | |
1140 | #if _LIBCPP_STD_VER14 > 14 && !defined(_LIBCPP_HAS_NO_VARIABLE_TEMPLATES) |
1141 | template <class _Tp> |
1142 | _LIBCPP_INLINE_VAR _LIBCPP_CONSTEXPRconstexpr bool is_enum_v |
1143 | = is_enum<_Tp>::value; |
1144 | #endif |
1145 | |
1146 | #endif // __has_feature(is_enum) || defined(_LIBCPP_COMPILER_GCC) |
1147 | |
1148 | // is_arithmetic |
1149 | |
1150 | |
1151 | template <class _Tp> struct _LIBCPP_TEMPLATE_VIS__attribute__ ((__type_visibility__("default"))) is_arithmetic |
1152 | : public integral_constant<bool, is_integral<_Tp>::value || |
1153 | is_floating_point<_Tp>::value> {}; |
1154 | |
1155 | #if _LIBCPP_STD_VER14 > 14 && !defined(_LIBCPP_HAS_NO_VARIABLE_TEMPLATES) |
1156 | template <class _Tp> |
1157 | _LIBCPP_INLINE_VAR _LIBCPP_CONSTEXPRconstexpr bool is_arithmetic_v |
1158 | = is_arithmetic<_Tp>::value; |
1159 | #endif |
1160 | |
1161 | // is_fundamental |
1162 | |
1163 | // Before Clang 10, __is_fundamental didn't work for nullptr_t. |
1164 | // In C++03 nullptr_t is library-provided but must still count as "fundamental." |
1165 | #if __has_keyword(__is_fundamental)!(0) && \ |
1166 | !(defined(_LIBCPP_CLANG_VER(13 * 100 + 0)) && _LIBCPP_CLANG_VER(13 * 100 + 0) < 1000) && \ |
1167 | !defined(_LIBCPP_CXX03_LANG) |
1168 | |
1169 | template<class _Tp> |
1170 | struct _LIBCPP_TEMPLATE_VIS__attribute__ ((__type_visibility__("default"))) is_fundamental : _BoolConstant<__is_fundamental(_Tp)> { }; |
1171 | |
1172 | #if _LIBCPP_STD_VER14 > 14 && !defined(_LIBCPP_HAS_NO_VARIABLE_TEMPLATES) |
1173 | template <class _Tp> |
1174 | _LIBCPP_INLINE_VAR _LIBCPP_CONSTEXPRconstexpr bool is_fundamental_v = __is_fundamental(_Tp); |
1175 | #endif |
1176 | |
1177 | #else // __has_keyword(__is_fundamental) |
1178 | |
1179 | template <class _Tp> struct _LIBCPP_TEMPLATE_VIS__attribute__ ((__type_visibility__("default"))) is_fundamental |
1180 | : public integral_constant<bool, is_void<_Tp>::value || |
1181 | __is_nullptr_t<_Tp>::value || |
1182 | is_arithmetic<_Tp>::value> {}; |
1183 | |
1184 | #if _LIBCPP_STD_VER14 > 14 && !defined(_LIBCPP_HAS_NO_VARIABLE_TEMPLATES) |
1185 | template <class _Tp> |
1186 | _LIBCPP_INLINE_VAR _LIBCPP_CONSTEXPRconstexpr bool is_fundamental_v |
1187 | = is_fundamental<_Tp>::value; |
1188 | #endif |
1189 | |
1190 | #endif // __has_keyword(__is_fundamental) |
1191 | |
1192 | // is_scalar |
1193 | |
1194 | // In C++03 nullptr_t is library-provided but must still count as "scalar." |
1195 | #if __has_keyword(__is_scalar)!(0) && !defined(_LIBCPP_CXX03_LANG) |
1196 | |
1197 | template<class _Tp> |
1198 | struct _LIBCPP_TEMPLATE_VIS__attribute__ ((__type_visibility__("default"))) is_scalar : _BoolConstant<__is_scalar(_Tp)> { }; |
1199 | |
1200 | #if _LIBCPP_STD_VER14 > 14 && !defined(_LIBCPP_HAS_NO_VARIABLE_TEMPLATES) |
1201 | template <class _Tp> |
1202 | _LIBCPP_INLINE_VAR _LIBCPP_CONSTEXPRconstexpr bool is_scalar_v = __is_scalar(_Tp); |
1203 | #endif |
1204 | |
1205 | #else // __has_keyword(__is_scalar) |
1206 | |
1207 | template <class _Tp> struct __is_block : false_type {}; |
1208 | #if defined(_LIBCPP_HAS_EXTENSION_BLOCKS) |
1209 | template <class _Rp, class ..._Args> struct __is_block<_Rp (^)(_Args...)> : true_type {}; |
1210 | #endif |
1211 | |
1212 | template <class _Tp> struct _LIBCPP_TEMPLATE_VIS__attribute__ ((__type_visibility__("default"))) is_scalar |
1213 | : public integral_constant<bool, is_arithmetic<_Tp>::value || |
1214 | is_member_pointer<_Tp>::value || |
1215 | is_pointer<_Tp>::value || |
1216 | __is_nullptr_t<_Tp>::value || |
1217 | __is_block<_Tp>::value || |
1218 | is_enum<_Tp>::value > {}; |
1219 | |
1220 | template <> struct _LIBCPP_TEMPLATE_VIS__attribute__ ((__type_visibility__("default"))) is_scalar<nullptr_t> : public true_type {}; |
1221 | |
1222 | #if _LIBCPP_STD_VER14 > 14 && !defined(_LIBCPP_HAS_NO_VARIABLE_TEMPLATES) |
1223 | template <class _Tp> |
1224 | _LIBCPP_INLINE_VAR _LIBCPP_CONSTEXPRconstexpr bool is_scalar_v |
1225 | = is_scalar<_Tp>::value; |
1226 | #endif |
1227 | |
1228 | #endif // __has_keyword(__is_scalar) |
1229 | |
1230 | // is_object |
1231 | |
1232 | #if __has_keyword(__is_object)!(0) |
1233 | |
1234 | template<class _Tp> |
1235 | struct _LIBCPP_TEMPLATE_VIS__attribute__ ((__type_visibility__("default"))) is_object : _BoolConstant<__is_object(_Tp)> { }; |
1236 | |
1237 | #if _LIBCPP_STD_VER14 > 14 && !defined(_LIBCPP_HAS_NO_VARIABLE_TEMPLATES) |
1238 | template <class _Tp> |
1239 | _LIBCPP_INLINE_VAR _LIBCPP_CONSTEXPRconstexpr bool is_object_v = __is_object(_Tp); |
1240 | #endif |
1241 | |
1242 | #else // __has_keyword(__is_object) |
1243 | |
1244 | template <class _Tp> struct _LIBCPP_TEMPLATE_VIS__attribute__ ((__type_visibility__("default"))) is_object |
1245 | : public integral_constant<bool, is_scalar<_Tp>::value || |
1246 | is_array<_Tp>::value || |
1247 | is_union<_Tp>::value || |
1248 | is_class<_Tp>::value > {}; |
1249 | |
1250 | #if _LIBCPP_STD_VER14 > 14 && !defined(_LIBCPP_HAS_NO_VARIABLE_TEMPLATES) |
1251 | template <class _Tp> |
1252 | _LIBCPP_INLINE_VAR _LIBCPP_CONSTEXPRconstexpr bool is_object_v |
1253 | = is_object<_Tp>::value; |
1254 | #endif |
1255 | |
1256 | #endif // __has_keyword(__is_object) |
1257 | |
1258 | // is_compound |
1259 | |
1260 | // >= 11 because in C++03 nullptr isn't actually nullptr |
1261 | #if __has_keyword(__is_compound)!(0) && !defined(_LIBCPP_CXX03_LANG) |
1262 | |
1263 | template<class _Tp> |
1264 | struct _LIBCPP_TEMPLATE_VIS__attribute__ ((__type_visibility__("default"))) is_compound : _BoolConstant<__is_compound(_Tp)> { }; |
1265 | |
1266 | #if _LIBCPP_STD_VER14 > 14 && !defined(_LIBCPP_HAS_NO_VARIABLE_TEMPLATES) |
1267 | template <class _Tp> |
1268 | _LIBCPP_INLINE_VAR _LIBCPP_CONSTEXPRconstexpr bool is_compound_v = __is_compound(_Tp); |
1269 | #endif |
1270 | |
1271 | #else // __has_keyword(__is_compound) |
1272 | |
1273 | template <class _Tp> struct _LIBCPP_TEMPLATE_VIS__attribute__ ((__type_visibility__("default"))) is_compound |
1274 | : public integral_constant<bool, !is_fundamental<_Tp>::value> {}; |
1275 | |
1276 | #if _LIBCPP_STD_VER14 > 14 && !defined(_LIBCPP_HAS_NO_VARIABLE_TEMPLATES) |
1277 | template <class _Tp> |
1278 | _LIBCPP_INLINE_VAR _LIBCPP_CONSTEXPRconstexpr bool is_compound_v |
1279 | = is_compound<_Tp>::value; |
1280 | #endif |
1281 | |
1282 | #endif // __has_keyword(__is_compound) |
1283 | |
1284 | // __is_referenceable [defns.referenceable] |
1285 | |
1286 | struct __is_referenceable_impl { |
1287 | template <class _Tp> static _Tp& __test(int); |
1288 | template <class _Tp> static __two __test(...); |
1289 | }; |
1290 | |
1291 | template <class _Tp> |
1292 | struct __is_referenceable : integral_constant<bool, |
1293 | _IsNotSame<decltype(__is_referenceable_impl::__test<_Tp>(0)), __two>::value> {}; |
1294 | |
1295 | |
1296 | // add_const |
1297 | |
1298 | template <class _Tp> struct _LIBCPP_TEMPLATE_VIS__attribute__ ((__type_visibility__("default"))) add_const { |
1299 | typedef _LIBCPP_NODEBUG_TYPE__attribute__((nodebug)) const _Tp type; |
1300 | }; |
1301 | |
1302 | #if _LIBCPP_STD_VER14 > 11 |
1303 | template <class _Tp> using add_const_t = typename add_const<_Tp>::type; |
1304 | #endif |
1305 | |
1306 | // add_volatile |
1307 | |
1308 | template <class _Tp> struct _LIBCPP_TEMPLATE_VIS__attribute__ ((__type_visibility__("default"))) add_volatile { |
1309 | typedef _LIBCPP_NODEBUG_TYPE__attribute__((nodebug)) volatile _Tp type; |
1310 | }; |
1311 | |
1312 | #if _LIBCPP_STD_VER14 > 11 |
1313 | template <class _Tp> using add_volatile_t = typename add_volatile<_Tp>::type; |
1314 | #endif |
1315 | |
1316 | // add_cv |
1317 | template <class _Tp> struct _LIBCPP_TEMPLATE_VIS__attribute__ ((__type_visibility__("default"))) add_cv { |
1318 | typedef _LIBCPP_NODEBUG_TYPE__attribute__((nodebug)) const volatile _Tp type; |
1319 | }; |
1320 | |
1321 | #if _LIBCPP_STD_VER14 > 11 |
1322 | template <class _Tp> using add_cv_t = typename add_cv<_Tp>::type; |
1323 | #endif |
1324 | |
1325 | // remove_reference |
1326 | |
1327 | #if __has_keyword(__remove_reference)!(1) |
1328 | |
1329 | template<class _Tp> |
1330 | struct _LIBCPP_TEMPLATE_VIS__attribute__ ((__type_visibility__("default"))) remove_reference { typedef __remove_reference(_Tp) type; }; |
1331 | |
1332 | #else // __has_keyword(__remove_reference) |
1333 | |
1334 | template <class _Tp> struct _LIBCPP_TEMPLATE_VIS__attribute__ ((__type_visibility__("default"))) remove_reference {typedef _LIBCPP_NODEBUG_TYPE__attribute__((nodebug)) _Tp type;}; |
1335 | template <class _Tp> struct _LIBCPP_TEMPLATE_VIS__attribute__ ((__type_visibility__("default"))) remove_reference<_Tp&> {typedef _LIBCPP_NODEBUG_TYPE__attribute__((nodebug)) _Tp type;}; |
1336 | template <class _Tp> struct _LIBCPP_TEMPLATE_VIS__attribute__ ((__type_visibility__("default"))) remove_reference<_Tp&&> {typedef _LIBCPP_NODEBUG_TYPE__attribute__((nodebug)) _Tp type;}; |
1337 | |
1338 | #if _LIBCPP_STD_VER14 > 11 |
1339 | template <class _Tp> using remove_reference_t = typename remove_reference<_Tp>::type; |
1340 | #endif |
1341 | |
1342 | #endif // __has_keyword(__remove_reference) |
1343 | |
1344 | // add_lvalue_reference |
1345 | |
1346 | template <class _Tp, bool = __is_referenceable<_Tp>::value> struct __add_lvalue_reference_impl { typedef _LIBCPP_NODEBUG_TYPE__attribute__((nodebug)) _Tp type; }; |
1347 | template <class _Tp > struct __add_lvalue_reference_impl<_Tp, true> { typedef _LIBCPP_NODEBUG_TYPE__attribute__((nodebug)) _Tp& type; }; |
1348 | |
1349 | template <class _Tp> struct _LIBCPP_TEMPLATE_VIS__attribute__ ((__type_visibility__("default"))) add_lvalue_reference |
1350 | {typedef _LIBCPP_NODEBUG_TYPE__attribute__((nodebug)) typename __add_lvalue_reference_impl<_Tp>::type type;}; |
1351 | |
1352 | #if _LIBCPP_STD_VER14 > 11 |
1353 | template <class _Tp> using add_lvalue_reference_t = typename add_lvalue_reference<_Tp>::type; |
1354 | #endif |
1355 | |
1356 | template <class _Tp, bool = __is_referenceable<_Tp>::value> struct __add_rvalue_reference_impl { typedef _LIBCPP_NODEBUG_TYPE__attribute__((nodebug)) _Tp type; }; |
1357 | template <class _Tp > struct __add_rvalue_reference_impl<_Tp, true> { typedef _LIBCPP_NODEBUG_TYPE__attribute__((nodebug)) _Tp&& type; }; |
1358 | |
1359 | template <class _Tp> struct _LIBCPP_TEMPLATE_VIS__attribute__ ((__type_visibility__("default"))) add_rvalue_reference |
1360 | {typedef _LIBCPP_NODEBUG_TYPE__attribute__((nodebug)) typename __add_rvalue_reference_impl<_Tp>::type type;}; |
1361 | |
1362 | #if _LIBCPP_STD_VER14 > 11 |
1363 | template <class _Tp> using add_rvalue_reference_t = typename add_rvalue_reference<_Tp>::type; |
1364 | #endif |
1365 | |
1366 | // Suppress deprecation notice for volatile-qualified return type resulting |
1367 | // from volatile-qualified types _Tp. |
1368 | _LIBCPP_SUPPRESS_DEPRECATED_PUSHGCC diagnostic push
GCC diagnostic ignored "-Wdeprecated"
GCC diagnostic ignored "-Wdeprecated-declarations" |
1369 | template <class _Tp> _Tp&& __declval(int); |
1370 | template <class _Tp> _Tp __declval(long); |
1371 | _LIBCPP_SUPPRESS_DEPRECATED_POPGCC diagnostic pop |
1372 | |
1373 | template <class _Tp> |
1374 | decltype(__declval<_Tp>(0)) |
1375 | declval() _NOEXCEPTnoexcept; |
1376 | |
1377 | // __uncvref |
1378 | |
1379 | template <class _Tp> |
1380 | struct __uncvref { |
1381 | typedef _LIBCPP_NODEBUG_TYPE__attribute__((nodebug)) typename remove_cv<typename remove_reference<_Tp>::type>::type type; |
1382 | }; |
1383 | |
1384 | template <class _Tp> |
1385 | struct __unconstref { |
1386 | typedef _LIBCPP_NODEBUG_TYPE__attribute__((nodebug)) typename remove_const<typename remove_reference<_Tp>::type>::type type; |
1387 | }; |
1388 | |
1389 | #ifndef _LIBCPP_CXX03_LANG |
1390 | template <class _Tp> |
1391 | using __uncvref_t _LIBCPP_NODEBUG_TYPE__attribute__((nodebug)) = typename __uncvref<_Tp>::type; |
1392 | #endif |
1393 | |
1394 | // __is_same_uncvref |
1395 | |
1396 | template <class _Tp, class _Up> |
1397 | struct __is_same_uncvref : _IsSame<typename __uncvref<_Tp>::type, |
1398 | typename __uncvref<_Up>::type> {}; |
1399 | |
1400 | #if _LIBCPP_STD_VER14 > 17 |
1401 | // remove_cvref - same as __uncvref |
1402 | template <class _Tp> |
1403 | struct remove_cvref : public __uncvref<_Tp> {}; |
1404 | |
1405 | template <class _Tp> using remove_cvref_t = typename remove_cvref<_Tp>::type; |
1406 | #endif |
1407 | |
1408 | |
1409 | struct __any |
1410 | { |
1411 | __any(...); |
1412 | }; |
1413 | |
1414 | // remove_pointer |
1415 | |
1416 | template <class _Tp> struct _LIBCPP_TEMPLATE_VIS__attribute__ ((__type_visibility__("default"))) remove_pointer {typedef _LIBCPP_NODEBUG_TYPE__attribute__((nodebug)) _Tp type;}; |
1417 | template <class _Tp> struct _LIBCPP_TEMPLATE_VIS__attribute__ ((__type_visibility__("default"))) remove_pointer<_Tp*> {typedef _LIBCPP_NODEBUG_TYPE__attribute__((nodebug)) _Tp type;}; |
1418 | template <class _Tp> struct _LIBCPP_TEMPLATE_VIS__attribute__ ((__type_visibility__("default"))) remove_pointer<_Tp* const> {typedef _LIBCPP_NODEBUG_TYPE__attribute__((nodebug)) _Tp type;}; |
1419 | template <class _Tp> struct _LIBCPP_TEMPLATE_VIS__attribute__ ((__type_visibility__("default"))) remove_pointer<_Tp* volatile> {typedef _LIBCPP_NODEBUG_TYPE__attribute__((nodebug)) _Tp type;}; |
1420 | template <class _Tp> struct _LIBCPP_TEMPLATE_VIS__attribute__ ((__type_visibility__("default"))) remove_pointer<_Tp* const volatile> {typedef _LIBCPP_NODEBUG_TYPE__attribute__((nodebug)) _Tp type;}; |
1421 | |
1422 | #if _LIBCPP_STD_VER14 > 11 |
1423 | template <class _Tp> using remove_pointer_t = typename remove_pointer<_Tp>::type; |
1424 | #endif |
1425 | |
1426 | // add_pointer |
1427 | |
1428 | template <class _Tp, |
1429 | bool = __is_referenceable<_Tp>::value || |
1430 | _IsSame<typename remove_cv<_Tp>::type, void>::value> |
1431 | struct __add_pointer_impl |
1432 | {typedef _LIBCPP_NODEBUG_TYPE__attribute__((nodebug)) typename remove_reference<_Tp>::type* type;}; |
1433 | template <class _Tp> struct __add_pointer_impl<_Tp, false> |
1434 | {typedef _LIBCPP_NODEBUG_TYPE__attribute__((nodebug)) _Tp type;}; |
1435 | |
1436 | template <class _Tp> struct _LIBCPP_TEMPLATE_VIS__attribute__ ((__type_visibility__("default"))) add_pointer |
1437 | {typedef _LIBCPP_NODEBUG_TYPE__attribute__((nodebug)) typename __add_pointer_impl<_Tp>::type type;}; |
1438 | |
1439 | #if _LIBCPP_STD_VER14 > 11 |
1440 | template <class _Tp> using add_pointer_t = typename add_pointer<_Tp>::type; |
1441 | #endif |
1442 | |
1443 | // type_identity |
1444 | #if _LIBCPP_STD_VER14 > 17 |
1445 | template<class _Tp> struct type_identity { typedef _Tp type; }; |
1446 | template<class _Tp> using type_identity_t = typename type_identity<_Tp>::type; |
1447 | #endif |
1448 | |
1449 | // is_signed |
1450 | |
1451 | // Before Clang 10, __is_signed didn't work for floating-point types or enums. |
1452 | #if __has_keyword(__is_signed)!(0) && \ |
1453 | !(defined(_LIBCPP_CLANG_VER(13 * 100 + 0)) && _LIBCPP_CLANG_VER(13 * 100 + 0) < 1000) |
1454 | |
1455 | template<class _Tp> |
1456 | struct _LIBCPP_TEMPLATE_VIS__attribute__ ((__type_visibility__("default"))) is_signed : _BoolConstant<__is_signed(_Tp)> { }; |
1457 | |
1458 | #if _LIBCPP_STD_VER14 > 14 && !defined(_LIBCPP_HAS_NO_VARIABLE_TEMPLATES) |
1459 | template <class _Tp> |
1460 | _LIBCPP_INLINE_VAR _LIBCPP_CONSTEXPRconstexpr bool is_signed_v = __is_signed(_Tp); |
1461 | #endif |
1462 | |
1463 | #else // __has_keyword(__is_signed) |
1464 | |
1465 | template <class _Tp, bool = is_integral<_Tp>::value> |
1466 | struct __libcpp_is_signed_impl : public _LIBCPP_BOOL_CONSTANT(_Tp(-1) < _Tp(0))integral_constant<bool,(_Tp(-1) < _Tp(0))> {}; |
1467 | |
1468 | template <class _Tp> |
1469 | struct __libcpp_is_signed_impl<_Tp, false> : public true_type {}; // floating point |
1470 | |
1471 | template <class _Tp, bool = is_arithmetic<_Tp>::value> |
1472 | struct __libcpp_is_signed : public __libcpp_is_signed_impl<_Tp> {}; |
1473 | |
1474 | template <class _Tp> struct __libcpp_is_signed<_Tp, false> : public false_type {}; |
1475 | |
1476 | template <class _Tp> struct _LIBCPP_TEMPLATE_VIS__attribute__ ((__type_visibility__("default"))) is_signed : public __libcpp_is_signed<_Tp> {}; |
1477 | |
1478 | #if _LIBCPP_STD_VER14 > 14 && !defined(_LIBCPP_HAS_NO_VARIABLE_TEMPLATES) |
1479 | template <class _Tp> |
1480 | _LIBCPP_INLINE_VAR _LIBCPP_CONSTEXPRconstexpr bool is_signed_v |
1481 | = is_signed<_Tp>::value; |
1482 | #endif |
1483 | |
1484 | #endif // __has_keyword(__is_signed) |
1485 | |
1486 | // is_unsigned |
1487 | |
1488 | // Before Clang 13, __is_unsigned returned true for enums with signed underlying type. |
1489 | // No currently-released version of AppleClang contains the fixed intrinsic. |
1490 | #if __has_keyword(__is_unsigned)!(0) && \ |
1491 | !(defined(_LIBCPP_CLANG_VER(13 * 100 + 0)) && _LIBCPP_CLANG_VER(13 * 100 + 0) < 1300) && \ |
1492 | !defined(_LIBCPP_APPLE_CLANG_VER) |
1493 | |
1494 | template<class _Tp> |
1495 | struct _LIBCPP_TEMPLATE_VIS__attribute__ ((__type_visibility__("default"))) is_unsigned : _BoolConstant<__is_unsigned(_Tp)> { }; |
1496 | |
1497 | #if _LIBCPP_STD_VER14 > 14 && !defined(_LIBCPP_HAS_NO_VARIABLE_TEMPLATES) |
1498 | template <class _Tp> |
1499 | _LIBCPP_INLINE_VAR _LIBCPP_CONSTEXPRconstexpr bool is_unsigned_v = __is_unsigned(_Tp); |
1500 | #endif |
1501 | |
1502 | #else // __has_keyword(__is_unsigned) |
1503 | |
1504 | template <class _Tp, bool = is_integral<_Tp>::value> |
1505 | struct __libcpp_is_unsigned_impl : public _LIBCPP_BOOL_CONSTANT(_Tp(0) < _Tp(-1))integral_constant<bool,(_Tp(0) < _Tp(-1))> {}; |
1506 | |
1507 | template <class _Tp> |
1508 | struct __libcpp_is_unsigned_impl<_Tp, false> : public false_type {}; // floating point |
1509 | |
1510 | template <class _Tp, bool = is_arithmetic<_Tp>::value> |
1511 | struct __libcpp_is_unsigned : public __libcpp_is_unsigned_impl<_Tp> {}; |
1512 | |
1513 | template <class _Tp> struct __libcpp_is_unsigned<_Tp, false> : public false_type {}; |
1514 | |
1515 | template <class _Tp> struct _LIBCPP_TEMPLATE_VIS__attribute__ ((__type_visibility__("default"))) is_unsigned : public __libcpp_is_unsigned<_Tp> {}; |
1516 | |
1517 | #if _LIBCPP_STD_VER14 > 14 && !defined(_LIBCPP_HAS_NO_VARIABLE_TEMPLATES) |
1518 | template <class _Tp> |
1519 | _LIBCPP_INLINE_VAR _LIBCPP_CONSTEXPRconstexpr bool is_unsigned_v |
1520 | = is_unsigned<_Tp>::value; |
1521 | #endif |
1522 | |
1523 | #endif // __has_keyword(__is_unsigned) |
1524 | |
1525 | // rank |
1526 | |
1527 | template <class _Tp> struct _LIBCPP_TEMPLATE_VIS__attribute__ ((__type_visibility__("default"))) rank |
1528 | : public integral_constant<size_t, 0> {}; |
1529 | template <class _Tp> struct _LIBCPP_TEMPLATE_VIS__attribute__ ((__type_visibility__("default"))) rank<_Tp[]> |
1530 | : public integral_constant<size_t, rank<_Tp>::value + 1> {}; |
1531 | template <class _Tp, size_t _Np> struct _LIBCPP_TEMPLATE_VIS__attribute__ ((__type_visibility__("default"))) rank<_Tp[_Np]> |
1532 | : public integral_constant<size_t, rank<_Tp>::value + 1> {}; |
1533 | |
1534 | #if _LIBCPP_STD_VER14 > 14 && !defined(_LIBCPP_HAS_NO_VARIABLE_TEMPLATES) |
1535 | template <class _Tp> |
1536 | _LIBCPP_INLINE_VAR _LIBCPP_CONSTEXPRconstexpr size_t rank_v |
1537 | = rank<_Tp>::value; |
1538 | #endif |
1539 | |
1540 | // extent |
1541 | |
1542 | #if __has_keyword(__array_extent)!(0) |
1543 | |
1544 | template<class _Tp, size_t _Dim = 0> |
1545 | struct _LIBCPP_TEMPLATE_VIS__attribute__ ((__type_visibility__("default"))) extent |
1546 | : integral_constant<size_t, __array_extent(_Tp, _Dim)> { }; |
1547 | |
1548 | #if _LIBCPP_STD_VER14 > 14 && !defined(_LIBCPP_HAS_NO_VARIABLE_TEMPLATES) |
1549 | template <class _Tp, unsigned _Ip = 0> |
1550 | _LIBCPP_INLINE_VAR _LIBCPP_CONSTEXPRconstexpr size_t extent_v = __array_extent(_Tp, _Ip); |
1551 | #endif |
1552 | |
1553 | #else // __has_keyword(__array_extent) |
1554 | |
1555 | template <class _Tp, unsigned _Ip = 0> struct _LIBCPP_TEMPLATE_VIS__attribute__ ((__type_visibility__("default"))) extent |
1556 | : public integral_constant<size_t, 0> {}; |
1557 | template <class _Tp> struct _LIBCPP_TEMPLATE_VIS__attribute__ ((__type_visibility__("default"))) extent<_Tp[], 0> |
1558 | : public integral_constant<size_t, 0> {}; |
1559 | template <class _Tp, unsigned _Ip> struct _LIBCPP_TEMPLATE_VIS__attribute__ ((__type_visibility__("default"))) extent<_Tp[], _Ip> |
1560 | : public integral_constant<size_t, extent<_Tp, _Ip-1>::value> {}; |
1561 | template <class _Tp, size_t _Np> struct _LIBCPP_TEMPLATE_VIS__attribute__ ((__type_visibility__("default"))) extent<_Tp[_Np], 0> |
1562 | : public integral_constant<size_t, _Np> {}; |
1563 | template <class _Tp, size_t _Np, unsigned _Ip> struct _LIBCPP_TEMPLATE_VIS__attribute__ ((__type_visibility__("default"))) extent<_Tp[_Np], _Ip> |
1564 | : public integral_constant<size_t, extent<_Tp, _Ip-1>::value> {}; |
1565 | |
1566 | #if _LIBCPP_STD_VER14 > 14 && !defined(_LIBCPP_HAS_NO_VARIABLE_TEMPLATES) |
1567 | template <class _Tp, unsigned _Ip = 0> |
1568 | _LIBCPP_INLINE_VAR _LIBCPP_CONSTEXPRconstexpr size_t extent_v |
1569 | = extent<_Tp, _Ip>::value; |
1570 | #endif |
1571 | |
1572 | #endif // __has_keyword(__array_extent) |
1573 | |
1574 | // remove_extent |
1575 | |
1576 | template <class _Tp> struct _LIBCPP_TEMPLATE_VIS__attribute__ ((__type_visibility__("default"))) remove_extent |
1577 | {typedef _Tp type;}; |
1578 | template <class _Tp> struct _LIBCPP_TEMPLATE_VIS__attribute__ ((__type_visibility__("default"))) remove_extent<_Tp[]> |
1579 | {typedef _Tp type;}; |
1580 | template <class _Tp, size_t _Np> struct _LIBCPP_TEMPLATE_VIS__attribute__ ((__type_visibility__("default"))) remove_extent<_Tp[_Np]> |
1581 | {typedef _Tp type;}; |
1582 | |
1583 | #if _LIBCPP_STD_VER14 > 11 |
1584 | template <class _Tp> using remove_extent_t = typename remove_extent<_Tp>::type; |
1585 | #endif |
1586 | |
1587 | // remove_all_extents |
1588 | |
1589 | template <class _Tp> struct _LIBCPP_TEMPLATE_VIS__attribute__ ((__type_visibility__("default"))) remove_all_extents |
1590 | {typedef _Tp type;}; |
1591 | template <class _Tp> struct _LIBCPP_TEMPLATE_VIS__attribute__ ((__type_visibility__("default"))) remove_all_extents<_Tp[]> |
1592 | {typedef typename remove_all_extents<_Tp>::type type;}; |
1593 | template <class _Tp, size_t _Np> struct _LIBCPP_TEMPLATE_VIS__attribute__ ((__type_visibility__("default"))) remove_all_extents<_Tp[_Np]> |
1594 | {typedef typename remove_all_extents<_Tp>::type type;}; |
1595 | |
1596 | #if _LIBCPP_STD_VER14 > 11 |
1597 | template <class _Tp> using remove_all_extents_t = typename remove_all_extents<_Tp>::type; |
1598 | #endif |
1599 | |
1600 | #if _LIBCPP_STD_VER14 > 17 |
1601 | // is_bounded_array |
1602 | |
1603 | template <class> struct _LIBCPP_TEMPLATE_VIS__attribute__ ((__type_visibility__("default"))) is_bounded_array : false_type {}; |
1604 | template <class _Tp, size_t _Np> struct _LIBCPP_TEMPLATE_VIS__attribute__ ((__type_visibility__("default"))) is_bounded_array<_Tp[_Np]> : true_type {}; |
1605 | |
1606 | template <class _Tp> |
1607 | _LIBCPP_INLINE_VAR _LIBCPP_CONSTEXPRconstexpr |
1608 | bool is_bounded_array_v = is_bounded_array<_Tp>::value; |
1609 | |
1610 | // is_unbounded_array |
1611 | |
1612 | template <class> struct _LIBCPP_TEMPLATE_VIS__attribute__ ((__type_visibility__("default"))) is_unbounded_array : false_type {}; |
1613 | template <class _Tp> struct _LIBCPP_TEMPLATE_VIS__attribute__ ((__type_visibility__("default"))) is_unbounded_array<_Tp[]> : true_type {}; |
1614 | |
1615 | template <class _Tp> |
1616 | _LIBCPP_INLINE_VAR _LIBCPP_CONSTEXPRconstexpr |
1617 | bool is_unbounded_array_v = is_unbounded_array<_Tp>::value; |
1618 | #endif |
1619 | |
1620 | // decay |
1621 | |
1622 | template <class _Up, bool> |
1623 | struct __decay { |
1624 | typedef _LIBCPP_NODEBUG_TYPE__attribute__((nodebug)) typename remove_cv<_Up>::type type; |
1625 | }; |
1626 | |
1627 | template <class _Up> |
1628 | struct __decay<_Up, true> { |
1629 | public: |
1630 | typedef _LIBCPP_NODEBUG_TYPE__attribute__((nodebug)) typename conditional |
1631 | < |
1632 | is_array<_Up>::value, |
1633 | typename remove_extent<_Up>::type*, |
1634 | typename conditional |
1635 | < |
1636 | is_function<_Up>::value, |
1637 | typename add_pointer<_Up>::type, |
1638 | typename remove_cv<_Up>::type |
1639 | >::type |
1640 | >::type type; |
1641 | }; |
1642 | |
1643 | template <class _Tp> |
1644 | struct _LIBCPP_TEMPLATE_VIS__attribute__ ((__type_visibility__("default"))) decay |
1645 | { |
1646 | private: |
1647 | typedef _LIBCPP_NODEBUG_TYPE__attribute__((nodebug)) typename remove_reference<_Tp>::type _Up; |
1648 | public: |
1649 | typedef _LIBCPP_NODEBUG_TYPE__attribute__((nodebug)) typename __decay<_Up, __is_referenceable<_Up>::value>::type type; |
1650 | }; |
1651 | |
1652 | #if _LIBCPP_STD_VER14 > 11 |
1653 | template <class _Tp> using decay_t = typename decay<_Tp>::type; |
1654 | #endif |
1655 | |
1656 | // is_abstract |
1657 | |
1658 | template <class _Tp> struct _LIBCPP_TEMPLATE_VIS__attribute__ ((__type_visibility__("default"))) is_abstract |
1659 | : public integral_constant<bool, __is_abstract(_Tp)> {}; |
1660 | |
1661 | #if _LIBCPP_STD_VER14 > 14 && !defined(_LIBCPP_HAS_NO_VARIABLE_TEMPLATES) |
1662 | template <class _Tp> |
1663 | _LIBCPP_INLINE_VAR _LIBCPP_CONSTEXPRconstexpr bool is_abstract_v |
1664 | = is_abstract<_Tp>::value; |
1665 | #endif |
1666 | |
1667 | // is_final |
1668 | |
1669 | template <class _Tp> struct _LIBCPP_TEMPLATE_VIS__attribute__ ((__type_visibility__("default"))) |
1670 | __libcpp_is_final : public integral_constant<bool, __is_final(_Tp)> {}; |
1671 | |
1672 | #if _LIBCPP_STD_VER14 > 11 |
1673 | template <class _Tp> struct _LIBCPP_TEMPLATE_VIS__attribute__ ((__type_visibility__("default"))) |
1674 | is_final : public integral_constant<bool, __is_final(_Tp)> {}; |
1675 | #endif |
1676 | |
1677 | #if _LIBCPP_STD_VER14 > 14 && !defined(_LIBCPP_HAS_NO_VARIABLE_TEMPLATES) |
1678 | template <class _Tp> |
1679 | _LIBCPP_INLINE_VAR _LIBCPP_CONSTEXPRconstexpr bool is_final_v |
1680 | = is_final<_Tp>::value; |
1681 | #endif |
1682 | |
1683 | // is_aggregate |
1684 | #if _LIBCPP_STD_VER14 > 14 && !defined(_LIBCPP_HAS_NO_IS_AGGREGATE) |
1685 | |
1686 | template <class _Tp> struct _LIBCPP_TEMPLATE_VIS__attribute__ ((__type_visibility__("default"))) |
1687 | is_aggregate : public integral_constant<bool, __is_aggregate(_Tp)> {}; |
1688 | |
1689 | #if !defined(_LIBCPP_HAS_NO_VARIABLE_TEMPLATES) |
1690 | template <class _Tp> |
1691 | _LIBCPP_INLINE_VAR constexpr bool is_aggregate_v |
1692 | = is_aggregate<_Tp>::value; |
1693 | #endif |
1694 | |
1695 | #endif // _LIBCPP_STD_VER > 14 && !defined(_LIBCPP_HAS_NO_IS_AGGREGATE) |
1696 | |
1697 | // is_base_of |
1698 | |
1699 | template <class _Bp, class _Dp> |
1700 | struct _LIBCPP_TEMPLATE_VIS__attribute__ ((__type_visibility__("default"))) is_base_of |
1701 | : public integral_constant<bool, __is_base_of(_Bp, _Dp)> {}; |
1702 | |
1703 | #if _LIBCPP_STD_VER14 > 14 && !defined(_LIBCPP_HAS_NO_VARIABLE_TEMPLATES) |
1704 | template <class _Bp, class _Dp> |
1705 | _LIBCPP_INLINE_VAR _LIBCPP_CONSTEXPRconstexpr bool is_base_of_v |
1706 | = is_base_of<_Bp, _Dp>::value; |
1707 | #endif |
1708 | |
1709 | // __is_core_convertible |
1710 | |
1711 | // [conv.general]/3 says "E is convertible to T" whenever "T t=E;" is well-formed. |
1712 | // We can't test for that, but we can test implicit convertibility by passing it |
1713 | // to a function. Notice that __is_core_convertible<void,void> is false, |
1714 | // and __is_core_convertible<immovable-type,immovable-type> is true in C++17 and later. |
1715 | |
1716 | template <class _Tp, class _Up, class = void> |
1717 | struct __is_core_convertible : public false_type {}; |
1718 | |
1719 | template <class _Tp, class _Up> |
1720 | struct __is_core_convertible<_Tp, _Up, decltype( |
1721 | static_cast<void(*)(_Up)>(0) ( static_cast<_Tp(*)()>(0)() ) |
1722 | )> : public true_type {}; |
1723 | |
1724 | // is_convertible |
1725 | |
1726 | #if __has_feature(is_convertible_to)1 && !defined(_LIBCPP_USE_IS_CONVERTIBLE_FALLBACK) |
1727 | |
1728 | template <class _T1, class _T2> struct _LIBCPP_TEMPLATE_VIS__attribute__ ((__type_visibility__("default"))) is_convertible |
1729 | : public integral_constant<bool, __is_convertible_to(_T1, _T2)> {}; |
1730 | |
1731 | #else // __has_feature(is_convertible_to) |
1732 | |
1733 | namespace __is_convertible_imp |
1734 | { |
1735 | template <class _Tp> void __test_convert(_Tp); |
1736 | |
1737 | template <class _From, class _To, class = void> |
1738 | struct __is_convertible_test : public false_type {}; |
1739 | |
1740 | template <class _From, class _To> |
1741 | struct __is_convertible_test<_From, _To, |
1742 | decltype(__is_convertible_imp::__test_convert<_To>(declval<_From>()))> : public true_type |
1743 | {}; |
1744 | |
1745 | template <class _Tp, bool _IsArray = is_array<_Tp>::value, |
1746 | bool _IsFunction = is_function<_Tp>::value, |
1747 | bool _IsVoid = is_void<_Tp>::value> |
1748 | struct __is_array_function_or_void {enum {value = 0};}; |
1749 | template <class _Tp> struct __is_array_function_or_void<_Tp, true, false, false> {enum {value = 1};}; |
1750 | template <class _Tp> struct __is_array_function_or_void<_Tp, false, true, false> {enum {value = 2};}; |
1751 | template <class _Tp> struct __is_array_function_or_void<_Tp, false, false, true> {enum {value = 3};}; |
1752 | } |
1753 | |
1754 | template <class _Tp, |
1755 | unsigned = __is_convertible_imp::__is_array_function_or_void<typename remove_reference<_Tp>::type>::value> |
1756 | struct __is_convertible_check |
1757 | { |
1758 | static const size_t __v = 0; |
1759 | }; |
1760 | |
1761 | template <class _Tp> |
1762 | struct __is_convertible_check<_Tp, 0> |
1763 | { |
1764 | static const size_t __v = sizeof(_Tp); |
1765 | }; |
1766 | |
1767 | template <class _T1, class _T2, |
1768 | unsigned _T1_is_array_function_or_void = __is_convertible_imp::__is_array_function_or_void<_T1>::value, |
1769 | unsigned _T2_is_array_function_or_void = __is_convertible_imp::__is_array_function_or_void<_T2>::value> |
1770 | struct __is_convertible |
1771 | : public integral_constant<bool, |
1772 | __is_convertible_imp::__is_convertible_test<_T1, _T2>::value |
1773 | > |
1774 | {}; |
1775 | |
1776 | template <class _T1, class _T2> struct __is_convertible<_T1, _T2, 0, 1> : public false_type {}; |
1777 | template <class _T1, class _T2> struct __is_convertible<_T1, _T2, 1, 1> : public false_type {}; |
1778 | template <class _T1, class _T2> struct __is_convertible<_T1, _T2, 2, 1> : public false_type {}; |
1779 | template <class _T1, class _T2> struct __is_convertible<_T1, _T2, 3, 1> : public false_type {}; |
1780 | |
1781 | template <class _T1, class _T2> struct __is_convertible<_T1, _T2, 0, 2> : public false_type {}; |
1782 | template <class _T1, class _T2> struct __is_convertible<_T1, _T2, 1, 2> : public false_type {}; |
1783 | template <class _T1, class _T2> struct __is_convertible<_T1, _T2, 2, 2> : public false_type {}; |
1784 | template <class _T1, class _T2> struct __is_convertible<_T1, _T2, 3, 2> : public false_type {}; |
1785 | |
1786 | template <class _T1, class _T2> struct __is_convertible<_T1, _T2, 0, 3> : public false_type {}; |
1787 | template <class _T1, class _T2> struct __is_convertible<_T1, _T2, 1, 3> : public false_type {}; |
1788 | template <class _T1, class _T2> struct __is_convertible<_T1, _T2, 2, 3> : public false_type {}; |
1789 | template <class _T1, class _T2> struct __is_convertible<_T1, _T2, 3, 3> : public true_type {}; |
1790 | |
1791 | template <class _T1, class _T2> struct _LIBCPP_TEMPLATE_VIS__attribute__ ((__type_visibility__("default"))) is_convertible |
1792 | : public __is_convertible<_T1, _T2> |
1793 | { |
1794 | static const size_t __complete_check1 = __is_convertible_check<_T1>::__v; |
1795 | static const size_t __complete_check2 = __is_convertible_check<_T2>::__v; |
1796 | }; |
1797 | |
1798 | #endif // __has_feature(is_convertible_to) |
1799 | |
1800 | #if _LIBCPP_STD_VER14 > 14 && !defined(_LIBCPP_HAS_NO_VARIABLE_TEMPLATES) |
1801 | template <class _From, class _To> |
1802 | _LIBCPP_INLINE_VAR _LIBCPP_CONSTEXPRconstexpr bool is_convertible_v |
1803 | = is_convertible<_From, _To>::value; |
1804 | #endif |
1805 | |
1806 | // is_nothrow_convertible |
1807 | |
1808 | #if _LIBCPP_STD_VER14 > 17 |
1809 | |
1810 | template <typename _Tp> |
1811 | static void __test_noexcept(_Tp) noexcept; |
1812 | |
1813 | template<typename _Fm, typename _To> |
1814 | static bool_constant<noexcept(_VSTDstd::__1::__test_noexcept<_To>(declval<_Fm>()))> |
1815 | __is_nothrow_convertible_test(); |
1816 | |
1817 | template <typename _Fm, typename _To> |
1818 | struct __is_nothrow_convertible_helper: decltype(__is_nothrow_convertible_test<_Fm, _To>()) |
1819 | { }; |
1820 | |
1821 | template <typename _Fm, typename _To> |
1822 | struct is_nothrow_convertible : _Or< |
1823 | _And<is_void<_To>, is_void<_Fm>>, |
1824 | _Lazy<_And, is_convertible<_Fm, _To>, __is_nothrow_convertible_helper<_Fm, _To>> |
1825 | >::type { }; |
1826 | |
1827 | template <typename _Fm, typename _To> |
1828 | inline constexpr bool is_nothrow_convertible_v = is_nothrow_convertible<_Fm, _To>::value; |
1829 | |
1830 | #endif // _LIBCPP_STD_VER > 17 |
1831 | |
1832 | // is_empty |
1833 | |
1834 | #if __has_feature(is_empty)1 || defined(_LIBCPP_COMPILER_GCC) |
1835 | |
1836 | template <class _Tp> |
1837 | struct _LIBCPP_TEMPLATE_VIS__attribute__ ((__type_visibility__("default"))) is_empty |
1838 | : public integral_constant<bool, __is_empty(_Tp)> {}; |
1839 | |
1840 | #else // __has_feature(is_empty) |
1841 | |
1842 | template <class _Tp> |
1843 | struct __is_empty1 |
1844 | : public _Tp |
1845 | { |
1846 | double __lx; |
1847 | }; |
1848 | |
1849 | struct __is_empty2 |
1850 | { |
1851 | double __lx; |
1852 | }; |
1853 | |
1854 | template <class _Tp, bool = is_class<_Tp>::value> |
1855 | struct __libcpp_empty : public integral_constant<bool, sizeof(__is_empty1<_Tp>) == sizeof(__is_empty2)> {}; |
1856 | |
1857 | template <class _Tp> struct __libcpp_empty<_Tp, false> : public false_type {}; |
1858 | |
1859 | template <class _Tp> struct _LIBCPP_TEMPLATE_VIS__attribute__ ((__type_visibility__("default"))) is_empty : public __libcpp_empty<_Tp> {}; |
1860 | |
1861 | #endif // __has_feature(is_empty) |
1862 | |
1863 | #if _LIBCPP_STD_VER14 > 14 && !defined(_LIBCPP_HAS_NO_VARIABLE_TEMPLATES) |
1864 | template <class _Tp> |
1865 | _LIBCPP_INLINE_VAR _LIBCPP_CONSTEXPRconstexpr bool is_empty_v |
1866 | = is_empty<_Tp>::value; |
1867 | #endif |
1868 | |
1869 | // is_polymorphic |
1870 | |
1871 | #if __has_feature(is_polymorphic)1 || defined(_LIBCPP_COMPILER_MSVC) |
1872 | |
1873 | template <class _Tp> |
1874 | struct _LIBCPP_TEMPLATE_VIS__attribute__ ((__type_visibility__("default"))) is_polymorphic |
1875 | : public integral_constant<bool, __is_polymorphic(_Tp)> {}; |
1876 | |
1877 | #else |
1878 | |
1879 | template<typename _Tp> char &__is_polymorphic_impl( |
1880 | typename enable_if<sizeof((_Tp*)dynamic_cast<const volatile void*>(declval<_Tp*>())) != 0, |
1881 | int>::type); |
1882 | template<typename _Tp> __two &__is_polymorphic_impl(...); |
1883 | |
1884 | template <class _Tp> struct _LIBCPP_TEMPLATE_VIS__attribute__ ((__type_visibility__("default"))) is_polymorphic |
1885 | : public integral_constant<bool, sizeof(__is_polymorphic_impl<_Tp>(0)) == 1> {}; |
1886 | |
1887 | #endif // __has_feature(is_polymorphic) |
1888 | |
1889 | #if _LIBCPP_STD_VER14 > 14 && !defined(_LIBCPP_HAS_NO_VARIABLE_TEMPLATES) |
1890 | template <class _Tp> |
1891 | _LIBCPP_INLINE_VAR _LIBCPP_CONSTEXPRconstexpr bool is_polymorphic_v |
1892 | = is_polymorphic<_Tp>::value; |
1893 | #endif |
1894 | |
1895 | // has_virtual_destructor |
1896 | |
1897 | #if __has_feature(has_virtual_destructor)1 || defined(_LIBCPP_COMPILER_GCC) |
1898 | |
1899 | template <class _Tp> struct _LIBCPP_TEMPLATE_VIS__attribute__ ((__type_visibility__("default"))) has_virtual_destructor |
1900 | : public integral_constant<bool, __has_virtual_destructor(_Tp)> {}; |
1901 | |
1902 | #else |
1903 | |
1904 | template <class _Tp> struct _LIBCPP_TEMPLATE_VIS__attribute__ ((__type_visibility__("default"))) has_virtual_destructor |
1905 | : public false_type {}; |
1906 | |
1907 | #endif |
1908 | |
1909 | #if _LIBCPP_STD_VER14 > 14 && !defined(_LIBCPP_HAS_NO_VARIABLE_TEMPLATES) |
1910 | template <class _Tp> |
1911 | _LIBCPP_INLINE_VAR _LIBCPP_CONSTEXPRconstexpr bool has_virtual_destructor_v |
1912 | = has_virtual_destructor<_Tp>::value; |
1913 | #endif |
1914 | |
1915 | // has_unique_object_representations |
1916 | |
1917 | #if _LIBCPP_STD_VER14 > 14 && defined(_LIBCPP_HAS_UNIQUE_OBJECT_REPRESENTATIONS) |
1918 | |
1919 | template <class _Tp> struct _LIBCPP_TEMPLATE_VIS__attribute__ ((__type_visibility__("default"))) has_unique_object_representations |
1920 | : public integral_constant<bool, |
1921 | __has_unique_object_representations(remove_cv_t<remove_all_extents_t<_Tp>>)> {}; |
1922 | |
1923 | #if !defined(_LIBCPP_HAS_NO_VARIABLE_TEMPLATES) |
1924 | template <class _Tp> |
1925 | _LIBCPP_INLINE_VAR _LIBCPP_CONSTEXPRconstexpr bool has_unique_object_representations_v |
1926 | = has_unique_object_representations<_Tp>::value; |
1927 | #endif |
1928 | |
1929 | #endif |
1930 | |
1931 | // alignment_of |
1932 | |
1933 | template <class _Tp> struct _LIBCPP_TEMPLATE_VIS__attribute__ ((__type_visibility__("default"))) alignment_of |
1934 | : public integral_constant<size_t, _LIBCPP_ALIGNOF(_Tp)alignof(_Tp)> {}; |
1935 | |
1936 | #if _LIBCPP_STD_VER14 > 14 && !defined(_LIBCPP_HAS_NO_VARIABLE_TEMPLATES) |
1937 | template <class _Tp> |
1938 | _LIBCPP_INLINE_VAR _LIBCPP_CONSTEXPRconstexpr size_t alignment_of_v |
1939 | = alignment_of<_Tp>::value; |
1940 | #endif |
1941 | |
1942 | // aligned_storage |
1943 | |
1944 | template <class _Hp, class _Tp> |
1945 | struct __type_list |
1946 | { |
1947 | typedef _Hp _Head; |
1948 | typedef _Tp _Tail; |
1949 | }; |
1950 | |
1951 | struct __nat |
1952 | { |
1953 | #ifndef _LIBCPP_CXX03_LANG |
1954 | __nat() = delete; |
1955 | __nat(const __nat&) = delete; |
1956 | __nat& operator=(const __nat&) = delete; |
1957 | ~__nat() = delete; |
1958 | #endif |
1959 | }; |
1960 | |
1961 | template <class _Tp> |
1962 | struct __align_type |
1963 | { |
1964 | static const size_t value = _LIBCPP_PREFERRED_ALIGNOF(_Tp)__alignof(_Tp); |
1965 | typedef _Tp type; |
1966 | }; |
1967 | |
1968 | struct __struct_double {long double __lx;}; |
1969 | struct __struct_double4 {double __lx[4];}; |
1970 | |
1971 | typedef |
1972 | __type_list<__align_type<unsigned char>, |
1973 | __type_list<__align_type<unsigned short>, |
1974 | __type_list<__align_type<unsigned int>, |
1975 | __type_list<__align_type<unsigned long>, |
1976 | __type_list<__align_type<unsigned long long>, |
1977 | __type_list<__align_type<double>, |
1978 | __type_list<__align_type<long double>, |
1979 | __type_list<__align_type<__struct_double>, |
1980 | __type_list<__align_type<__struct_double4>, |
1981 | __type_list<__align_type<int*>, |
1982 | __nat |
1983 | > > > > > > > > > > __all_types; |
1984 | |
1985 | template <size_t _Align> |
1986 | struct _ALIGNAS(_Align)alignas(_Align) __fallback_overaligned {}; |
1987 | |
1988 | template <class _TL, size_t _Align> struct __find_pod; |
1989 | |
1990 | template <class _Hp, size_t _Align> |
1991 | struct __find_pod<__type_list<_Hp, __nat>, _Align> |
1992 | { |
1993 | typedef typename conditional< |
1994 | _Align == _Hp::value, |
1995 | typename _Hp::type, |
1996 | __fallback_overaligned<_Align> |
1997 | >::type type; |
1998 | }; |
1999 | |
2000 | template <class _Hp, class _Tp, size_t _Align> |
2001 | struct __find_pod<__type_list<_Hp, _Tp>, _Align> |
2002 | { |
2003 | typedef typename conditional< |
2004 | _Align == _Hp::value, |
2005 | typename _Hp::type, |
2006 | typename __find_pod<_Tp, _Align>::type |
2007 | >::type type; |
2008 | }; |
2009 | |
2010 | template <class _TL, size_t _Len> struct __find_max_align; |
2011 | |
2012 | template <class _Hp, size_t _Len> |
2013 | struct __find_max_align<__type_list<_Hp, __nat>, _Len> : public integral_constant<size_t, _Hp::value> {}; |
2014 | |
2015 | template <size_t _Len, size_t _A1, size_t _A2> |
2016 | struct __select_align |
2017 | { |
2018 | private: |
2019 | static const size_t __min = _A2 < _A1 ? _A2 : _A1; |
2020 | static const size_t __max = _A1 < _A2 ? _A2 : _A1; |
2021 | public: |
2022 | static const size_t value = _Len < __max ? __min : __max; |
2023 | }; |
2024 | |
2025 | template <class _Hp, class _Tp, size_t _Len> |
2026 | struct __find_max_align<__type_list<_Hp, _Tp>, _Len> |
2027 | : public integral_constant<size_t, __select_align<_Len, _Hp::value, __find_max_align<_Tp, _Len>::value>::value> {}; |
2028 | |
2029 | template <size_t _Len, size_t _Align = __find_max_align<__all_types, _Len>::value> |
2030 | struct _LIBCPP_TEMPLATE_VIS__attribute__ ((__type_visibility__("default"))) aligned_storage |
2031 | { |
2032 | typedef typename __find_pod<__all_types, _Align>::type _Aligner; |
2033 | union type |
2034 | { |
2035 | _Aligner __align; |
2036 | unsigned char __data[(_Len + _Align - 1)/_Align * _Align]; |
2037 | }; |
2038 | }; |
2039 | |
2040 | #if _LIBCPP_STD_VER14 > 11 |
2041 | template <size_t _Len, size_t _Align = __find_max_align<__all_types, _Len>::value> |
2042 | using aligned_storage_t = typename aligned_storage<_Len, _Align>::type; |
2043 | #endif |
2044 | |
2045 | #define _CREATE_ALIGNED_STORAGE_SPECIALIZATION(n) \ |
2046 | template <size_t _Len>\ |
2047 | struct _LIBCPP_TEMPLATE_VIS__attribute__ ((__type_visibility__("default"))) aligned_storage<_Len, n>\ |
2048 | {\ |
2049 | struct _ALIGNAS(n)alignas(n) type\ |
2050 | {\ |
2051 | unsigned char __lx[(_Len + n - 1)/n * n];\ |
2052 | };\ |
2053 | } |
2054 | |
2055 | _CREATE_ALIGNED_STORAGE_SPECIALIZATION(0x1); |
2056 | _CREATE_ALIGNED_STORAGE_SPECIALIZATION(0x2); |
2057 | _CREATE_ALIGNED_STORAGE_SPECIALIZATION(0x4); |
2058 | _CREATE_ALIGNED_STORAGE_SPECIALIZATION(0x8); |
2059 | _CREATE_ALIGNED_STORAGE_SPECIALIZATION(0x10); |
2060 | _CREATE_ALIGNED_STORAGE_SPECIALIZATION(0x20); |
2061 | _CREATE_ALIGNED_STORAGE_SPECIALIZATION(0x40); |
2062 | _CREATE_ALIGNED_STORAGE_SPECIALIZATION(0x80); |
2063 | _CREATE_ALIGNED_STORAGE_SPECIALIZATION(0x100); |
2064 | _CREATE_ALIGNED_STORAGE_SPECIALIZATION(0x200); |
2065 | _CREATE_ALIGNED_STORAGE_SPECIALIZATION(0x400); |
2066 | _CREATE_ALIGNED_STORAGE_SPECIALIZATION(0x800); |
2067 | _CREATE_ALIGNED_STORAGE_SPECIALIZATION(0x1000); |
2068 | _CREATE_ALIGNED_STORAGE_SPECIALIZATION(0x2000); |
2069 | // PE/COFF does not support alignment beyond 8192 (=0x2000) |
2070 | #if !defined(_LIBCPP_OBJECT_FORMAT_COFF) |
2071 | _CREATE_ALIGNED_STORAGE_SPECIALIZATION(0x4000); |
2072 | #endif // !defined(_LIBCPP_OBJECT_FORMAT_COFF) |
2073 | |
2074 | #undef _CREATE_ALIGNED_STORAGE_SPECIALIZATION |
2075 | |
2076 | |
2077 | // aligned_union |
2078 | |
2079 | template <size_t _I0, size_t ..._In> |
2080 | struct __static_max; |
2081 | |
2082 | template <size_t _I0> |
2083 | struct __static_max<_I0> |
2084 | { |
2085 | static const size_t value = _I0; |
2086 | }; |
2087 | |
2088 | template <size_t _I0, size_t _I1, size_t ..._In> |
2089 | struct __static_max<_I0, _I1, _In...> |
2090 | { |
2091 | static const size_t value = _I0 >= _I1 ? __static_max<_I0, _In...>::value : |
2092 | __static_max<_I1, _In...>::value; |
2093 | }; |
2094 | |
2095 | template <size_t _Len, class _Type0, class ..._Types> |
2096 | struct aligned_union |
2097 | { |
2098 | static const size_t alignment_value = __static_max<_LIBCPP_PREFERRED_ALIGNOF(_Type0)__alignof(_Type0), |
2099 | _LIBCPP_PREFERRED_ALIGNOF(_Types)__alignof(_Types)...>::value; |
2100 | static const size_t __len = __static_max<_Len, sizeof(_Type0), |
2101 | sizeof(_Types)...>::value; |
2102 | typedef typename aligned_storage<__len, alignment_value>::type type; |
2103 | }; |
2104 | |
2105 | #if _LIBCPP_STD_VER14 > 11 |
2106 | template <size_t _Len, class ..._Types> using aligned_union_t = typename aligned_union<_Len, _Types...>::type; |
2107 | #endif |
2108 | |
2109 | template <class _Tp> |
2110 | struct __numeric_type |
2111 | { |
2112 | static void __test(...); |
2113 | static float __test(float); |
2114 | static double __test(char); |
2115 | static double __test(int); |
2116 | static double __test(unsigned); |
2117 | static double __test(long); |
2118 | static double __test(unsigned long); |
2119 | static double __test(long long); |
2120 | static double __test(unsigned long long); |
2121 | static double __test(double); |
2122 | static long double __test(long double); |
2123 | |
2124 | typedef decltype(__test(declval<_Tp>())) type; |
2125 | static const bool value = _IsNotSame<type, void>::value; |
2126 | }; |
2127 | |
2128 | template <> |
2129 | struct __numeric_type<void> |
2130 | { |
2131 | static const bool value = true; |
2132 | }; |
2133 | |
2134 | // __promote |
2135 | |
2136 | template <class _A1, class _A2 = void, class _A3 = void, |
2137 | bool = __numeric_type<_A1>::value && |
2138 | __numeric_type<_A2>::value && |
2139 | __numeric_type<_A3>::value> |
2140 | class __promote_imp |
2141 | { |
2142 | public: |
2143 | static const bool value = false; |
2144 | }; |
2145 | |
2146 | template <class _A1, class _A2, class _A3> |
2147 | class __promote_imp<_A1, _A2, _A3, true> |
2148 | { |
2149 | private: |
2150 | typedef typename __promote_imp<_A1>::type __type1; |
2151 | typedef typename __promote_imp<_A2>::type __type2; |
2152 | typedef typename __promote_imp<_A3>::type __type3; |
2153 | public: |
2154 | typedef decltype(__type1() + __type2() + __type3()) type; |
2155 | static const bool value = true; |
2156 | }; |
2157 | |
2158 | template <class _A1, class _A2> |
2159 | class __promote_imp<_A1, _A2, void, true> |
2160 | { |
2161 | private: |
2162 | typedef typename __promote_imp<_A1>::type __type1; |
2163 | typedef typename __promote_imp<_A2>::type __type2; |
2164 | public: |
2165 | typedef decltype(__type1() + __type2()) type; |
2166 | static const bool value = true; |
2167 | }; |
2168 | |
2169 | template <class _A1> |
2170 | class __promote_imp<_A1, void, void, true> |
2171 | { |
2172 | public: |
2173 | typedef typename __numeric_type<_A1>::type type; |
2174 | static const bool value = true; |
2175 | }; |
2176 | |
2177 | template <class _A1, class _A2 = void, class _A3 = void> |
2178 | class __promote : public __promote_imp<_A1, _A2, _A3> {}; |
2179 | |
2180 | // make_signed / make_unsigned |
2181 | |
2182 | typedef |
2183 | __type_list<signed char, |
2184 | __type_list<signed short, |
2185 | __type_list<signed int, |
2186 | __type_list<signed long, |
2187 | __type_list<signed long long, |
2188 | #ifndef _LIBCPP_HAS_NO_INT128 |
2189 | __type_list<__int128_t, |
2190 | #endif |
2191 | __nat |
2192 | #ifndef _LIBCPP_HAS_NO_INT128 |
2193 | > |
2194 | #endif |
2195 | > > > > > __signed_types; |
2196 | |
2197 | typedef |
2198 | __type_list<unsigned char, |
2199 | __type_list<unsigned short, |
2200 | __type_list<unsigned int, |
2201 | __type_list<unsigned long, |
2202 | __type_list<unsigned long long, |
2203 | #ifndef _LIBCPP_HAS_NO_INT128 |
2204 | __type_list<__uint128_t, |
2205 | #endif |
2206 | __nat |
2207 | #ifndef _LIBCPP_HAS_NO_INT128 |
2208 | > |
2209 | #endif |
2210 | > > > > > __unsigned_types; |
2211 | |
2212 | template <class _TypeList, size_t _Size, bool = _Size <= sizeof(typename _TypeList::_Head)> struct __find_first; |
2213 | |
2214 | template <class _Hp, class _Tp, size_t _Size> |
2215 | struct __find_first<__type_list<_Hp, _Tp>, _Size, true> |
2216 | { |
2217 | typedef _LIBCPP_NODEBUG_TYPE__attribute__((nodebug)) _Hp type; |
2218 | }; |
2219 | |
2220 | template <class _Hp, class _Tp, size_t _Size> |
2221 | struct __find_first<__type_list<_Hp, _Tp>, _Size, false> |
2222 | { |
2223 | typedef _LIBCPP_NODEBUG_TYPE__attribute__((nodebug)) typename __find_first<_Tp, _Size>::type type; |
2224 | }; |
2225 | |
2226 | template <class _Tp, class _Up, bool = is_const<typename remove_reference<_Tp>::type>::value, |
2227 | bool = is_volatile<typename remove_reference<_Tp>::type>::value> |
2228 | struct __apply_cv |
2229 | { |
2230 | typedef _LIBCPP_NODEBUG_TYPE__attribute__((nodebug)) _Up type; |
2231 | }; |
2232 | |
2233 | template <class _Tp, class _Up> |
2234 | struct __apply_cv<_Tp, _Up, true, false> |
2235 | { |
2236 | typedef _LIBCPP_NODEBUG_TYPE__attribute__((nodebug)) const _Up type; |
2237 | }; |
2238 | |
2239 | template <class _Tp, class _Up> |
2240 | struct __apply_cv<_Tp, _Up, false, true> |
2241 | { |
2242 | typedef volatile _Up type; |
2243 | }; |
2244 | |
2245 | template <class _Tp, class _Up> |
2246 | struct __apply_cv<_Tp, _Up, true, true> |
2247 | { |
2248 | typedef const volatile _Up type; |
2249 | }; |
2250 | |
2251 | template <class _Tp, class _Up> |
2252 | struct __apply_cv<_Tp&, _Up, false, false> |
2253 | { |
2254 | typedef _Up& type; |
2255 | }; |
2256 | |
2257 | template <class _Tp, class _Up> |
2258 | struct __apply_cv<_Tp&, _Up, true, false> |
2259 | { |
2260 | typedef const _Up& type; |
2261 | }; |
2262 | |
2263 | template <class _Tp, class _Up> |
2264 | struct __apply_cv<_Tp&, _Up, false, true> |
2265 | { |
2266 | typedef volatile _Up& type; |
2267 | }; |
2268 | |
2269 | template <class _Tp, class _Up> |
2270 | struct __apply_cv<_Tp&, _Up, true, true> |
2271 | { |
2272 | typedef const volatile _Up& type; |
2273 | }; |
2274 | |
2275 | template <class _Tp, bool = is_integral<_Tp>::value || is_enum<_Tp>::value> |
2276 | struct __make_signed {}; |
2277 | |
2278 | template <class _Tp> |
2279 | struct __make_signed<_Tp, true> |
2280 | { |
2281 | typedef typename __find_first<__signed_types, sizeof(_Tp)>::type type; |
2282 | }; |
2283 | |
2284 | template <> struct __make_signed<bool, true> {}; |
2285 | template <> struct __make_signed< signed short, true> {typedef short type;}; |
2286 | template <> struct __make_signed<unsigned short, true> {typedef short type;}; |
2287 | template <> struct __make_signed< signed int, true> {typedef int type;}; |
2288 | template <> struct __make_signed<unsigned int, true> {typedef int type;}; |
2289 | template <> struct __make_signed< signed long, true> {typedef long type;}; |
2290 | template <> struct __make_signed<unsigned long, true> {typedef long type;}; |
2291 | template <> struct __make_signed< signed long long, true> {typedef long long type;}; |
2292 | template <> struct __make_signed<unsigned long long, true> {typedef long long type;}; |
2293 | #ifndef _LIBCPP_HAS_NO_INT128 |
2294 | template <> struct __make_signed<__int128_t, true> {typedef __int128_t type;}; |
2295 | template <> struct __make_signed<__uint128_t, true> {typedef __int128_t type;}; |
2296 | #endif |
2297 | |
2298 | template <class _Tp> |
2299 | struct _LIBCPP_TEMPLATE_VIS__attribute__ ((__type_visibility__("default"))) make_signed |
2300 | { |
2301 | typedef typename __apply_cv<_Tp, typename __make_signed<typename remove_cv<_Tp>::type>::type>::type type; |
2302 | }; |
2303 | |
2304 | #if _LIBCPP_STD_VER14 > 11 |
2305 | template <class _Tp> using make_signed_t = typename make_signed<_Tp>::type; |
2306 | #endif |
2307 | |
2308 | template <class _Tp, bool = is_integral<_Tp>::value || is_enum<_Tp>::value> |
2309 | struct __make_unsigned {}; |
2310 | |
2311 | template <class _Tp> |
2312 | struct __make_unsigned<_Tp, true> |
2313 | { |
2314 | typedef typename __find_first<__unsigned_types, sizeof(_Tp)>::type type; |
2315 | }; |
2316 | |
2317 | template <> struct __make_unsigned<bool, true> {}; |
2318 | template <> struct __make_unsigned< signed short, true> {typedef unsigned short type;}; |
2319 | template <> struct __make_unsigned<unsigned short, true> {typedef unsigned short type;}; |
2320 | template <> struct __make_unsigned< signed int, true> {typedef unsigned int type;}; |
2321 | template <> struct __make_unsigned<unsigned int, true> {typedef unsigned int type;}; |
2322 | template <> struct __make_unsigned< signed long, true> {typedef unsigned long type;}; |
2323 | template <> struct __make_unsigned<unsigned long, true> {typedef unsigned long type;}; |
2324 | template <> struct __make_unsigned< signed long long, true> {typedef unsigned long long type;}; |
2325 | template <> struct __make_unsigned<unsigned long long, true> {typedef unsigned long long type;}; |
2326 | #ifndef _LIBCPP_HAS_NO_INT128 |
2327 | template <> struct __make_unsigned<__int128_t, true> {typedef __uint128_t type;}; |
2328 | template <> struct __make_unsigned<__uint128_t, true> {typedef __uint128_t type;}; |
2329 | #endif |
2330 | |
2331 | template <class _Tp> |
2332 | struct _LIBCPP_TEMPLATE_VIS__attribute__ ((__type_visibility__("default"))) make_unsigned |
2333 | { |
2334 | typedef typename __apply_cv<_Tp, typename __make_unsigned<typename remove_cv<_Tp>::type>::type>::type type; |
2335 | }; |
2336 | |
2337 | #if _LIBCPP_STD_VER14 > 11 |
2338 | template <class _Tp> using make_unsigned_t = typename make_unsigned<_Tp>::type; |
2339 | #endif |
2340 | |
2341 | #ifndef _LIBCPP_CXX03_LANG |
2342 | template <class _Tp> |
2343 | _LIBCPP_NODISCARD_ATTRIBUTE[[nodiscard]] _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__ )) constexpr |
2344 | typename make_unsigned<_Tp>::type __to_unsigned_like(_Tp __x) noexcept { |
2345 | return static_cast<typename make_unsigned<_Tp>::type>(__x); |
2346 | } |
2347 | #endif |
2348 | |
2349 | #if _LIBCPP_STD_VER14 > 14 |
2350 | template <class...> using void_t = void; |
2351 | #endif |
2352 | |
2353 | #if _LIBCPP_STD_VER14 > 17 |
2354 | // Let COND_RES(X, Y) be: |
2355 | template <class _Tp, class _Up> |
2356 | using __cond_type = decltype(false ? declval<_Tp>() : declval<_Up>()); |
2357 | |
2358 | template <class _Tp, class _Up, class = void> |
2359 | struct __common_type3 {}; |
2360 | |
2361 | // sub-bullet 4 - "if COND_RES(CREF(D1), CREF(D2)) denotes a type..." |
2362 | template <class _Tp, class _Up> |
2363 | struct __common_type3<_Tp, _Up, void_t<__cond_type<const _Tp&, const _Up&>>> |
2364 | { |
2365 | using type = remove_cvref_t<__cond_type<const _Tp&, const _Up&>>; |
2366 | }; |
2367 | |
2368 | template <class _Tp, class _Up, class = void> |
2369 | struct __common_type2_imp : __common_type3<_Tp, _Up> {}; |
2370 | #else |
2371 | template <class _Tp, class _Up, class = void> |
2372 | struct __common_type2_imp {}; |
2373 | #endif |
2374 | |
2375 | // sub-bullet 3 - "if decay_t<decltype(false ? declval<D1>() : declval<D2>())> ..." |
2376 | template <class _Tp, class _Up> |
2377 | struct __common_type2_imp<_Tp, _Up, |
2378 | typename __void_t<decltype( |
2379 | true ? declval<_Tp>() : declval<_Up>() |
2380 | )>::type> |
2381 | { |
2382 | typedef _LIBCPP_NODEBUG_TYPE__attribute__((nodebug)) typename decay<decltype( |
2383 | true ? declval<_Tp>() : declval<_Up>() |
2384 | )>::type type; |
2385 | }; |
2386 | |
2387 | template <class, class = void> |
2388 | struct __common_type_impl {}; |
2389 | |
2390 | // Clang provides variadic templates in C++03 as an extension. |
2391 | #if !defined(_LIBCPP_CXX03_LANG) || defined(__clang__1) |
2392 | # define _LIBCPP_OPTIONAL_PACK(...) , __VA_ARGS__ |
2393 | template <class... Tp> |
2394 | struct __common_types; |
2395 | template <class... _Tp> |
2396 | struct _LIBCPP_TEMPLATE_VIS__attribute__ ((__type_visibility__("default"))) common_type; |
2397 | #else |
2398 | # define _LIBCPP_OPTIONAL_PACK(...) |
2399 | struct __no_arg; |
2400 | template <class _Tp, class _Up, class = __no_arg> |
2401 | struct __common_types; |
2402 | template <class _Tp = __no_arg, class _Up = __no_arg, class _Vp = __no_arg, |
2403 | class _Unused = __no_arg> |
2404 | struct common_type { |
2405 | static_assert(sizeof(_Unused) == 0, |
2406 | "common_type accepts at most 3 arguments in C++03"); |
2407 | }; |
2408 | #endif // _LIBCPP_CXX03_LANG |
2409 | |
2410 | template <class _Tp, class _Up> |
2411 | struct __common_type_impl< |
2412 | __common_types<_Tp, _Up>, |
2413 | typename __void_t<typename common_type<_Tp, _Up>::type>::type> |
2414 | { |
2415 | typedef typename common_type<_Tp, _Up>::type type; |
2416 | }; |
2417 | |
2418 | template <class _Tp, class _Up, class _Vp _LIBCPP_OPTIONAL_PACK(class... _Rest)> |
2419 | struct __common_type_impl< |
2420 | __common_types<_Tp, _Up, _Vp _LIBCPP_OPTIONAL_PACK(_Rest...)>, |
2421 | typename __void_t<typename common_type<_Tp, _Up>::type>::type> |
2422 | : __common_type_impl<__common_types<typename common_type<_Tp, _Up>::type, |
2423 | _Vp _LIBCPP_OPTIONAL_PACK(_Rest...)> > { |
2424 | }; |
2425 | |
2426 | // bullet 1 - sizeof...(Tp) == 0 |
2427 | |
2428 | template <> |
2429 | struct _LIBCPP_TEMPLATE_VIS__attribute__ ((__type_visibility__("default"))) common_type<> {}; |
2430 | |
2431 | // bullet 2 - sizeof...(Tp) == 1 |
2432 | |
2433 | template <class _Tp> |
2434 | struct _LIBCPP_TEMPLATE_VIS__attribute__ ((__type_visibility__("default"))) common_type<_Tp> |
2435 | : public common_type<_Tp, _Tp> {}; |
2436 | |
2437 | // bullet 3 - sizeof...(Tp) == 2 |
2438 | |
2439 | // sub-bullet 1 - "If is_same_v<T1, D1> is false or ..." |
2440 | template <class _Tp, class _Up> |
2441 | struct _LIBCPP_TEMPLATE_VIS__attribute__ ((__type_visibility__("default"))) common_type<_Tp, _Up> |
2442 | : conditional< |
2443 | _IsSame<_Tp, typename decay<_Tp>::type>::value && _IsSame<_Up, typename decay<_Up>::type>::value, |
2444 | __common_type2_imp<_Tp, _Up>, |
2445 | common_type<typename decay<_Tp>::type, typename decay<_Up>::type> |
2446 | >::type |
2447 | {}; |
2448 | |
2449 | // bullet 4 - sizeof...(Tp) > 2 |
2450 | |
2451 | template <class _Tp, class _Up, class _Vp _LIBCPP_OPTIONAL_PACK(class... _Rest)> |
2452 | struct _LIBCPP_TEMPLATE_VIS__attribute__ ((__type_visibility__("default"))) |
2453 | common_type<_Tp, _Up, _Vp _LIBCPP_OPTIONAL_PACK(_Rest...)> |
2454 | : __common_type_impl< |
2455 | __common_types<_Tp, _Up, _Vp _LIBCPP_OPTIONAL_PACK(_Rest...)> > {}; |
2456 | |
2457 | #undef _LIBCPP_OPTIONAL_PACK |
2458 | |
2459 | #if _LIBCPP_STD_VER14 > 11 |
2460 | template <class ..._Tp> using common_type_t = typename common_type<_Tp...>::type; |
2461 | #endif |
2462 | |
2463 | #if _LIBCPP_STD_VER14 > 11 |
2464 | // Let COPYCV(FROM, TO) be an alias for type TO with the addition of FROM's |
2465 | // top-level cv-qualifiers. |
2466 | template <class _From, class _To> |
2467 | struct __copy_cv |
2468 | { |
2469 | using type = _To; |
2470 | }; |
2471 | |
2472 | template <class _From, class _To> |
2473 | struct __copy_cv<const _From, _To> |
2474 | { |
2475 | using type = add_const_t<_To>; |
2476 | }; |
2477 | |
2478 | template <class _From, class _To> |
2479 | struct __copy_cv<volatile _From, _To> |
2480 | { |
2481 | using type = add_volatile_t<_To>; |
2482 | }; |
2483 | |
2484 | template <class _From, class _To> |
2485 | struct __copy_cv<const volatile _From, _To> |
2486 | { |
2487 | using type = add_cv_t<_To>; |
2488 | }; |
2489 | |
2490 | template <class _From, class _To> |
2491 | using __copy_cv_t = typename __copy_cv<_From, _To>::type; |
2492 | |
2493 | template <class _From, class _To> |
2494 | struct __copy_cvref |
2495 | { |
2496 | using type = __copy_cv_t<_From, _To>; |
2497 | }; |
2498 | |
2499 | template <class _From, class _To> |
2500 | struct __copy_cvref<_From&, _To> |
2501 | { |
2502 | using type = add_lvalue_reference_t<__copy_cv_t<_From, _To>>; |
2503 | }; |
2504 | |
2505 | template <class _From, class _To> |
2506 | struct __copy_cvref<_From&&, _To> |
2507 | { |
2508 | using type = add_rvalue_reference_t<__copy_cv_t<_From, _To>>; |
2509 | }; |
2510 | |
2511 | template <class _From, class _To> |
2512 | using __copy_cvref_t = typename __copy_cvref<_From, _To>::type; |
2513 | |
2514 | #endif // _LIBCPP_STD_VER > 11 |
2515 | |
2516 | // common_reference |
2517 | #if _LIBCPP_STD_VER14 > 17 && !defined(_LIBCPP_HAS_NO_CONCEPTS) |
2518 | // Let COND_RES(X, Y) be: |
2519 | template <class _Xp, class _Yp> |
2520 | using __cond_res = |
2521 | decltype(false ? declval<_Xp(&)()>()() : declval<_Yp(&)()>()()); |
2522 | |
2523 | // Let `XREF(A)` denote a unary alias template `T` such that `T<U>` denotes the same type as `U` |
2524 | // with the addition of `A`'s cv and reference qualifiers, for a non-reference cv-unqualified type |
2525 | // `U`. |
2526 | // [Note: `XREF(A)` is `__xref<A>::template __apply`] |
2527 | template <class _Tp> |
2528 | struct __xref { |
2529 | template<class _Up> |
2530 | using __apply = __copy_cvref_t<_Tp, _Up>; |
2531 | }; |
2532 | |
2533 | // Given types A and B, let X be remove_reference_t<A>, let Y be remove_reference_t<B>, |
2534 | // and let COMMON-REF(A, B) be: |
2535 | template<class _Ap, class _Bp, class _Xp = remove_reference_t<_Ap>, class _Yp = remove_reference_t<_Bp>> |
2536 | struct __common_ref; |
2537 | |
2538 | template<class _Xp, class _Yp> |
2539 | using __common_ref_t = typename __common_ref<_Xp, _Yp>::__type; |
2540 | |
2541 | template<class _Xp, class _Yp> |
2542 | using __cv_cond_res = __cond_res<__copy_cv_t<_Xp, _Yp>&, __copy_cv_t<_Yp, _Xp>&>; |
2543 | |
2544 | |
2545 | // If A and B are both lvalue reference types, COMMON-REF(A, B) is |
2546 | // COND-RES(COPYCV(X, Y)&, COPYCV(Y, X)&) if that type exists and is a reference type. |
2547 | template<class _Ap, class _Bp, class _Xp, class _Yp> |
2548 | requires requires { typename __cv_cond_res<_Xp, _Yp>; } && is_reference_v<__cv_cond_res<_Xp, _Yp>> |
2549 | struct __common_ref<_Ap&, _Bp&, _Xp, _Yp> |
2550 | { |
2551 | using __type = __cv_cond_res<_Xp, _Yp>; |
2552 | }; |
2553 | |
2554 | // Otherwise, let C be remove_reference_t<COMMON-REF(X&, Y&)>&&. ... |
2555 | template <class _Xp, class _Yp> |
2556 | using __common_ref_C = remove_reference_t<__common_ref_t<_Xp&, _Yp&>>&&; |
2557 | |
2558 | |
2559 | // .... If A and B are both rvalue reference types, C is well-formed, and |
2560 | // is_convertible_v<A, C> && is_convertible_v<B, C> is true, then COMMON-REF(A, B) is C. |
2561 | template<class _Ap, class _Bp, class _Xp, class _Yp> |
2562 | requires |
2563 | requires { typename __common_ref_C<_Xp, _Yp>; } && |
2564 | is_convertible_v<_Ap&&, __common_ref_C<_Xp, _Yp>> && |
2565 | is_convertible_v<_Bp&&, __common_ref_C<_Xp, _Yp>> |
2566 | struct __common_ref<_Ap&&, _Bp&&, _Xp, _Yp> |
2567 | { |
2568 | using __type = __common_ref_C<_Xp, _Yp>; |
2569 | }; |
2570 | |
2571 | // Otherwise, let D be COMMON-REF(const X&, Y&). ... |
2572 | template <class _Tp, class _Up> |
2573 | using __common_ref_D = __common_ref_t<const _Tp&, _Up&>; |
2574 | |
2575 | // ... If A is an rvalue reference and B is an lvalue reference and D is well-formed and |
2576 | // is_convertible_v<A, D> is true, then COMMON-REF(A, B) is D. |
2577 | template<class _Ap, class _Bp, class _Xp, class _Yp> |
2578 | requires requires { typename __common_ref_D<_Xp, _Yp>; } && |
2579 | is_convertible_v<_Ap&&, __common_ref_D<_Xp, _Yp>> |
2580 | struct __common_ref<_Ap&&, _Bp&, _Xp, _Yp> |
2581 | { |
2582 | using __type = __common_ref_D<_Xp, _Yp>; |
2583 | }; |
2584 | |
2585 | // Otherwise, if A is an lvalue reference and B is an rvalue reference, then |
2586 | // COMMON-REF(A, B) is COMMON-REF(B, A). |
2587 | template<class _Ap, class _Bp, class _Xp, class _Yp> |
2588 | struct __common_ref<_Ap&, _Bp&&, _Xp, _Yp> : __common_ref<_Bp&&, _Ap&> {}; |
2589 | |
2590 | // Otherwise, COMMON-REF(A, B) is ill-formed. |
2591 | template<class _Ap, class _Bp, class _Xp, class _Yp> |
2592 | struct __common_ref {}; |
2593 | |
2594 | // Note C: For the common_reference trait applied to a parameter pack [...] |
2595 | |
2596 | template <class...> |
2597 | struct common_reference; |
2598 | |
2599 | template <class... _Types> |
2600 | using common_reference_t = typename common_reference<_Types...>::type; |
2601 | |
2602 | // bullet 1 - sizeof...(T) == 0 |
2603 | template<> |
2604 | struct common_reference<> {}; |
2605 | |
2606 | // bullet 2 - sizeof...(T) == 1 |
2607 | template <class _Tp> |
2608 | struct common_reference<_Tp> |
2609 | { |
2610 | using type = _Tp; |
2611 | }; |
2612 | |
2613 | // bullet 3 - sizeof...(T) == 2 |
2614 | template <class _Tp, class _Up> struct __common_reference_sub_bullet3; |
2615 | template <class _Tp, class _Up> struct __common_reference_sub_bullet2 : __common_reference_sub_bullet3<_Tp, _Up> {}; |
2616 | template <class _Tp, class _Up> struct __common_reference_sub_bullet1 : __common_reference_sub_bullet2<_Tp, _Up> {}; |
2617 | |
2618 | // sub-bullet 1 - If T1 and T2 are reference types and COMMON-REF(T1, T2) is well-formed, then |
2619 | // the member typedef `type` denotes that type. |
2620 | template <class _Tp, class _Up> struct common_reference<_Tp, _Up> : __common_reference_sub_bullet1<_Tp, _Up> {}; |
2621 | |
2622 | template <class _Tp, class _Up> |
2623 | requires is_reference_v<_Tp> && is_reference_v<_Up> && requires { typename __common_ref_t<_Tp, _Up>; } |
2624 | struct __common_reference_sub_bullet1<_Tp, _Up> |
2625 | { |
2626 | using type = __common_ref_t<_Tp, _Up>; |
2627 | }; |
2628 | |
2629 | // sub-bullet 2 - Otherwise, if basic_common_reference<remove_cvref_t<T1>, remove_cvref_t<T2>, XREF(T1), XREF(T2)>::type |
2630 | // is well-formed, then the member typedef `type` denotes that type. |
2631 | template <class, class, template <class> class, template <class> class> struct basic_common_reference {}; |
2632 | |
2633 | template <class _Tp, class _Up> |
2634 | using __basic_common_reference_t = typename basic_common_reference< |
2635 | remove_cvref_t<_Tp>, remove_cvref_t<_Up>, |
2636 | __xref<_Tp>::template __apply, __xref<_Up>::template __apply>::type; |
2637 | |
2638 | template <class _Tp, class _Up> |
2639 | requires requires { typename __basic_common_reference_t<_Tp, _Up>; } |
2640 | struct __common_reference_sub_bullet2<_Tp, _Up> |
2641 | { |
2642 | using type = __basic_common_reference_t<_Tp, _Up>; |
2643 | }; |
2644 | |
2645 | // sub-bullet 3 - Otherwise, if COND-RES(T1, T2) is well-formed, |
2646 | // then the member typedef `type` denotes that type. |
2647 | template <class _Tp, class _Up> |
2648 | requires requires { typename __cond_res<_Tp, _Up>; } |
2649 | struct __common_reference_sub_bullet3<_Tp, _Up> |
2650 | { |
2651 | using type = __cond_res<_Tp, _Up>; |
2652 | }; |
2653 | |
2654 | |
2655 | // sub-bullet 4 & 5 - Otherwise, if common_type_t<T1, T2> is well-formed, |
2656 | // then the member typedef `type` denotes that type. |
2657 | // - Otherwise, there shall be no member `type`. |
2658 | template <class _Tp, class _Up> struct __common_reference_sub_bullet3 : common_type<_Tp, _Up> {}; |
2659 | |
2660 | // bullet 4 - If there is such a type `C`, the member typedef type shall denote the same type, if |
2661 | // any, as `common_reference_t<C, Rest...>`. |
2662 | template <class _Tp, class _Up, class _Vp, class... _Rest> |
2663 | requires requires { typename common_reference_t<_Tp, _Up>; } |
2664 | struct common_reference<_Tp, _Up, _Vp, _Rest...> |
2665 | : common_reference<common_reference_t<_Tp, _Up>, _Vp, _Rest...> |
2666 | {}; |
2667 | |
2668 | // bullet 5 - Otherwise, there shall be no member `type`. |
2669 | template <class...> struct common_reference {}; |
2670 | |
2671 | #endif // _LIBCPP_STD_VER > 17 && !defined(_LIBCPP_HAS_NO_CONCEPTS) |
2672 | |
2673 | // is_assignable |
2674 | |
2675 | template<typename, typename _Tp> struct __select_2nd { typedef _LIBCPP_NODEBUG_TYPE__attribute__((nodebug)) _Tp type; }; |
2676 | |
2677 | #if __has_keyword(__is_assignable)!(0) |
2678 | |
2679 | template<class _Tp, class _Up> |
2680 | struct _LIBCPP_TEMPLATE_VIS__attribute__ ((__type_visibility__("default"))) is_assignable : _BoolConstant<__is_assignable(_Tp, _Up)> { }; |
2681 | |
2682 | #if _LIBCPP_STD_VER14 > 14 && !defined(_LIBCPP_HAS_NO_VARIABLE_TEMPLATES) |
2683 | template <class _Tp, class _Arg> |
2684 | _LIBCPP_INLINE_VAR _LIBCPP_CONSTEXPRconstexpr bool is_assignable_v = __is_assignable(_Tp, _Arg); |
2685 | #endif |
2686 | |
2687 | #else // __has_keyword(__is_assignable) |
2688 | |
2689 | template <class _Tp, class _Arg> |
2690 | typename __select_2nd<decltype((declval<_Tp>() = declval<_Arg>())), true_type>::type |
2691 | __is_assignable_test(int); |
2692 | |
2693 | template <class, class> |
2694 | false_type __is_assignable_test(...); |
2695 | |
2696 | |
2697 | template <class _Tp, class _Arg, bool = is_void<_Tp>::value || is_void<_Arg>::value> |
2698 | struct __is_assignable_imp |
2699 | : public decltype((_VSTDstd::__1::__is_assignable_test<_Tp, _Arg>(0))) {}; |
2700 | |
2701 | template <class _Tp, class _Arg> |
2702 | struct __is_assignable_imp<_Tp, _Arg, true> |
2703 | : public false_type |
2704 | { |
2705 | }; |
2706 | |
2707 | template <class _Tp, class _Arg> |
2708 | struct is_assignable |
2709 | : public __is_assignable_imp<_Tp, _Arg> {}; |
2710 | |
2711 | #if _LIBCPP_STD_VER14 > 14 && !defined(_LIBCPP_HAS_NO_VARIABLE_TEMPLATES) |
2712 | template <class _Tp, class _Arg> |
2713 | _LIBCPP_INLINE_VAR _LIBCPP_CONSTEXPRconstexpr bool is_assignable_v |
2714 | = is_assignable<_Tp, _Arg>::value; |
2715 | #endif |
2716 | |
2717 | #endif // __has_keyword(__is_assignable) |
2718 | |
2719 | // is_copy_assignable |
2720 | |
2721 | template <class _Tp> struct _LIBCPP_TEMPLATE_VIS__attribute__ ((__type_visibility__("default"))) is_copy_assignable |
2722 | : public is_assignable<typename add_lvalue_reference<_Tp>::type, |
2723 | typename add_lvalue_reference<typename add_const<_Tp>::type>::type> {}; |
2724 | |
2725 | #if _LIBCPP_STD_VER14 > 14 && !defined(_LIBCPP_HAS_NO_VARIABLE_TEMPLATES) |
2726 | template <class _Tp> |
2727 | _LIBCPP_INLINE_VAR _LIBCPP_CONSTEXPRconstexpr bool is_copy_assignable_v |
2728 | = is_copy_assignable<_Tp>::value; |
2729 | #endif |
2730 | |
2731 | // is_move_assignable |
2732 | |
2733 | template <class _Tp> struct _LIBCPP_TEMPLATE_VIS__attribute__ ((__type_visibility__("default"))) is_move_assignable |
2734 | : public is_assignable<typename add_lvalue_reference<_Tp>::type, |
2735 | typename add_rvalue_reference<_Tp>::type> {}; |
2736 | |
2737 | #if _LIBCPP_STD_VER14 > 14 && !defined(_LIBCPP_HAS_NO_VARIABLE_TEMPLATES) |
2738 | template <class _Tp> |
2739 | _LIBCPP_INLINE_VAR _LIBCPP_CONSTEXPRconstexpr bool is_move_assignable_v |
2740 | = is_move_assignable<_Tp>::value; |
2741 | #endif |
2742 | |
2743 | // is_destructible |
2744 | |
2745 | #if __has_keyword(__is_destructible)!(1) |
2746 | |
2747 | template<class _Tp> |
2748 | struct _LIBCPP_TEMPLATE_VIS__attribute__ ((__type_visibility__("default"))) is_destructible : _BoolConstant<__is_destructible(_Tp)> { }; |
2749 | |
2750 | #if _LIBCPP_STD_VER14 > 14 && !defined(_LIBCPP_HAS_NO_VARIABLE_TEMPLATES) |
2751 | template <class _Tp> |
2752 | _LIBCPP_INLINE_VAR _LIBCPP_CONSTEXPRconstexpr bool is_destructible_v = __is_destructible(_Tp); |
2753 | #endif |
2754 | |
2755 | #else // __has_keyword(__is_destructible) |
2756 | |
2757 | // if it's a reference, return true |
2758 | // if it's a function, return false |
2759 | // if it's void, return false |
2760 | // if it's an array of unknown bound, return false |
2761 | // Otherwise, return "declval<_Up&>().~_Up()" is well-formed |
2762 | // where _Up is remove_all_extents<_Tp>::type |
2763 | |
2764 | template <class> |
2765 | struct __is_destructible_apply { typedef int type; }; |
2766 | |
2767 | template <typename _Tp> |
2768 | struct __is_destructor_wellformed { |
2769 | template <typename _Tp1> |
2770 | static char __test ( |
2771 | typename __is_destructible_apply<decltype(declval<_Tp1&>().~_Tp1())>::type |
2772 | ); |
2773 | |
2774 | template <typename _Tp1> |
2775 | static __two __test (...); |
2776 | |
2777 | static const bool value = sizeof(__test<_Tp>(12)) == sizeof(char); |
2778 | }; |
2779 | |
2780 | template <class _Tp, bool> |
2781 | struct __destructible_imp; |
2782 | |
2783 | template <class _Tp> |
2784 | struct __destructible_imp<_Tp, false> |
2785 | : public integral_constant<bool, |
2786 | __is_destructor_wellformed<typename remove_all_extents<_Tp>::type>::value> {}; |
2787 | |
2788 | template <class _Tp> |
2789 | struct __destructible_imp<_Tp, true> |
2790 | : public true_type {}; |
2791 | |
2792 | template <class _Tp, bool> |
2793 | struct __destructible_false; |
2794 | |
2795 | template <class _Tp> |
2796 | struct __destructible_false<_Tp, false> : public __destructible_imp<_Tp, is_reference<_Tp>::value> {}; |
2797 | |
2798 | template <class _Tp> |
2799 | struct __destructible_false<_Tp, true> : public false_type {}; |
2800 | |
2801 | template <class _Tp> |
2802 | struct is_destructible |
2803 | : public __destructible_false<_Tp, is_function<_Tp>::value> {}; |
2804 | |
2805 | template <class _Tp> |
2806 | struct is_destructible<_Tp[]> |
2807 | : public false_type {}; |
2808 | |
2809 | template <> |
2810 | struct is_destructible<void> |
2811 | : public false_type {}; |
2812 | |
2813 | #if _LIBCPP_STD_VER14 > 14 && !defined(_LIBCPP_HAS_NO_VARIABLE_TEMPLATES) |
2814 | template <class _Tp> |
2815 | _LIBCPP_INLINE_VAR _LIBCPP_CONSTEXPRconstexpr bool is_destructible_v |
2816 | = is_destructible<_Tp>::value; |
2817 | #endif |
2818 | |
2819 | #endif // __has_keyword(__is_destructible) |
2820 | |
2821 | template <class _MP, bool _IsMemberFunctionPtr, bool _IsMemberObjectPtr> |
2822 | struct __member_pointer_traits_imp |
2823 | { |
2824 | }; |
2825 | |
2826 | template <class _Rp, class _Class, class ..._Param> |
2827 | struct __member_pointer_traits_imp<_Rp (_Class::*)(_Param...), true, false> |
2828 | { |
2829 | typedef _Class _ClassType; |
2830 | typedef _Rp _ReturnType; |
2831 | typedef _Rp (_FnType) (_Param...); |
2832 | }; |
2833 | |
2834 | template <class _Rp, class _Class, class ..._Param> |
2835 | struct __member_pointer_traits_imp<_Rp (_Class::*)(_Param..., ...), true, false> |
2836 | { |
2837 | typedef _Class _ClassType; |
2838 | typedef _Rp _ReturnType; |
2839 | typedef _Rp (_FnType) (_Param..., ...); |
2840 | }; |
2841 | |
2842 | template <class _Rp, class _Class, class ..._Param> |
2843 | struct __member_pointer_traits_imp<_Rp (_Class::*)(_Param...) const, true, false> |
2844 | { |
2845 | typedef _Class const _ClassType; |
2846 | typedef _Rp _ReturnType; |
2847 | typedef _Rp (_FnType) (_Param...); |
2848 | }; |
2849 | |
2850 | template <class _Rp, class _Class, class ..._Param> |
2851 | struct __member_pointer_traits_imp<_Rp (_Class::*)(_Param..., ...) const, true, false> |
2852 | { |
2853 | typedef _Class const _ClassType; |
2854 | typedef _Rp _ReturnType; |
2855 | typedef _Rp (_FnType) (_Param..., ...); |
2856 | }; |
2857 | |
2858 | template <class _Rp, class _Class, class ..._Param> |
2859 | struct __member_pointer_traits_imp<_Rp (_Class::*)(_Param...) volatile, true, false> |
2860 | { |
2861 | typedef _Class volatile _ClassType; |
2862 | typedef _Rp _ReturnType; |
2863 | typedef _Rp (_FnType) (_Param...); |
2864 | }; |
2865 | |
2866 | template <class _Rp, class _Class, class ..._Param> |
2867 | struct __member_pointer_traits_imp<_Rp (_Class::*)(_Param..., ...) volatile, true, false> |
2868 | { |
2869 | typedef _Class volatile _ClassType; |
2870 | typedef _Rp _ReturnType; |
2871 | typedef _Rp (_FnType) (_Param..., ...); |
2872 | }; |
2873 | |
2874 | template <class _Rp, class _Class, class ..._Param> |
2875 | struct __member_pointer_traits_imp<_Rp (_Class::*)(_Param...) const volatile, true, false> |
2876 | { |
2877 | typedef _Class const volatile _ClassType; |
2878 | typedef _Rp _ReturnType; |
2879 | typedef _Rp (_FnType) (_Param...); |
2880 | }; |
2881 | |
2882 | template <class _Rp, class _Class, class ..._Param> |
2883 | struct __member_pointer_traits_imp<_Rp (_Class::*)(_Param..., ...) const volatile, true, false> |
2884 | { |
2885 | typedef _Class const volatile _ClassType; |
2886 | typedef _Rp _ReturnType; |
2887 | typedef _Rp (_FnType) (_Param..., ...); |
2888 | }; |
2889 | |
2890 | #if __has_feature(cxx_reference_qualified_functions)1 || defined(_LIBCPP_COMPILER_GCC) |
2891 | |
2892 | template <class _Rp, class _Class, class ..._Param> |
2893 | struct __member_pointer_traits_imp<_Rp (_Class::*)(_Param...) &, true, false> |
2894 | { |
2895 | typedef _Class& _ClassType; |
2896 | typedef _Rp _ReturnType; |
2897 | typedef _Rp (_FnType) (_Param...); |
2898 | }; |
2899 | |
2900 | template <class _Rp, class _Class, class ..._Param> |
2901 | struct __member_pointer_traits_imp<_Rp (_Class::*)(_Param..., ...) &, true, false> |
2902 | { |
2903 | typedef _Class& _ClassType; |
2904 | typedef _Rp _ReturnType; |
2905 | typedef _Rp (_FnType) (_Param..., ...); |
2906 | }; |
2907 | |
2908 | template <class _Rp, class _Class, class ..._Param> |
2909 | struct __member_pointer_traits_imp<_Rp (_Class::*)(_Param...) const&, true, false> |
2910 | { |
2911 | typedef _Class const& _ClassType; |
2912 | typedef _Rp _ReturnType; |
2913 | typedef _Rp (_FnType) (_Param...); |
2914 | }; |
2915 | |
2916 | template <class _Rp, class _Class, class ..._Param> |
2917 | struct __member_pointer_traits_imp<_Rp (_Class::*)(_Param..., ...) const&, true, false> |
2918 | { |
2919 | typedef _Class const& _ClassType; |
2920 | typedef _Rp _ReturnType; |
2921 | typedef _Rp (_FnType) (_Param..., ...); |
2922 | }; |
2923 | |
2924 | template <class _Rp, class _Class, class ..._Param> |
2925 | struct __member_pointer_traits_imp<_Rp (_Class::*)(_Param...) volatile&, true, false> |
2926 | { |
2927 | typedef _Class volatile& _ClassType; |
2928 | typedef _Rp _ReturnType; |
2929 | typedef _Rp (_FnType) (_Param...); |
2930 | }; |
2931 | |
2932 | template <class _Rp, class _Class, class ..._Param> |
2933 | struct __member_pointer_traits_imp<_Rp (_Class::*)(_Param..., ...) volatile&, true, false> |
2934 | { |
2935 | typedef _Class volatile& _ClassType; |
2936 | typedef _Rp _ReturnType; |
2937 | typedef _Rp (_FnType) (_Param..., ...); |
2938 | }; |
2939 | |
2940 | template <class _Rp, class _Class, class ..._Param> |
2941 | struct __member_pointer_traits_imp<_Rp (_Class::*)(_Param...) const volatile&, true, false> |
2942 | { |
2943 | typedef _Class const volatile& _ClassType; |
2944 | typedef _Rp _ReturnType; |
2945 | typedef _Rp (_FnType) (_Param...); |
2946 | }; |
2947 | |
2948 | template <class _Rp, class _Class, class ..._Param> |
2949 | struct __member_pointer_traits_imp<_Rp (_Class::*)(_Param..., ...) const volatile&, true, false> |
2950 | { |
2951 | typedef _Class const volatile& _ClassType; |
2952 | typedef _Rp _ReturnType; |
2953 | typedef _Rp (_FnType) (_Param..., ...); |
2954 | }; |
2955 | |
2956 | template <class _Rp, class _Class, class ..._Param> |
2957 | struct __member_pointer_traits_imp<_Rp (_Class::*)(_Param...) &&, true, false> |
2958 | { |
2959 | typedef _Class&& _ClassType; |
2960 | typedef _Rp _ReturnType; |
2961 | typedef _Rp (_FnType) (_Param...); |
2962 | }; |
2963 | |
2964 | template <class _Rp, class _Class, class ..._Param> |
2965 | struct __member_pointer_traits_imp<_Rp (_Class::*)(_Param..., ...) &&, true, false> |
2966 | { |
2967 | typedef _Class&& _ClassType; |
2968 | typedef _Rp _ReturnType; |
2969 | typedef _Rp (_FnType) (_Param..., ...); |
2970 | }; |
2971 | |
2972 | template <class _Rp, class _Class, class ..._Param> |
2973 | struct __member_pointer_traits_imp<_Rp (_Class::*)(_Param...) const&&, true, false> |
2974 | { |
2975 | typedef _Class const&& _ClassType; |
2976 | typedef _Rp _ReturnType; |
2977 | typedef _Rp (_FnType) (_Param...); |
2978 | }; |
2979 | |
2980 | template <class _Rp, class _Class, class ..._Param> |
2981 | struct __member_pointer_traits_imp<_Rp (_Class::*)(_Param..., ...) const&&, true, false> |
2982 | { |
2983 | typedef _Class const&& _ClassType; |
2984 | typedef _Rp _ReturnType; |
2985 | typedef _Rp (_FnType) (_Param..., ...); |
2986 | }; |
2987 | |
2988 | template <class _Rp, class _Class, class ..._Param> |
2989 | struct __member_pointer_traits_imp<_Rp (_Class::*)(_Param...) volatile&&, true, false> |
2990 | { |
2991 | typedef _Class volatile&& _ClassType; |
2992 | typedef _Rp _ReturnType; |
2993 | typedef _Rp (_FnType) (_Param...); |
2994 | }; |
2995 | |
2996 | template <class _Rp, class _Class, class ..._Param> |
2997 | struct __member_pointer_traits_imp<_Rp (_Class::*)(_Param..., ...) volatile&&, true, false> |
2998 | { |
2999 | typedef _Class volatile&& _ClassType; |
3000 | typedef _Rp _ReturnType; |
3001 | typedef _Rp (_FnType) (_Param..., ...); |
3002 | }; |
3003 | |
3004 | template <class _Rp, class _Class, class ..._Param> |
3005 | struct __member_pointer_traits_imp<_Rp (_Class::*)(_Param...) const volatile&&, true, false> |
3006 | { |
3007 | typedef _Class const volatile&& _ClassType; |
3008 | typedef _Rp _ReturnType; |
3009 | typedef _Rp (_FnType) (_Param...); |
3010 | }; |
3011 | |
3012 | template <class _Rp, class _Class, class ..._Param> |
3013 | struct __member_pointer_traits_imp<_Rp (_Class::*)(_Param..., ...) const volatile&&, true, false> |
3014 | { |
3015 | typedef _Class const volatile&& _ClassType; |
3016 | typedef _Rp _ReturnType; |
3017 | typedef _Rp (_FnType) (_Param..., ...); |
3018 | }; |
3019 | |
3020 | #endif // __has_feature(cxx_reference_qualified_functions) || defined(_LIBCPP_COMPILER_GCC) |
3021 | |
3022 | |
3023 | template <class _Rp, class _Class> |
3024 | struct __member_pointer_traits_imp<_Rp _Class::*, false, true> |
3025 | { |
3026 | typedef _Class _ClassType; |
3027 | typedef _Rp _ReturnType; |
3028 | }; |
3029 | |
3030 | template <class _MP> |
3031 | struct __member_pointer_traits |
3032 | : public __member_pointer_traits_imp<typename remove_cv<_MP>::type, |
3033 | is_member_function_pointer<_MP>::value, |
3034 | is_member_object_pointer<_MP>::value> |
3035 | { |
3036 | // typedef ... _ClassType; |
3037 | // typedef ... _ReturnType; |
3038 | // typedef ... _FnType; |
3039 | }; |
3040 | |
3041 | |
3042 | template <class _DecayedFp> |
3043 | struct __member_pointer_class_type {}; |
3044 | |
3045 | template <class _Ret, class _ClassType> |
3046 | struct __member_pointer_class_type<_Ret _ClassType::*> { |
3047 | typedef _ClassType type; |
3048 | }; |
3049 | |
3050 | // template <class T, class... Args> struct is_constructible; |
3051 | |
3052 | #if defined(_LIBCPP_COMPILER_GCC) && _GNUC_VER_NEW((4 * 100 + 2) * 10 + 1) >= 10000 |
3053 | # define _LIBCPP_GCC_SUPPORTS_IS_CONSTRUCTIBLE |
3054 | #endif |
3055 | |
3056 | #if !defined(_LIBCPP_CXX03_LANG) && !__has_feature(is_constructible)1 && !defined(_LIBCPP_GCC_SUPPORTS_IS_CONSTRUCTIBLE) |
3057 | |
3058 | template <class _Tp, class... _Args> |
3059 | struct __libcpp_is_constructible; |
3060 | |
3061 | template <class _To, class _From> |
3062 | struct __is_invalid_base_to_derived_cast { |
3063 | static_assert(is_reference<_To>::value, "Wrong specialization"); |
3064 | using _RawFrom = __uncvref_t<_From>; |
3065 | using _RawTo = __uncvref_t<_To>; |
3066 | static const bool value = _And< |
3067 | _IsNotSame<_RawFrom, _RawTo>, |
3068 | is_base_of<_RawFrom, _RawTo>, |
3069 | _Not<__libcpp_is_constructible<_RawTo, _From>> |
3070 | >::value; |
3071 | }; |
3072 | |
3073 | template <class _To, class _From> |
3074 | struct __is_invalid_lvalue_to_rvalue_cast : false_type { |
3075 | static_assert(is_reference<_To>::value, "Wrong specialization"); |
3076 | }; |
3077 | |
3078 | template <class _ToRef, class _FromRef> |
3079 | struct __is_invalid_lvalue_to_rvalue_cast<_ToRef&&, _FromRef&> { |
3080 | using _RawFrom = __uncvref_t<_FromRef>; |
3081 | using _RawTo = __uncvref_t<_ToRef>; |
3082 | static const bool value = _And< |
3083 | _Not<is_function<_RawTo>>, |
3084 | _Or< |
3085 | _IsSame<_RawFrom, _RawTo>, |
3086 | is_base_of<_RawTo, _RawFrom>> |
3087 | >::value; |
3088 | }; |
3089 | |
3090 | struct __is_constructible_helper |
3091 | { |
3092 | template <class _To> |
3093 | static void __eat(_To); |
3094 | |
3095 | // This overload is needed to work around a Clang bug that disallows |
3096 | // static_cast<T&&>(e) for non-reference-compatible types. |
3097 | // Example: static_cast<int&&>(declval<double>()); |
3098 | // NOTE: The static_cast implementation below is required to support |
3099 | // classes with explicit conversion operators. |
3100 | template <class _To, class _From, |
3101 | class = decltype(__eat<_To>(declval<_From>()))> |
3102 | static true_type __test_cast(int); |
3103 | |
3104 | template <class _To, class _From, |
3105 | class = decltype(static_cast<_To>(declval<_From>()))> |
3106 | static integral_constant<bool, |
3107 | !__is_invalid_base_to_derived_cast<_To, _From>::value && |
3108 | !__is_invalid_lvalue_to_rvalue_cast<_To, _From>::value |
3109 | > __test_cast(long); |
3110 | |
3111 | template <class, class> |
3112 | static false_type __test_cast(...); |
3113 | |
3114 | template <class _Tp, class ..._Args, |
3115 | class = decltype(_Tp(declval<_Args>()...))> |
3116 | static true_type __test_nary(int); |
3117 | template <class _Tp, class...> |
3118 | static false_type __test_nary(...); |
3119 | |
3120 | template <class _Tp, class _A0, class = decltype(::new _Tp(declval<_A0>()))> |
3121 | static is_destructible<_Tp> __test_unary(int); |
3122 | template <class, class> |
3123 | static false_type __test_unary(...); |
3124 | }; |
3125 | |
3126 | template <class _Tp, bool = is_void<_Tp>::value> |
3127 | struct __is_default_constructible |
3128 | : decltype(__is_constructible_helper::__test_nary<_Tp>(0)) |
3129 | {}; |
3130 | |
3131 | template <class _Tp> |
3132 | struct __is_default_constructible<_Tp, true> : false_type {}; |
3133 | |
3134 | template <class _Tp> |
3135 | struct __is_default_constructible<_Tp[], false> : false_type {}; |
3136 | |
3137 | template <class _Tp, size_t _Nx> |
3138 | struct __is_default_constructible<_Tp[_Nx], false> |
3139 | : __is_default_constructible<typename remove_all_extents<_Tp>::type> {}; |
3140 | |
3141 | template <class _Tp, class... _Args> |
3142 | struct __libcpp_is_constructible |
3143 | { |
3144 | static_assert(sizeof...(_Args) > 1, "Wrong specialization"); |
3145 | typedef decltype(__is_constructible_helper::__test_nary<_Tp, _Args...>(0)) |
3146 | type; |
3147 | }; |
3148 | |
3149 | template <class _Tp> |
3150 | struct __libcpp_is_constructible<_Tp> : __is_default_constructible<_Tp> {}; |
3151 | |
3152 | template <class _Tp, class _A0> |
3153 | struct __libcpp_is_constructible<_Tp, _A0> |
3154 | : public decltype(__is_constructible_helper::__test_unary<_Tp, _A0>(0)) |
3155 | {}; |
3156 | |
3157 | template <class _Tp, class _A0> |
3158 | struct __libcpp_is_constructible<_Tp&, _A0> |
3159 | : public decltype(__is_constructible_helper:: |
3160 | __test_cast<_Tp&, _A0>(0)) |
3161 | {}; |
3162 | |
3163 | template <class _Tp, class _A0> |
3164 | struct __libcpp_is_constructible<_Tp&&, _A0> |
3165 | : public decltype(__is_constructible_helper:: |
3166 | __test_cast<_Tp&&, _A0>(0)) |
3167 | {}; |
3168 | |
3169 | #endif |
3170 | |
3171 | #if __has_feature(is_constructible)1 || defined(_LIBCPP_GCC_SUPPORTS_IS_CONSTRUCTIBLE) |
3172 | template <class _Tp, class ..._Args> |
3173 | struct _LIBCPP_TEMPLATE_VIS__attribute__ ((__type_visibility__("default"))) is_constructible |
3174 | : public integral_constant<bool, __is_constructible(_Tp, _Args...)> |
3175 | {}; |
3176 | #else |
3177 | template <class _Tp, class... _Args> |
3178 | struct _LIBCPP_TEMPLATE_VIS__attribute__ ((__type_visibility__("default"))) is_constructible |
3179 | : public __libcpp_is_constructible<_Tp, _Args...>::type {}; |
3180 | #endif |
3181 | |
3182 | #if _LIBCPP_STD_VER14 > 14 && !defined(_LIBCPP_HAS_NO_VARIABLE_TEMPLATES) |
3183 | template <class _Tp, class ..._Args> |
3184 | _LIBCPP_INLINE_VAR _LIBCPP_CONSTEXPRconstexpr bool is_constructible_v |
3185 | = is_constructible<_Tp, _Args...>::value; |
3186 | #endif |
3187 | |
3188 | // is_default_constructible |
3189 | |
3190 | template <class _Tp> |
3191 | struct _LIBCPP_TEMPLATE_VIS__attribute__ ((__type_visibility__("default"))) is_default_constructible |
3192 | : public is_constructible<_Tp> |
3193 | {}; |
3194 | |
3195 | #if _LIBCPP_STD_VER14 > 14 && !defined(_LIBCPP_HAS_NO_VARIABLE_TEMPLATES) |
3196 | template <class _Tp> |
3197 | _LIBCPP_INLINE_VAR _LIBCPP_CONSTEXPRconstexpr bool is_default_constructible_v |
3198 | = is_default_constructible<_Tp>::value; |
3199 | #endif |
3200 | |
3201 | #ifndef _LIBCPP_CXX03_LANG |
3202 | // First of all, we can't implement this check in C++03 mode because the {} |
3203 | // default initialization syntax isn't valid. |
3204 | // Second, we implement the trait in a funny manner with two defaulted template |
3205 | // arguments to workaround Clang's PR43454. |
3206 | template <class _Tp> |
3207 | void __test_implicit_default_constructible(_Tp); |
3208 | |
3209 | template <class _Tp, class = void, class = typename is_default_constructible<_Tp>::type> |
3210 | struct __is_implicitly_default_constructible |
3211 | : false_type |
3212 | { }; |
3213 | |
3214 | template <class _Tp> |
3215 | struct __is_implicitly_default_constructible<_Tp, decltype(__test_implicit_default_constructible<_Tp const&>({})), true_type> |
3216 | : true_type |
3217 | { }; |
3218 | |
3219 | template <class _Tp> |
3220 | struct __is_implicitly_default_constructible<_Tp, decltype(__test_implicit_default_constructible<_Tp const&>({})), false_type> |
3221 | : false_type |
3222 | { }; |
3223 | #endif // !C++03 |
3224 | |
3225 | // is_copy_constructible |
3226 | |
3227 | template <class _Tp> |
3228 | struct _LIBCPP_TEMPLATE_VIS__attribute__ ((__type_visibility__("default"))) is_copy_constructible |
3229 | : public is_constructible<_Tp, |
3230 | typename add_lvalue_reference<typename add_const<_Tp>::type>::type> {}; |
3231 | |
3232 | #if _LIBCPP_STD_VER14 > 14 && !defined(_LIBCPP_HAS_NO_VARIABLE_TEMPLATES) |
3233 | template <class _Tp> |
3234 | _LIBCPP_INLINE_VAR _LIBCPP_CONSTEXPRconstexpr bool is_copy_constructible_v |
3235 | = is_copy_constructible<_Tp>::value; |
3236 | #endif |
3237 | |
3238 | // is_move_constructible |
3239 | |
3240 | template <class _Tp> |
3241 | struct _LIBCPP_TEMPLATE_VIS__attribute__ ((__type_visibility__("default"))) is_move_constructible |
3242 | : public is_constructible<_Tp, typename add_rvalue_reference<_Tp>::type> |
3243 | {}; |
3244 | |
3245 | #if _LIBCPP_STD_VER14 > 14 && !defined(_LIBCPP_HAS_NO_VARIABLE_TEMPLATES) |
3246 | template <class _Tp> |
3247 | _LIBCPP_INLINE_VAR _LIBCPP_CONSTEXPRconstexpr bool is_move_constructible_v |
3248 | = is_move_constructible<_Tp>::value; |
3249 | #endif |
3250 | |
3251 | // is_trivially_constructible |
3252 | |
3253 | #if __has_feature(is_trivially_constructible)1 || _GNUC_VER(4 * 100 + 2) >= 501 |
3254 | |
3255 | template <class _Tp, class... _Args> |
3256 | struct _LIBCPP_TEMPLATE_VIS__attribute__ ((__type_visibility__("default"))) is_trivially_constructible |
3257 | : integral_constant<bool, __is_trivially_constructible(_Tp, _Args...)> |
3258 | { |
3259 | }; |
3260 | |
3261 | #else // !__has_feature(is_trivially_constructible) |
3262 | |
3263 | template <class _Tp, class... _Args> |
3264 | struct _LIBCPP_TEMPLATE_VIS__attribute__ ((__type_visibility__("default"))) is_trivially_constructible |
3265 | : false_type |
3266 | { |
3267 | }; |
3268 | |
3269 | template <class _Tp> |
3270 | struct _LIBCPP_TEMPLATE_VIS__attribute__ ((__type_visibility__("default"))) is_trivially_constructible<_Tp> |
3271 | #if __has_feature(has_trivial_constructor)1 || defined(_LIBCPP_COMPILER_GCC) |
3272 | : integral_constant<bool, __has_trivial_constructor(_Tp)> |
3273 | #else |
3274 | : integral_constant<bool, is_scalar<_Tp>::value> |
3275 | #endif |
3276 | { |
3277 | }; |
3278 | |
3279 | template <class _Tp> |
3280 | struct _LIBCPP_TEMPLATE_VIS__attribute__ ((__type_visibility__("default"))) is_trivially_constructible<_Tp, _Tp&&> |
3281 | : integral_constant<bool, is_scalar<_Tp>::value> |
3282 | { |
3283 | }; |
3284 | |
3285 | template <class _Tp> |
3286 | struct _LIBCPP_TEMPLATE_VIS__attribute__ ((__type_visibility__("default"))) is_trivially_constructible<_Tp, const _Tp&> |
3287 | : integral_constant<bool, is_scalar<_Tp>::value> |
3288 | { |
3289 | }; |
3290 | |
3291 | template <class _Tp> |
3292 | struct _LIBCPP_TEMPLATE_VIS__attribute__ ((__type_visibility__("default"))) is_trivially_constructible<_Tp, _Tp&> |
3293 | : integral_constant<bool, is_scalar<_Tp>::value> |
3294 | { |
3295 | }; |
3296 | |
3297 | #endif // !__has_feature(is_trivially_constructible) |
3298 | |
3299 | |
3300 | #if _LIBCPP_STD_VER14 > 14 && !defined(_LIBCPP_HAS_NO_VARIABLE_TEMPLATES) |
3301 | template <class _Tp, class... _Args> |
3302 | _LIBCPP_INLINE_VAR _LIBCPP_CONSTEXPRconstexpr bool is_trivially_constructible_v |
3303 | = is_trivially_constructible<_Tp, _Args...>::value; |
3304 | #endif |
3305 | |
3306 | // is_trivially_default_constructible |
3307 | |
3308 | template <class _Tp> struct _LIBCPP_TEMPLATE_VIS__attribute__ ((__type_visibility__("default"))) is_trivially_default_constructible |
3309 | : public is_trivially_constructible<_Tp> |
3310 | {}; |
3311 | |
3312 | #if _LIBCPP_STD_VER14 > 14 && !defined(_LIBCPP_HAS_NO_VARIABLE_TEMPLATES) |
3313 | template <class _Tp> |
3314 | _LIBCPP_INLINE_VAR _LIBCPP_CONSTEXPRconstexpr bool is_trivially_default_constructible_v |
3315 | = is_trivially_default_constructible<_Tp>::value; |
3316 | #endif |
3317 | |
3318 | // is_trivially_copy_constructible |
3319 | |
3320 | template <class _Tp> struct _LIBCPP_TEMPLATE_VIS__attribute__ ((__type_visibility__("default"))) is_trivially_copy_constructible |
3321 | : public is_trivially_constructible<_Tp, typename add_lvalue_reference<const _Tp>::type> |
3322 | {}; |
3323 | |
3324 | #if _LIBCPP_STD_VER14 > 14 && !defined(_LIBCPP_HAS_NO_VARIABLE_TEMPLATES) |
3325 | template <class _Tp> |
3326 | _LIBCPP_INLINE_VAR _LIBCPP_CONSTEXPRconstexpr bool is_trivially_copy_constructible_v |
3327 | = is_trivially_copy_constructible<_Tp>::value; |
3328 | #endif |
3329 | |
3330 | // is_trivially_move_constructible |
3331 | |
3332 | template <class _Tp> struct _LIBCPP_TEMPLATE_VIS__attribute__ ((__type_visibility__("default"))) is_trivially_move_constructible |
3333 | : public is_trivially_constructible<_Tp, typename add_rvalue_reference<_Tp>::type> |
3334 | {}; |
3335 | |
3336 | #if _LIBCPP_STD_VER14 > 14 && !defined(_LIBCPP_HAS_NO_VARIABLE_TEMPLATES) |
3337 | template <class _Tp> |
3338 | _LIBCPP_INLINE_VAR _LIBCPP_CONSTEXPRconstexpr bool is_trivially_move_constructible_v |
3339 | = is_trivially_move_constructible<_Tp>::value; |
3340 | #endif |
3341 | |
3342 | // is_trivially_assignable |
3343 | |
3344 | #if __has_feature(is_trivially_assignable)1 || _GNUC_VER(4 * 100 + 2) >= 501 |
3345 | |
3346 | template <class _Tp, class _Arg> |
3347 | struct is_trivially_assignable |
3348 | : integral_constant<bool, __is_trivially_assignable(_Tp, _Arg)> |
3349 | { |
3350 | }; |
3351 | |
3352 | #else // !__has_feature(is_trivially_assignable) |
3353 | |
3354 | template <class _Tp, class _Arg> |
3355 | struct is_trivially_assignable |
3356 | : public false_type {}; |
3357 | |
3358 | template <class _Tp> |
3359 | struct is_trivially_assignable<_Tp&, _Tp> |
3360 | : integral_constant<bool, is_scalar<_Tp>::value> {}; |
3361 | |
3362 | template <class _Tp> |
3363 | struct is_trivially_assignable<_Tp&, _Tp&> |
3364 | : integral_constant<bool, is_scalar<_Tp>::value> {}; |
3365 | |
3366 | template <class _Tp> |
3367 | struct is_trivially_assignable<_Tp&, const _Tp&> |
3368 | : integral_constant<bool, is_scalar<_Tp>::value> {}; |
3369 | |
3370 | template <class _Tp> |
3371 | struct is_trivially_assignable<_Tp&, _Tp&&> |
3372 | : integral_constant<bool, is_scalar<_Tp>::value> {}; |
3373 | |
3374 | #endif // !__has_feature(is_trivially_assignable) |
3375 | |
3376 | #if _LIBCPP_STD_VER14 > 14 && !defined(_LIBCPP_HAS_NO_VARIABLE_TEMPLATES) |
3377 | template <class _Tp, class _Arg> |
3378 | _LIBCPP_INLINE_VAR _LIBCPP_CONSTEXPRconstexpr bool is_trivially_assignable_v |
3379 | = is_trivially_assignable<_Tp, _Arg>::value; |
3380 | #endif |
3381 | |
3382 | // is_trivially_copy_assignable |
3383 | |
3384 | template <class _Tp> struct _LIBCPP_TEMPLATE_VIS__attribute__ ((__type_visibility__("default"))) is_trivially_copy_assignable |
3385 | : public is_trivially_assignable<typename add_lvalue_reference<_Tp>::type, |
3386 | typename add_lvalue_reference<typename add_const<_Tp>::type>::type> {}; |
3387 | |
3388 | #if _LIBCPP_STD_VER14 > 14 && !defined(_LIBCPP_HAS_NO_VARIABLE_TEMPLATES) |
3389 | template <class _Tp> |
3390 | _LIBCPP_INLINE_VAR _LIBCPP_CONSTEXPRconstexpr bool is_trivially_copy_assignable_v |
3391 | = is_trivially_copy_assignable<_Tp>::value; |
3392 | #endif |
3393 | |
3394 | // is_trivially_move_assignable |
3395 | |
3396 | template <class _Tp> struct _LIBCPP_TEMPLATE_VIS__attribute__ ((__type_visibility__("default"))) is_trivially_move_assignable |
3397 | : public is_trivially_assignable<typename add_lvalue_reference<_Tp>::type, |
3398 | typename add_rvalue_reference<_Tp>::type> |
3399 | {}; |
3400 | |
3401 | #if _LIBCPP_STD_VER14 > 14 && !defined(_LIBCPP_HAS_NO_VARIABLE_TEMPLATES) |
3402 | template <class _Tp> |
3403 | _LIBCPP_INLINE_VAR _LIBCPP_CONSTEXPRconstexpr bool is_trivially_move_assignable_v |
3404 | = is_trivially_move_assignable<_Tp>::value; |
3405 | #endif |
3406 | |
3407 | // is_trivially_destructible |
3408 | |
3409 | #if __has_keyword(__is_trivially_destructible)!(0) |
3410 | |
3411 | template <class _Tp> struct _LIBCPP_TEMPLATE_VIS__attribute__ ((__type_visibility__("default"))) is_trivially_destructible |
3412 | : public integral_constant<bool, __is_trivially_destructible(_Tp)> {}; |
3413 | |
3414 | #elif __has_feature(has_trivial_destructor)1 || defined(_LIBCPP_COMPILER_GCC) |
3415 | |
3416 | template <class _Tp> struct _LIBCPP_TEMPLATE_VIS__attribute__ ((__type_visibility__("default"))) is_trivially_destructible |
3417 | : public integral_constant<bool, is_destructible<_Tp>::value && __has_trivial_destructor(_Tp)> {}; |
3418 | |
3419 | #else |
3420 | |
3421 | template <class _Tp> struct __libcpp_trivial_destructor |
3422 | : public integral_constant<bool, is_scalar<_Tp>::value || |
3423 | is_reference<_Tp>::value> {}; |
3424 | |
3425 | template <class _Tp> struct _LIBCPP_TEMPLATE_VIS__attribute__ ((__type_visibility__("default"))) is_trivially_destructible |
3426 | : public __libcpp_trivial_destructor<typename remove_all_extents<_Tp>::type> {}; |
3427 | |
3428 | template <class _Tp> struct _LIBCPP_TEMPLATE_VIS__attribute__ ((__type_visibility__("default"))) is_trivially_destructible<_Tp[]> |
3429 | : public false_type {}; |
3430 | |
3431 | #endif |
3432 | |
3433 | #if _LIBCPP_STD_VER14 > 14 && !defined(_LIBCPP_HAS_NO_VARIABLE_TEMPLATES) |
3434 | template <class _Tp> |
3435 | _LIBCPP_INLINE_VAR _LIBCPP_CONSTEXPRconstexpr bool is_trivially_destructible_v |
3436 | = is_trivially_destructible<_Tp>::value; |
3437 | #endif |
3438 | |
3439 | // is_nothrow_constructible |
3440 | |
3441 | #if __has_keyword(__is_nothrow_constructible)!(0) |
3442 | |
3443 | template <class _Tp, class... _Args> |
3444 | struct _LIBCPP_TEMPLATE_VIS__attribute__ ((__type_visibility__("default"))) is_nothrow_constructible |
3445 | : public integral_constant<bool, __is_nothrow_constructible(_Tp, _Args...)> {}; |
3446 | |
3447 | #else |
3448 | |
3449 | template <bool, bool, class _Tp, class... _Args> struct __libcpp_is_nothrow_constructible; |
3450 | |
3451 | template <class _Tp, class... _Args> |
3452 | struct __libcpp_is_nothrow_constructible</*is constructible*/true, /*is reference*/false, _Tp, _Args...> |
3453 | : public integral_constant<bool, noexcept(_Tp(declval<_Args>()...))> |
3454 | { |
3455 | }; |
3456 | |
3457 | template <class _Tp> |
3458 | void __implicit_conversion_to(_Tp) noexcept { } |
3459 | |
3460 | template <class _Tp, class _Arg> |
3461 | struct __libcpp_is_nothrow_constructible</*is constructible*/true, /*is reference*/true, _Tp, _Arg> |
3462 | : public integral_constant<bool, noexcept(_VSTDstd::__1::__implicit_conversion_to<_Tp>(declval<_Arg>()))> |
3463 | { |
3464 | }; |
3465 | |
3466 | template <class _Tp, bool _IsReference, class... _Args> |
3467 | struct __libcpp_is_nothrow_constructible</*is constructible*/false, _IsReference, _Tp, _Args...> |
3468 | : public false_type |
3469 | { |
3470 | }; |
3471 | |
3472 | template <class _Tp, class... _Args> |
3473 | struct _LIBCPP_TEMPLATE_VIS__attribute__ ((__type_visibility__("default"))) is_nothrow_constructible |
3474 | : __libcpp_is_nothrow_constructible<is_constructible<_Tp, _Args...>::value, is_reference<_Tp>::value, _Tp, _Args...> |
3475 | { |
3476 | }; |
3477 | |
3478 | template <class _Tp, size_t _Ns> |
3479 | struct _LIBCPP_TEMPLATE_VIS__attribute__ ((__type_visibility__("default"))) is_nothrow_constructible<_Tp[_Ns]> |
3480 | : __libcpp_is_nothrow_constructible<is_constructible<_Tp>::value, is_reference<_Tp>::value, _Tp> |
3481 | { |
3482 | }; |
3483 | |
3484 | #endif // _LIBCPP_HAS_NO_NOEXCEPT |
3485 | |
3486 | |
3487 | #if _LIBCPP_STD_VER14 > 14 && !defined(_LIBCPP_HAS_NO_VARIABLE_TEMPLATES) |
3488 | template <class _Tp, class ..._Args> |
3489 | _LIBCPP_INLINE_VAR _LIBCPP_CONSTEXPRconstexpr bool is_nothrow_constructible_v |
3490 | = is_nothrow_constructible<_Tp, _Args...>::value; |
3491 | #endif |
3492 | |
3493 | // is_nothrow_default_constructible |
3494 | |
3495 | template <class _Tp> struct _LIBCPP_TEMPLATE_VIS__attribute__ ((__type_visibility__("default"))) is_nothrow_default_constructible |
3496 | : public is_nothrow_constructible<_Tp> |
3497 | {}; |
3498 | |
3499 | #if _LIBCPP_STD_VER14 > 14 && !defined(_LIBCPP_HAS_NO_VARIABLE_TEMPLATES) |
3500 | template <class _Tp> |
3501 | _LIBCPP_INLINE_VAR _LIBCPP_CONSTEXPRconstexpr bool is_nothrow_default_constructible_v |
3502 | = is_nothrow_default_constructible<_Tp>::value; |
3503 | #endif |
3504 | |
3505 | // is_nothrow_copy_constructible |
3506 | |
3507 | template <class _Tp> struct _LIBCPP_TEMPLATE_VIS__attribute__ ((__type_visibility__("default"))) is_nothrow_copy_constructible |
3508 | : public is_nothrow_constructible<_Tp, |
3509 | typename add_lvalue_reference<typename add_const<_Tp>::type>::type> {}; |
3510 | |
3511 | #if _LIBCPP_STD_VER14 > 14 && !defined(_LIBCPP_HAS_NO_VARIABLE_TEMPLATES) |
3512 | template <class _Tp> |
3513 | _LIBCPP_INLINE_VAR _LIBCPP_CONSTEXPRconstexpr bool is_nothrow_copy_constructible_v |
3514 | = is_nothrow_copy_constructible<_Tp>::value; |
3515 | #endif |
3516 | |
3517 | // is_nothrow_move_constructible |
3518 | |
3519 | template <class _Tp> struct _LIBCPP_TEMPLATE_VIS__attribute__ ((__type_visibility__("default"))) is_nothrow_move_constructible |
3520 | : public is_nothrow_constructible<_Tp, typename add_rvalue_reference<_Tp>::type> |
3521 | {}; |
3522 | |
3523 | #if _LIBCPP_STD_VER14 > 14 && !defined(_LIBCPP_HAS_NO_VARIABLE_TEMPLATES) |
3524 | template <class _Tp> |
3525 | _LIBCPP_INLINE_VAR _LIBCPP_CONSTEXPRconstexpr bool is_nothrow_move_constructible_v |
3526 | = is_nothrow_move_constructible<_Tp>::value; |
3527 | #endif |
3528 | |
3529 | // is_nothrow_assignable |
3530 | |
3531 | #if __has_keyword(__is_nothrow_assignable)!(0) |
3532 | |
3533 | template <class _Tp, class _Arg> |
3534 | struct _LIBCPP_TEMPLATE_VIS__attribute__ ((__type_visibility__("default"))) is_nothrow_assignable |
3535 | : public integral_constant<bool, __is_nothrow_assignable(_Tp, _Arg)> {}; |
3536 | |
3537 | #else |
3538 | |
3539 | template <bool, class _Tp, class _Arg> struct __libcpp_is_nothrow_assignable; |
3540 | |
3541 | template <class _Tp, class _Arg> |
3542 | struct __libcpp_is_nothrow_assignable<false, _Tp, _Arg> |
3543 | : public false_type |
3544 | { |
3545 | }; |
3546 | |
3547 | template <class _Tp, class _Arg> |
3548 | struct __libcpp_is_nothrow_assignable<true, _Tp, _Arg> |
3549 | : public integral_constant<bool, noexcept(declval<_Tp>() = declval<_Arg>()) > |
3550 | { |
3551 | }; |
3552 | |
3553 | template <class _Tp, class _Arg> |
3554 | struct _LIBCPP_TEMPLATE_VIS__attribute__ ((__type_visibility__("default"))) is_nothrow_assignable |
3555 | : public __libcpp_is_nothrow_assignable<is_assignable<_Tp, _Arg>::value, _Tp, _Arg> |
3556 | { |
3557 | }; |
3558 | |
3559 | #endif // _LIBCPP_HAS_NO_NOEXCEPT |
3560 | |
3561 | #if _LIBCPP_STD_VER14 > 14 && !defined(_LIBCPP_HAS_NO_VARIABLE_TEMPLATES) |
3562 | template <class _Tp, class _Arg> |
3563 | _LIBCPP_INLINE_VAR _LIBCPP_CONSTEXPRconstexpr bool is_nothrow_assignable_v |
3564 | = is_nothrow_assignable<_Tp, _Arg>::value; |
3565 | #endif |
3566 | |
3567 | // is_nothrow_copy_assignable |
3568 | |
3569 | template <class _Tp> struct _LIBCPP_TEMPLATE_VIS__attribute__ ((__type_visibility__("default"))) is_nothrow_copy_assignable |
3570 | : public is_nothrow_assignable<typename add_lvalue_reference<_Tp>::type, |
3571 | typename add_lvalue_reference<typename add_const<_Tp>::type>::type> {}; |
3572 | |
3573 | #if _LIBCPP_STD_VER14 > 14 && !defined(_LIBCPP_HAS_NO_VARIABLE_TEMPLATES) |
3574 | template <class _Tp> |
3575 | _LIBCPP_INLINE_VAR _LIBCPP_CONSTEXPRconstexpr bool is_nothrow_copy_assignable_v |
3576 | = is_nothrow_copy_assignable<_Tp>::value; |
3577 | #endif |
3578 | |
3579 | // is_nothrow_move_assignable |
3580 | |
3581 | template <class _Tp> struct _LIBCPP_TEMPLATE_VIS__attribute__ ((__type_visibility__("default"))) is_nothrow_move_assignable |
3582 | : public is_nothrow_assignable<typename add_lvalue_reference<_Tp>::type, |
3583 | typename add_rvalue_reference<_Tp>::type> |
3584 | {}; |
3585 | |
3586 | #if _LIBCPP_STD_VER14 > 14 && !defined(_LIBCPP_HAS_NO_VARIABLE_TEMPLATES) |
3587 | template <class _Tp> |
3588 | _LIBCPP_INLINE_VAR _LIBCPP_CONSTEXPRconstexpr bool is_nothrow_move_assignable_v |
3589 | = is_nothrow_move_assignable<_Tp>::value; |
3590 | #endif |
3591 | |
3592 | // is_nothrow_destructible |
3593 | |
3594 | #if !defined(_LIBCPP_CXX03_LANG) |
3595 | |
3596 | template <bool, class _Tp> struct __libcpp_is_nothrow_destructible; |
3597 | |
3598 | template <class _Tp> |
3599 | struct __libcpp_is_nothrow_destructible<false, _Tp> |
3600 | : public false_type |
3601 | { |
3602 | }; |
3603 | |
3604 | template <class _Tp> |
3605 | struct __libcpp_is_nothrow_destructible<true, _Tp> |
3606 | : public integral_constant<bool, noexcept(declval<_Tp>().~_Tp()) > |
3607 | { |
3608 | }; |
3609 | |
3610 | template <class _Tp> |
3611 | struct _LIBCPP_TEMPLATE_VIS__attribute__ ((__type_visibility__("default"))) is_nothrow_destructible |
3612 | : public __libcpp_is_nothrow_destructible<is_destructible<_Tp>::value, _Tp> |
3613 | { |
3614 | }; |
3615 | |
3616 | template <class _Tp, size_t _Ns> |
3617 | struct _LIBCPP_TEMPLATE_VIS__attribute__ ((__type_visibility__("default"))) is_nothrow_destructible<_Tp[_Ns]> |
3618 | : public is_nothrow_destructible<_Tp> |
3619 | { |
3620 | }; |
3621 | |
3622 | template <class _Tp> |
3623 | struct _LIBCPP_TEMPLATE_VIS__attribute__ ((__type_visibility__("default"))) is_nothrow_destructible<_Tp&> |
3624 | : public true_type |
3625 | { |
3626 | }; |
3627 | |
3628 | template <class _Tp> |
3629 | struct _LIBCPP_TEMPLATE_VIS__attribute__ ((__type_visibility__("default"))) is_nothrow_destructible<_Tp&&> |
3630 | : public true_type |
3631 | { |
3632 | }; |
3633 | |
3634 | #else |
3635 | |
3636 | template <class _Tp> struct __libcpp_nothrow_destructor |
3637 | : public integral_constant<bool, is_scalar<_Tp>::value || |
3638 | is_reference<_Tp>::value> {}; |
3639 | |
3640 | template <class _Tp> struct _LIBCPP_TEMPLATE_VIS__attribute__ ((__type_visibility__("default"))) is_nothrow_destructible |
3641 | : public __libcpp_nothrow_destructor<typename remove_all_extents<_Tp>::type> {}; |
3642 | |
3643 | template <class _Tp> |
3644 | struct _LIBCPP_TEMPLATE_VIS__attribute__ ((__type_visibility__("default"))) is_nothrow_destructible<_Tp[]> |
3645 | : public false_type {}; |
3646 | |
3647 | #endif |
3648 | |
3649 | #if _LIBCPP_STD_VER14 > 14 && !defined(_LIBCPP_HAS_NO_VARIABLE_TEMPLATES) |
3650 | template <class _Tp> |
3651 | _LIBCPP_INLINE_VAR _LIBCPP_CONSTEXPRconstexpr bool is_nothrow_destructible_v |
3652 | = is_nothrow_destructible<_Tp>::value; |
3653 | #endif |
3654 | |
3655 | // is_pod |
3656 | |
3657 | #if __has_feature(is_pod)1 || defined(_LIBCPP_COMPILER_GCC) |
3658 | |
3659 | template <class _Tp> struct _LIBCPP_TEMPLATE_VIS__attribute__ ((__type_visibility__("default"))) is_pod |
3660 | : public integral_constant<bool, __is_pod(_Tp)> {}; |
3661 | |
3662 | #else |
3663 | |
3664 | template <class _Tp> struct _LIBCPP_TEMPLATE_VIS__attribute__ ((__type_visibility__("default"))) is_pod |
3665 | : public integral_constant<bool, is_trivially_default_constructible<_Tp>::value && |
3666 | is_trivially_copy_constructible<_Tp>::value && |
3667 | is_trivially_copy_assignable<_Tp>::value && |
3668 | is_trivially_destructible<_Tp>::value> {}; |
3669 | |
3670 | #endif |
3671 | |
3672 | #if _LIBCPP_STD_VER14 > 14 && !defined(_LIBCPP_HAS_NO_VARIABLE_TEMPLATES) |
3673 | template <class _Tp> |
3674 | _LIBCPP_INLINE_VAR _LIBCPP_CONSTEXPRconstexpr bool is_pod_v |
3675 | = is_pod<_Tp>::value; |
3676 | #endif |
3677 | |
3678 | // is_literal_type; |
3679 | |
3680 | #if _LIBCPP_STD_VER14 <= 17 || defined(_LIBCPP_ENABLE_CXX20_REMOVED_TYPE_TRAITS) |
3681 | template <class _Tp> struct _LIBCPP_TEMPLATE_VIS__attribute__ ((__type_visibility__("default"))) _LIBCPP_DEPRECATED_IN_CXX17 is_literal_type |
3682 | : public integral_constant<bool, __is_literal_type(_Tp)> |
3683 | {}; |
3684 | |
3685 | #if _LIBCPP_STD_VER14 > 14 && !defined(_LIBCPP_HAS_NO_VARIABLE_TEMPLATES) |
3686 | template <class _Tp> |
3687 | _LIBCPP_DEPRECATED_IN_CXX17 _LIBCPP_INLINE_VAR _LIBCPP_CONSTEXPRconstexpr bool is_literal_type_v |
3688 | = is_literal_type<_Tp>::value; |
3689 | #endif // _LIBCPP_STD_VER > 14 && !defined(_LIBCPP_HAS_NO_VARIABLE_TEMPLATES) |
3690 | #endif // _LIBCPP_STD_VER <= 17 || defined(_LIBCPP_ENABLE_CXX20_REMOVED_TYPE_TRAITS) |
3691 | |
3692 | // is_standard_layout; |
3693 | |
3694 | template <class _Tp> struct _LIBCPP_TEMPLATE_VIS__attribute__ ((__type_visibility__("default"))) is_standard_layout |
3695 | #if __has_feature(is_standard_layout)1 || defined(_LIBCPP_COMPILER_GCC) |
3696 | : public integral_constant<bool, __is_standard_layout(_Tp)> |
3697 | #else |
3698 | : integral_constant<bool, is_scalar<typename remove_all_extents<_Tp>::type>::value> |
3699 | #endif |
3700 | {}; |
3701 | |
3702 | #if _LIBCPP_STD_VER14 > 14 && !defined(_LIBCPP_HAS_NO_VARIABLE_TEMPLATES) |
3703 | template <class _Tp> |
3704 | _LIBCPP_INLINE_VAR _LIBCPP_CONSTEXPRconstexpr bool is_standard_layout_v |
3705 | = is_standard_layout<_Tp>::value; |
3706 | #endif |
3707 | |
3708 | // is_trivially_copyable; |
3709 | |
3710 | template <class _Tp> struct _LIBCPP_TEMPLATE_VIS__attribute__ ((__type_visibility__("default"))) is_trivially_copyable |
3711 | #if __has_feature(is_trivially_copyable)1 |
3712 | : public integral_constant<bool, __is_trivially_copyable(_Tp)> |
3713 | #elif _GNUC_VER(4 * 100 + 2) >= 501 |
3714 | : public integral_constant<bool, !is_volatile<_Tp>::value && __is_trivially_copyable(_Tp)> |
3715 | #else |
3716 | : integral_constant<bool, is_scalar<typename remove_all_extents<_Tp>::type>::value> |
3717 | #endif |
3718 | {}; |
3719 | |
3720 | #if _LIBCPP_STD_VER14 > 14 && !defined(_LIBCPP_HAS_NO_VARIABLE_TEMPLATES) |
3721 | template <class _Tp> |
3722 | _LIBCPP_INLINE_VAR _LIBCPP_CONSTEXPRconstexpr bool is_trivially_copyable_v |
3723 | = is_trivially_copyable<_Tp>::value; |
3724 | #endif |
3725 | |
3726 | // is_trivial; |
3727 | |
3728 | template <class _Tp> struct _LIBCPP_TEMPLATE_VIS__attribute__ ((__type_visibility__("default"))) is_trivial |
3729 | #if __has_feature(is_trivial)1 || defined(_LIBCPP_COMPILER_GCC) |
3730 | : public integral_constant<bool, __is_trivial(_Tp)> |
3731 | #else |
3732 | : integral_constant<bool, is_trivially_copyable<_Tp>::value && |
3733 | is_trivially_default_constructible<_Tp>::value> |
3734 | #endif |
3735 | {}; |
3736 | |
3737 | #if _LIBCPP_STD_VER14 > 14 && !defined(_LIBCPP_HAS_NO_VARIABLE_TEMPLATES) |
3738 | template <class _Tp> |
3739 | _LIBCPP_INLINE_VAR _LIBCPP_CONSTEXPRconstexpr bool is_trivial_v |
3740 | = is_trivial<_Tp>::value; |
3741 | #endif |
3742 | |
3743 | template <class _Tp> struct __is_reference_wrapper_impl : public false_type {}; |
3744 | template <class _Tp> struct __is_reference_wrapper_impl<reference_wrapper<_Tp> > : public true_type {}; |
3745 | template <class _Tp> struct __is_reference_wrapper |
3746 | : public __is_reference_wrapper_impl<typename remove_cv<_Tp>::type> {}; |
3747 | |
3748 | #ifndef _LIBCPP_CXX03_LANG |
3749 | |
3750 | template <class _Fp, class _A0, |
3751 | class _DecayFp = typename decay<_Fp>::type, |
3752 | class _DecayA0 = typename decay<_A0>::type, |
3753 | class _ClassT = typename __member_pointer_class_type<_DecayFp>::type> |
3754 | using __enable_if_bullet1 = typename enable_if |
3755 | < |
3756 | is_member_function_pointer<_DecayFp>::value |
3757 | && is_base_of<_ClassT, _DecayA0>::value |
3758 | >::type; |
3759 | |
3760 | template <class _Fp, class _A0, |
3761 | class _DecayFp = typename decay<_Fp>::type, |
3762 | class _DecayA0 = typename decay<_A0>::type> |
3763 | using __enable_if_bullet2 = typename enable_if |
3764 | < |
3765 | is_member_function_pointer<_DecayFp>::value |
3766 | && __is_reference_wrapper<_DecayA0>::value |
3767 | >::type; |
3768 | |
3769 | template <class _Fp, class _A0, |
3770 | class _DecayFp = typename decay<_Fp>::type, |
3771 | class _DecayA0 = typename decay<_A0>::type, |
3772 | class _ClassT = typename __member_pointer_class_type<_DecayFp>::type> |
3773 | using __enable_if_bullet3 = typename enable_if |
3774 | < |
3775 | is_member_function_pointer<_DecayFp>::value |
3776 | && !is_base_of<_ClassT, _DecayA0>::value |
3777 | && !__is_reference_wrapper<_DecayA0>::value |
3778 | >::type; |
3779 | |
3780 | template <class _Fp, class _A0, |
3781 | class _DecayFp = typename decay<_Fp>::type, |
3782 | class _DecayA0 = typename decay<_A0>::type, |
3783 | class _ClassT = typename __member_pointer_class_type<_DecayFp>::type> |
3784 | using __enable_if_bullet4 = typename enable_if |
3785 | < |
3786 | is_member_object_pointer<_DecayFp>::value |
3787 | && is_base_of<_ClassT, _DecayA0>::value |
3788 | >::type; |
3789 | |
3790 | template <class _Fp, class _A0, |
3791 | class _DecayFp = typename decay<_Fp>::type, |
3792 | class _DecayA0 = typename decay<_A0>::type> |
3793 | using __enable_if_bullet5 = typename enable_if |
3794 | < |
3795 | is_member_object_pointer<_DecayFp>::value |
3796 | && __is_reference_wrapper<_DecayA0>::value |
3797 | >::type; |
3798 | |
3799 | template <class _Fp, class _A0, |
3800 | class _DecayFp = typename decay<_Fp>::type, |
3801 | class _DecayA0 = typename decay<_A0>::type, |
3802 | class _ClassT = typename __member_pointer_class_type<_DecayFp>::type> |
3803 | using __enable_if_bullet6 = typename enable_if |
3804 | < |
3805 | is_member_object_pointer<_DecayFp>::value |
3806 | && !is_base_of<_ClassT, _DecayA0>::value |
3807 | && !__is_reference_wrapper<_DecayA0>::value |
3808 | >::type; |
3809 | |
3810 | // __invoke forward declarations |
3811 | |
3812 | // fall back - none of the bullets |
3813 | |
3814 | #define _LIBCPP_INVOKE_RETURN(...) \ |
3815 | noexcept(noexcept(__VA_ARGS__)) -> decltype(__VA_ARGS__) \ |
3816 | { return __VA_ARGS__; } |
3817 | |
3818 | template <class ..._Args> |
3819 | auto __invoke(__any, _Args&& ...__args) -> __nat; |
3820 | |
3821 | template <class ..._Args> |
3822 | auto __invoke_constexpr(__any, _Args&& ...__args) -> __nat; |
3823 | |
3824 | // bullets 1, 2 and 3 |
3825 | |
3826 | template <class _Fp, class _A0, class ..._Args, |
3827 | class = __enable_if_bullet1<_Fp, _A0>> |
3828 | inline _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__ )) |
3829 | _LIBCPP_CONSTEXPR_AFTER_CXX17 auto |
3830 | __invoke(_Fp&& __f, _A0&& __a0, _Args&& ...__args) |
3831 | _LIBCPP_INVOKE_RETURN((static_cast<_A0&&>(__a0).*__f)(static_cast<_Args&&>(__args)...)) |
3832 | |
3833 | template <class _Fp, class _A0, class ..._Args, |
3834 | class = __enable_if_bullet1<_Fp, _A0>> |
3835 | inline _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__ )) |
3836 | _LIBCPP_CONSTEXPRconstexpr auto |
3837 | __invoke_constexpr(_Fp&& __f, _A0&& __a0, _Args&& ...__args) |
3838 | _LIBCPP_INVOKE_RETURN((static_cast<_A0&&>(__a0).*__f)(static_cast<_Args&&>(__args)...)) |
3839 | |
3840 | template <class _Fp, class _A0, class ..._Args, |
3841 | class = __enable_if_bullet2<_Fp, _A0>> |
3842 | inline _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__ )) |
3843 | _LIBCPP_CONSTEXPR_AFTER_CXX17 auto |
3844 | __invoke(_Fp&& __f, _A0&& __a0, _Args&& ...__args) |
3845 | _LIBCPP_INVOKE_RETURN((__a0.get().*__f)(static_cast<_Args&&>(__args)...)) |
3846 | |
3847 | template <class _Fp, class _A0, class ..._Args, |
3848 | class = __enable_if_bullet2<_Fp, _A0>> |
3849 | inline _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__ )) |
3850 | _LIBCPP_CONSTEXPRconstexpr auto |
3851 | __invoke_constexpr(_Fp&& __f, _A0&& __a0, _Args&& ...__args) |
3852 | _LIBCPP_INVOKE_RETURN((__a0.get().*__f)(static_cast<_Args&&>(__args)...)) |
3853 | |
3854 | template <class _Fp, class _A0, class ..._Args, |
3855 | class = __enable_if_bullet3<_Fp, _A0>> |
3856 | inline _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__ )) |
3857 | _LIBCPP_CONSTEXPR_AFTER_CXX17 auto |
3858 | __invoke(_Fp&& __f, _A0&& __a0, _Args&& ...__args) |
3859 | _LIBCPP_INVOKE_RETURN(((*static_cast<_A0&&>(__a0)).*__f)(static_cast<_Args&&>(__args)...)) |
3860 | |
3861 | template <class _Fp, class _A0, class ..._Args, |
3862 | class = __enable_if_bullet3<_Fp, _A0>> |
3863 | inline _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__ )) |
3864 | _LIBCPP_CONSTEXPRconstexpr auto |
3865 | __invoke_constexpr(_Fp&& __f, _A0&& __a0, _Args&& ...__args) |
3866 | _LIBCPP_INVOKE_RETURN(((*static_cast<_A0&&>(__a0)).*__f)(static_cast<_Args&&>(__args)...)) |
3867 | |
3868 | // bullets 4, 5 and 6 |
3869 | |
3870 | template <class _Fp, class _A0, |
3871 | class = __enable_if_bullet4<_Fp, _A0>> |
3872 | inline _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__ )) |
3873 | _LIBCPP_CONSTEXPR_AFTER_CXX17 auto |
3874 | __invoke(_Fp&& __f, _A0&& __a0) |
3875 | _LIBCPP_INVOKE_RETURN(static_cast<_A0&&>(__a0).*__f) |
3876 | |
3877 | template <class _Fp, class _A0, |
3878 | class = __enable_if_bullet4<_Fp, _A0>> |
3879 | inline _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__ )) |
3880 | _LIBCPP_CONSTEXPRconstexpr auto |
3881 | __invoke_constexpr(_Fp&& __f, _A0&& __a0) |
3882 | _LIBCPP_INVOKE_RETURN(static_cast<_A0&&>(__a0).*__f) |
3883 | |
3884 | template <class _Fp, class _A0, |
3885 | class = __enable_if_bullet5<_Fp, _A0>> |
3886 | inline _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__ )) |
3887 | _LIBCPP_CONSTEXPR_AFTER_CXX17 auto |
3888 | __invoke(_Fp&& __f, _A0&& __a0) |
3889 | _LIBCPP_INVOKE_RETURN(__a0.get().*__f) |
3890 | |
3891 | template <class _Fp, class _A0, |
3892 | class = __enable_if_bullet5<_Fp, _A0>> |
3893 | inline _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__ )) |
3894 | _LIBCPP_CONSTEXPRconstexpr auto |
3895 | __invoke_constexpr(_Fp&& __f, _A0&& __a0) |
3896 | _LIBCPP_INVOKE_RETURN(__a0.get().*__f) |
3897 | |
3898 | template <class _Fp, class _A0, |
3899 | class = __enable_if_bullet6<_Fp, _A0>> |
3900 | inline _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__ )) |
3901 | _LIBCPP_CONSTEXPR_AFTER_CXX17 auto |
3902 | __invoke(_Fp&& __f, _A0&& __a0) |
3903 | _LIBCPP_INVOKE_RETURN((*static_cast<_A0&&>(__a0)).*__f) |
3904 | |
3905 | template <class _Fp, class _A0, |
3906 | class = __enable_if_bullet6<_Fp, _A0>> |
3907 | inline _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__ )) |
3908 | _LIBCPP_CONSTEXPRconstexpr auto |
3909 | __invoke_constexpr(_Fp&& __f, _A0&& __a0) |
3910 | _LIBCPP_INVOKE_RETURN((*static_cast<_A0&&>(__a0)).*__f) |
3911 | |
3912 | // bullet 7 |
3913 | |
3914 | template <class _Fp, class ..._Args> |
3915 | inline _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__ )) |
3916 | _LIBCPP_CONSTEXPR_AFTER_CXX17 auto |
3917 | __invoke(_Fp&& __f, _Args&& ...__args) |
3918 | _LIBCPP_INVOKE_RETURN(static_cast<_Fp&&>(__f)(static_cast<_Args&&>(__args)...)) |
3919 | |
3920 | template <class _Fp, class ..._Args> |
3921 | inline _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__ )) |
3922 | _LIBCPP_CONSTEXPRconstexpr auto |
3923 | __invoke_constexpr(_Fp&& __f, _Args&& ...__args) |
3924 | _LIBCPP_INVOKE_RETURN(static_cast<_Fp&&>(__f)(static_cast<_Args&&>(__args)...)) |
3925 | |
3926 | #undef _LIBCPP_INVOKE_RETURN |
3927 | |
3928 | // __invokable |
3929 | template <class _Ret, class _Fp, class ..._Args> |
3930 | struct __invokable_r |
3931 | { |
3932 | template <class _XFp, class ..._XArgs> |
3933 | static auto __try_call(int) -> decltype( |
3934 | _VSTDstd::__1::__invoke(declval<_XFp>(), declval<_XArgs>()...)); |
3935 | template <class _XFp, class ..._XArgs> |
3936 | static __nat __try_call(...); |
3937 | |
3938 | // FIXME: Check that _Ret, _Fp, and _Args... are all complete types, cv void, |
3939 | // or incomplete array types as required by the standard. |
3940 | using _Result = decltype(__try_call<_Fp, _Args...>(0)); |
3941 | |
3942 | using type = |
3943 | typename conditional< |
3944 | _IsNotSame<_Result, __nat>::value, |
3945 | typename conditional< |
3946 | is_void<_Ret>::value, |
3947 | true_type, |
3948 | is_convertible<_Result, _Ret> |
3949 | >::type, |
3950 | false_type |
3951 | >::type; |
3952 | static const bool value = type::value; |
3953 | }; |
3954 | template <class _Fp, class ..._Args> |
3955 | using __invokable = __invokable_r<void, _Fp, _Args...>; |
3956 | |
3957 | template <bool _IsInvokable, bool _IsCVVoid, class _Ret, class _Fp, class ..._Args> |
3958 | struct __nothrow_invokable_r_imp { |
3959 | static const bool value = false; |
3960 | }; |
3961 | |
3962 | template <class _Ret, class _Fp, class ..._Args> |
3963 | struct __nothrow_invokable_r_imp<true, false, _Ret, _Fp, _Args...> |
3964 | { |
3965 | typedef __nothrow_invokable_r_imp _ThisT; |
3966 | |
3967 | template <class _Tp> |
3968 | static void __test_noexcept(_Tp) noexcept; |
3969 | |
3970 | static const bool value = noexcept(_ThisT::__test_noexcept<_Ret>( |
3971 | _VSTDstd::__1::__invoke(declval<_Fp>(), declval<_Args>()...))); |
3972 | }; |
3973 | |
3974 | template <class _Ret, class _Fp, class ..._Args> |
3975 | struct __nothrow_invokable_r_imp<true, true, _Ret, _Fp, _Args...> |
3976 | { |
3977 | static const bool value = noexcept( |
3978 | _VSTDstd::__1::__invoke(declval<_Fp>(), declval<_Args>()...)); |
3979 | }; |
3980 | |
3981 | template <class _Ret, class _Fp, class ..._Args> |
3982 | using __nothrow_invokable_r = |
3983 | __nothrow_invokable_r_imp< |
3984 | __invokable_r<_Ret, _Fp, _Args...>::value, |
3985 | is_void<_Ret>::value, |
3986 | _Ret, _Fp, _Args... |
3987 | >; |
3988 | |
3989 | template <class _Fp, class ..._Args> |
3990 | using __nothrow_invokable = |
3991 | __nothrow_invokable_r_imp< |
3992 | __invokable<_Fp, _Args...>::value, |
3993 | true, void, _Fp, _Args... |
3994 | >; |
3995 | |
3996 | template <class _Fp, class ..._Args> |
3997 | struct __invoke_of |
3998 | : public enable_if< |
3999 | __invokable<_Fp, _Args...>::value, |
4000 | typename __invokable_r<void, _Fp, _Args...>::_Result> |
4001 | { |
4002 | }; |
4003 | |
4004 | #endif // _LIBCPP_CXX03_LANG |
4005 | |
4006 | // result_of |
4007 | |
4008 | #if _LIBCPP_STD_VER14 <= 17 || defined(_LIBCPP_ENABLE_CXX20_REMOVED_TYPE_TRAITS) |
4009 | template <class _Callable> class _LIBCPP_DEPRECATED_IN_CXX17 result_of; |
4010 | |
4011 | #ifndef _LIBCPP_CXX03_LANG |
4012 | |
4013 | template <class _Fp, class ..._Args> |
4014 | class _LIBCPP_TEMPLATE_VIS__attribute__ ((__type_visibility__("default"))) result_of<_Fp(_Args...)> |
4015 | : public __invoke_of<_Fp, _Args...> |
4016 | { |
4017 | }; |
4018 | |
4019 | #else // C++03 |
4020 | |
4021 | template <class _Fn, bool, bool> |
4022 | class __result_of |
4023 | { |
4024 | }; |
4025 | |
4026 | template <class _Fn, class ..._Args> |
4027 | class __result_of<_Fn(_Args...), true, false> |
4028 | { |
4029 | public: |
4030 | typedef decltype(declval<_Fn>()(declval<_Args>()...)) type; |
4031 | }; |
4032 | |
4033 | template <class _MP, class _Tp, bool _IsMemberFunctionPtr> |
4034 | struct __result_of_mp; |
4035 | |
4036 | // member function pointer |
4037 | |
4038 | template <class _MP, class _Tp> |
4039 | struct __result_of_mp<_MP, _Tp, true> |
4040 | { |
4041 | using type = typename __member_pointer_traits<_MP>::_ReturnType; |
4042 | }; |
4043 | |
4044 | // member data pointer |
4045 | |
4046 | template <class _MP, class _Tp, bool> |
4047 | struct __result_of_mdp; |
4048 | |
4049 | template <class _Rp, class _Class, class _Tp> |
4050 | struct __result_of_mdp<_Rp _Class::*, _Tp, false> |
4051 | { |
4052 | using type = typename __apply_cv<decltype(*declval<_Tp>()), _Rp>::type&; |
4053 | }; |
4054 | |
4055 | template <class _Rp, class _Class, class _Tp> |
4056 | struct __result_of_mdp<_Rp _Class::*, _Tp, true> |
4057 | { |
4058 | using type = typename __apply_cv<_Tp, _Rp>::type&; |
4059 | }; |
4060 | |
4061 | template <class _Rp, class _Class, class _Tp> |
4062 | struct __result_of_mp<_Rp _Class::*, _Tp, false> |
4063 | : public __result_of_mdp<_Rp _Class::*, _Tp, |
4064 | is_base_of<_Class, typename remove_reference<_Tp>::type>::value> |
4065 | { |
4066 | }; |
4067 | |
4068 | template <class _Fn, class _Tp> |
4069 | class __result_of<_Fn(_Tp), false, true> // _Fn must be member pointer |
4070 | : public __result_of_mp<typename remove_reference<_Fn>::type, |
4071 | _Tp, |
4072 | is_member_function_pointer<typename remove_reference<_Fn>::type>::value> |
4073 | { |
4074 | }; |
4075 | |
4076 | template <class _Fn, class _Tp, class ..._Args> |
4077 | class __result_of<_Fn(_Tp, _Args...), false, true> // _Fn must be member pointer |
4078 | : public __result_of_mp<typename remove_reference<_Fn>::type, |
4079 | _Tp, |
4080 | is_member_function_pointer<typename remove_reference<_Fn>::type>::value> |
4081 | { |
4082 | }; |
4083 | |
4084 | template <class _Fn, class ..._Args> |
4085 | class _LIBCPP_TEMPLATE_VIS__attribute__ ((__type_visibility__("default"))) result_of<_Fn(_Args...)> |
4086 | : public __result_of<_Fn(_Args...), |
4087 | is_class<typename remove_reference<_Fn>::type>::value || |
4088 | is_function<typename remove_pointer<typename remove_reference<_Fn>::type>::type>::value, |
4089 | is_member_pointer<typename remove_reference<_Fn>::type>::value |
4090 | > |
4091 | { |
4092 | }; |
4093 | |
4094 | #endif // C++03 |
4095 | |
4096 | #if _LIBCPP_STD_VER14 > 11 |
4097 | template <class _Tp> using result_of_t _LIBCPP_DEPRECATED_IN_CXX17 = typename result_of<_Tp>::type; |
4098 | #endif // _LIBCPP_STD_VER > 11 |
4099 | #endif // _LIBCPP_STD_VER <= 17 || defined(_LIBCPP_ENABLE_CXX20_REMOVED_TYPE_TRAITS) |
4100 | |
4101 | #if _LIBCPP_STD_VER14 > 14 |
4102 | |
4103 | // invoke_result |
4104 | |
4105 | template <class _Fn, class... _Args> |
4106 | struct _LIBCPP_TEMPLATE_VIS__attribute__ ((__type_visibility__("default"))) invoke_result |
4107 | : __invoke_of<_Fn, _Args...> |
4108 | { |
4109 | }; |
4110 | |
4111 | template <class _Fn, class... _Args> |
4112 | using invoke_result_t = typename invoke_result<_Fn, _Args...>::type; |
4113 | |
4114 | // is_invocable |
4115 | |
4116 | template <class _Fn, class ..._Args> |
4117 | struct _LIBCPP_TEMPLATE_VIS__attribute__ ((__type_visibility__("default"))) is_invocable |
4118 | : integral_constant<bool, __invokable<_Fn, _Args...>::value> {}; |
4119 | |
4120 | template <class _Ret, class _Fn, class ..._Args> |
4121 | struct _LIBCPP_TEMPLATE_VIS__attribute__ ((__type_visibility__("default"))) is_invocable_r |
4122 | : integral_constant<bool, __invokable_r<_Ret, _Fn, _Args...>::value> {}; |
4123 | |
4124 | template <class _Fn, class ..._Args> |
4125 | _LIBCPP_INLINE_VAR constexpr bool is_invocable_v |
4126 | = is_invocable<_Fn, _Args...>::value; |
4127 | |
4128 | template <class _Ret, class _Fn, class ..._Args> |
4129 | _LIBCPP_INLINE_VAR constexpr bool is_invocable_r_v |
4130 | = is_invocable_r<_Ret, _Fn, _Args...>::value; |
4131 | |
4132 | // is_nothrow_invocable |
4133 | |
4134 | template <class _Fn, class ..._Args> |
4135 | struct _LIBCPP_TEMPLATE_VIS__attribute__ ((__type_visibility__("default"))) is_nothrow_invocable |
4136 | : integral_constant<bool, __nothrow_invokable<_Fn, _Args...>::value> {}; |
4137 | |
4138 | template <class _Ret, class _Fn, class ..._Args> |
4139 | struct _LIBCPP_TEMPLATE_VIS__attribute__ ((__type_visibility__("default"))) is_nothrow_invocable_r |
4140 | : integral_constant<bool, __nothrow_invokable_r<_Ret, _Fn, _Args...>::value> {}; |
4141 | |
4142 | template <class _Fn, class ..._Args> |
4143 | _LIBCPP_INLINE_VAR constexpr bool is_nothrow_invocable_v |
4144 | = is_nothrow_invocable<_Fn, _Args...>::value; |
4145 | |
4146 | template <class _Ret, class _Fn, class ..._Args> |
4147 | _LIBCPP_INLINE_VAR constexpr bool is_nothrow_invocable_r_v |
4148 | = is_nothrow_invocable_r<_Ret, _Fn, _Args...>::value; |
4149 | |
4150 | #endif // _LIBCPP_STD_VER > 14 |
4151 | |
4152 | // __swappable |
4153 | |
4154 | template <class _Tp> struct __is_swappable; |
4155 | template <class _Tp> struct __is_nothrow_swappable; |
4156 | |
4157 | |
4158 | #ifndef _LIBCPP_CXX03_LANG |
4159 | template <class _Tp> |
4160 | using __swap_result_t = typename enable_if<is_move_constructible<_Tp>::value && is_move_assignable<_Tp>::value>::type; |
4161 | #else |
4162 | template <class> |
4163 | using __swap_result_t = void; |
4164 | #endif |
4165 | |
4166 | template <class _Tp> |
4167 | inline _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__ )) |
4168 | _LIBCPP_CONSTEXPR_AFTER_CXX17 __swap_result_t<_Tp> |
4169 | swap(_Tp& __x, _Tp& __y) _NOEXCEPT_(is_nothrow_move_constructible<_Tp>::value &&noexcept(is_nothrow_move_constructible<_Tp>::value && is_nothrow_move_assignable<_Tp>::value) |
4170 | is_nothrow_move_assignable<_Tp>::value)noexcept(is_nothrow_move_constructible<_Tp>::value && is_nothrow_move_assignable<_Tp>::value); |
4171 | |
4172 | template<class _Tp, size_t _Np> |
4173 | inline _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__ )) _LIBCPP_CONSTEXPR_AFTER_CXX17 |
4174 | typename enable_if< |
4175 | __is_swappable<_Tp>::value |
4176 | >::type |
4177 | swap(_Tp (&__a)[_Np], _Tp (&__b)[_Np]) _NOEXCEPT_(__is_nothrow_swappable<_Tp>::value)noexcept(__is_nothrow_swappable<_Tp>::value); |
4178 | |
4179 | namespace __detail |
4180 | { |
4181 | // ALL generic swap overloads MUST already have a declaration available at this point. |
4182 | |
4183 | template <class _Tp, class _Up = _Tp, |
4184 | bool _NotVoid = !is_void<_Tp>::value && !is_void<_Up>::value> |
4185 | struct __swappable_with |
4186 | { |
4187 | template <class _LHS, class _RHS> |
4188 | static decltype(swap(declval<_LHS>(), declval<_RHS>())) |
4189 | __test_swap(int); |
4190 | template <class, class> |
4191 | static __nat __test_swap(long); |
4192 | |
4193 | // Extra parens are needed for the C++03 definition of decltype. |
4194 | typedef decltype((__test_swap<_Tp, _Up>(0))) __swap1; |
4195 | typedef decltype((__test_swap<_Up, _Tp>(0))) __swap2; |
4196 | |
4197 | static const bool value = _IsNotSame<__swap1, __nat>::value |
4198 | && _IsNotSame<__swap2, __nat>::value; |
4199 | }; |
4200 | |
4201 | template <class _Tp, class _Up> |
4202 | struct __swappable_with<_Tp, _Up, false> : false_type {}; |
4203 | |
4204 | template <class _Tp, class _Up = _Tp, bool _Swappable = __swappable_with<_Tp, _Up>::value> |
4205 | struct __nothrow_swappable_with { |
4206 | static const bool value = |
4207 | #ifndef _LIBCPP_HAS_NO_NOEXCEPT |
4208 | noexcept(swap(declval<_Tp>(), declval<_Up>())) |
4209 | && noexcept(swap(declval<_Up>(), declval<_Tp>())); |
4210 | #else |
4211 | false; |
4212 | #endif |
4213 | }; |
4214 | |
4215 | template <class _Tp, class _Up> |
4216 | struct __nothrow_swappable_with<_Tp, _Up, false> : false_type {}; |
4217 | |
4218 | } // __detail |
4219 | |
4220 | template <class _Tp> |
4221 | struct __is_swappable |
4222 | : public integral_constant<bool, __detail::__swappable_with<_Tp&>::value> |
4223 | { |
4224 | }; |
4225 | |
4226 | template <class _Tp> |
4227 | struct __is_nothrow_swappable |
4228 | : public integral_constant<bool, __detail::__nothrow_swappable_with<_Tp&>::value> |
4229 | { |
4230 | }; |
4231 | |
4232 | #if _LIBCPP_STD_VER14 > 14 |
4233 | |
4234 | template <class _Tp, class _Up> |
4235 | struct _LIBCPP_TEMPLATE_VIS__attribute__ ((__type_visibility__("default"))) is_swappable_with |
4236 | : public integral_constant<bool, __detail::__swappable_with<_Tp, _Up>::value> |
4237 | { |
4238 | }; |
4239 | |
4240 | template <class _Tp> |
4241 | struct _LIBCPP_TEMPLATE_VIS__attribute__ ((__type_visibility__("default"))) is_swappable |
4242 | : public conditional< |
4243 | __is_referenceable<_Tp>::value, |
4244 | is_swappable_with< |
4245 | typename add_lvalue_reference<_Tp>::type, |
4246 | typename add_lvalue_reference<_Tp>::type>, |
4247 | false_type |
4248 | >::type |
4249 | { |
4250 | }; |
4251 | |
4252 | template <class _Tp, class _Up> |
4253 | struct _LIBCPP_TEMPLATE_VIS__attribute__ ((__type_visibility__("default"))) is_nothrow_swappable_with |
4254 | : public integral_constant<bool, __detail::__nothrow_swappable_with<_Tp, _Up>::value> |
4255 | { |
4256 | }; |
4257 | |
4258 | template <class _Tp> |
4259 | struct _LIBCPP_TEMPLATE_VIS__attribute__ ((__type_visibility__("default"))) is_nothrow_swappable |
4260 | : public conditional< |
4261 | __is_referenceable<_Tp>::value, |
4262 | is_nothrow_swappable_with< |
4263 | typename add_lvalue_reference<_Tp>::type, |
4264 | typename add_lvalue_reference<_Tp>::type>, |
4265 | false_type |
4266 | >::type |
4267 | { |
4268 | }; |
4269 | |
4270 | template <class _Tp, class _Up> |
4271 | _LIBCPP_INLINE_VAR constexpr bool is_swappable_with_v |
4272 | = is_swappable_with<_Tp, _Up>::value; |
4273 | |
4274 | template <class _Tp> |
4275 | _LIBCPP_INLINE_VAR constexpr bool is_swappable_v |
4276 | = is_swappable<_Tp>::value; |
4277 | |
4278 | template <class _Tp, class _Up> |
4279 | _LIBCPP_INLINE_VAR constexpr bool is_nothrow_swappable_with_v |
4280 | = is_nothrow_swappable_with<_Tp, _Up>::value; |
4281 | |
4282 | template <class _Tp> |
4283 | _LIBCPP_INLINE_VAR constexpr bool is_nothrow_swappable_v |
4284 | = is_nothrow_swappable<_Tp>::value; |
4285 | |
4286 | #endif // _LIBCPP_STD_VER > 14 |
4287 | |
4288 | template <class _Tp, bool = is_enum<_Tp>::value> struct __underlying_type_impl; |
4289 | |
4290 | template <class _Tp> |
4291 | struct __underlying_type_impl<_Tp, false> {}; |
4292 | |
4293 | template <class _Tp> |
4294 | struct __underlying_type_impl<_Tp, true> |
4295 | { |
4296 | typedef __underlying_type(_Tp) type; |
4297 | }; |
4298 | |
4299 | template <class _Tp> |
4300 | struct underlying_type : __underlying_type_impl<_Tp, is_enum<_Tp>::value> {}; |
4301 | |
4302 | #if _LIBCPP_STD_VER14 > 11 |
4303 | template <class _Tp> using underlying_type_t = typename underlying_type<_Tp>::type; |
4304 | #endif |
4305 | |
4306 | template <class _Tp, bool = is_enum<_Tp>::value> |
4307 | struct __sfinae_underlying_type |
4308 | { |
4309 | typedef typename underlying_type<_Tp>::type type; |
4310 | typedef decltype(((type)1) + 0) __promoted_type; |
4311 | }; |
4312 | |
4313 | template <class _Tp> |
4314 | struct __sfinae_underlying_type<_Tp, false> {}; |
4315 | |
4316 | inline _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__ )) _LIBCPP_CONSTEXPRconstexpr |
4317 | int __convert_to_integral(int __val) { return __val; } |
4318 | |
4319 | inline _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__ )) _LIBCPP_CONSTEXPRconstexpr |
4320 | unsigned __convert_to_integral(unsigned __val) { return __val; } |
4321 | |
4322 | inline _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__ )) _LIBCPP_CONSTEXPRconstexpr |
4323 | long __convert_to_integral(long __val) { return __val; } |
4324 | |
4325 | inline _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__ )) _LIBCPP_CONSTEXPRconstexpr |
4326 | unsigned long __convert_to_integral(unsigned long __val) { return __val; } |
4327 | |
4328 | inline _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__ )) _LIBCPP_CONSTEXPRconstexpr |
4329 | long long __convert_to_integral(long long __val) { return __val; } |
4330 | |
4331 | inline _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__ )) _LIBCPP_CONSTEXPRconstexpr |
4332 | unsigned long long __convert_to_integral(unsigned long long __val) {return __val; } |
4333 | |
4334 | template<typename _Fp> |
4335 | inline _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__ )) _LIBCPP_CONSTEXPRconstexpr |
4336 | typename enable_if<is_floating_point<_Fp>::value, long long>::type |
4337 | __convert_to_integral(_Fp __val) { return __val; } |
4338 | |
4339 | #ifndef _LIBCPP_HAS_NO_INT128 |
4340 | inline _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__ )) _LIBCPP_CONSTEXPRconstexpr |
4341 | __int128_t __convert_to_integral(__int128_t __val) { return __val; } |
4342 | |
4343 | inline _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__ )) _LIBCPP_CONSTEXPRconstexpr |
4344 | __uint128_t __convert_to_integral(__uint128_t __val) { return __val; } |
4345 | #endif |
4346 | |
4347 | template <class _Tp> |
4348 | inline _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__ )) _LIBCPP_CONSTEXPRconstexpr |
4349 | typename __sfinae_underlying_type<_Tp>::__promoted_type |
4350 | __convert_to_integral(_Tp __val) { return __val; } |
4351 | |
4352 | #ifndef _LIBCPP_CXX03_LANG |
4353 | |
4354 | template <class _Tp> |
4355 | struct __has_operator_addressof_member_imp |
4356 | { |
4357 | template <class _Up> |
4358 | static auto __test(int) |
4359 | -> typename __select_2nd<decltype(declval<_Up>().operator&()), true_type>::type; |
4360 | template <class> |
4361 | static auto __test(long) -> false_type; |
4362 | |
4363 | static const bool value = decltype(__test<_Tp>(0))::value; |
4364 | }; |
4365 | |
4366 | template <class _Tp> |
4367 | struct __has_operator_addressof_free_imp |
4368 | { |
4369 | template <class _Up> |
4370 | static auto __test(int) |
4371 | -> typename __select_2nd<decltype(operator&(declval<_Up>())), true_type>::type; |
4372 | template <class> |
4373 | static auto __test(long) -> false_type; |
4374 | |
4375 | static const bool value = decltype(__test<_Tp>(0))::value; |
4376 | }; |
4377 | |
4378 | template <class _Tp> |
4379 | struct __has_operator_addressof |
4380 | : public integral_constant<bool, __has_operator_addressof_member_imp<_Tp>::value |
4381 | || __has_operator_addressof_free_imp<_Tp>::value> |
4382 | {}; |
4383 | |
4384 | #endif // _LIBCPP_CXX03_LANG |
4385 | |
4386 | // is_scoped_enum [meta.unary.prop] |
4387 | |
4388 | #if _LIBCPP_STD_VER14 > 20 |
4389 | template <class _Tp, bool = is_enum_v<_Tp> > |
4390 | struct __is_scoped_enum_helper : false_type {}; |
4391 | |
4392 | template <class _Tp> |
4393 | struct __is_scoped_enum_helper<_Tp, true> |
4394 | : public bool_constant<!is_convertible_v<_Tp, underlying_type_t<_Tp> > > {}; |
4395 | |
4396 | template <class _Tp> |
4397 | struct _LIBCPP_TEMPLATE_VIS__attribute__ ((__type_visibility__("default"))) is_scoped_enum |
4398 | : public __is_scoped_enum_helper<_Tp> {}; |
4399 | |
4400 | template <class _Tp> |
4401 | _LIBCPP_INLINE_VAR _LIBCPP_CONSTEXPRconstexpr bool is_scoped_enum_v = |
4402 | is_scoped_enum<_Tp>::value; |
4403 | #endif |
4404 | |
4405 | #if _LIBCPP_STD_VER14 > 14 |
4406 | |
4407 | template <class... _Args> |
4408 | struct conjunction : _And<_Args...> {}; |
4409 | template<class... _Args> |
4410 | _LIBCPP_INLINE_VAR constexpr bool conjunction_v |
4411 | = conjunction<_Args...>::value; |
4412 | |
4413 | template <class... _Args> |
4414 | struct disjunction : _Or<_Args...> {}; |
4415 | template<class... _Args> |
4416 | _LIBCPP_INLINE_VAR constexpr bool disjunction_v |
4417 | = disjunction<_Args...>::value; |
4418 | |
4419 | template <class _Tp> |
4420 | struct negation : _Not<_Tp> {}; |
4421 | template<class _Tp> |
4422 | _LIBCPP_INLINE_VAR constexpr bool negation_v |
4423 | = negation<_Tp>::value; |
4424 | #endif // _LIBCPP_STD_VER > 14 |
4425 | |
4426 | // These traits are used in __tree and __hash_table |
4427 | struct __extract_key_fail_tag {}; |
4428 | struct __extract_key_self_tag {}; |
4429 | struct __extract_key_first_tag {}; |
4430 | |
4431 | template <class _ValTy, class _Key, |
4432 | class _RawValTy = typename __unconstref<_ValTy>::type> |
4433 | struct __can_extract_key |
4434 | : conditional<_IsSame<_RawValTy, _Key>::value, __extract_key_self_tag, |
4435 | __extract_key_fail_tag>::type {}; |
4436 | |
4437 | template <class _Pair, class _Key, class _First, class _Second> |
4438 | struct __can_extract_key<_Pair, _Key, pair<_First, _Second> > |
4439 | : conditional<_IsSame<typename remove_const<_First>::type, _Key>::value, |
4440 | __extract_key_first_tag, __extract_key_fail_tag>::type {}; |
4441 | |
4442 | // __can_extract_map_key uses true_type/false_type instead of the tags. |
4443 | // It returns true if _Key != _ContainerValueTy (the container is a map not a set) |
4444 | // and _ValTy == _Key. |
4445 | template <class _ValTy, class _Key, class _ContainerValueTy, |
4446 | class _RawValTy = typename __unconstref<_ValTy>::type> |
4447 | struct __can_extract_map_key |
4448 | : integral_constant<bool, _IsSame<_RawValTy, _Key>::value> {}; |
4449 | |
4450 | // This specialization returns __extract_key_fail_tag for non-map containers |
4451 | // because _Key == _ContainerValueTy |
4452 | template <class _ValTy, class _Key, class _RawValTy> |
4453 | struct __can_extract_map_key<_ValTy, _Key, _Key, _RawValTy> |
4454 | : false_type {}; |
4455 | |
4456 | #ifndef _LIBCPP_HAS_NO_BUILTIN_IS_CONSTANT_EVALUATED |
4457 | #if _LIBCPP_STD_VER14 > 17 |
4458 | _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__ )) |
4459 | inline constexpr bool is_constant_evaluated() noexcept { |
4460 | return __builtin_is_constant_evaluated(); |
4461 | } |
4462 | #endif |
4463 | |
4464 | inline _LIBCPP_CONSTEXPRconstexpr |
4465 | bool __libcpp_is_constant_evaluated() _NOEXCEPTnoexcept { return __builtin_is_constant_evaluated(); } |
4466 | #else |
4467 | inline _LIBCPP_CONSTEXPRconstexpr |
4468 | bool __libcpp_is_constant_evaluated() _NOEXCEPTnoexcept { return false; } |
4469 | #endif |
4470 | |
4471 | template <class _CharT> |
4472 | using _IsCharLikeType = _And<is_standard_layout<_CharT>, is_trivial<_CharT> >; |
4473 | |
4474 | template<class _Tp> |
4475 | using __make_const_lvalue_ref = const typename remove_reference<_Tp>::type&; |
4476 | |
4477 | #if _LIBCPP_STD_VER14 > 17 |
4478 | template<bool _Const, class _Tp> |
4479 | using __maybe_const = conditional_t<_Const, const _Tp, _Tp>; |
4480 | #endif // _LIBCPP_STD_VER > 17 |
4481 | |
4482 | _LIBCPP_END_NAMESPACE_STD} } |
4483 | |
4484 | #if _LIBCPP_STD_VER14 > 14 |
4485 | // std::byte |
4486 | namespace std // purposefully not versioned |
4487 | { |
4488 | |
4489 | |
4490 | } |
4491 | #endif |
4492 | |
4493 | #endif // _LIBCPP_TYPE_TRAITS |
1 | // -*- C++ -*- |
2 | //===------------------------- fstream ------------------------------------===// |
3 | // |
4 | // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. |
5 | // See https://llvm.org/LICENSE.txt for license information. |
6 | // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception |
7 | // |
8 | //===----------------------------------------------------------------------===// |
9 | |
10 | #ifndef _LIBCPP_FSTREAM |
11 | #define _LIBCPP_FSTREAM |
12 | |
13 | /* |
14 | fstream synopsis |
15 | |
16 | template <class charT, class traits = char_traits<charT> > |
17 | class basic_filebuf |
18 | : public basic_streambuf<charT, traits> |
19 | { |
20 | public: |
21 | typedef charT char_type; |
22 | typedef traits traits_type; |
23 | typedef typename traits_type::int_type int_type; |
24 | typedef typename traits_type::pos_type pos_type; |
25 | typedef typename traits_type::off_type off_type; |
26 | |
27 | // 27.9.1.2 Constructors/destructor: |
28 | basic_filebuf(); |
29 | basic_filebuf(basic_filebuf&& rhs); |
30 | virtual ~basic_filebuf(); |
31 | |
32 | // 27.9.1.3 Assign/swap: |
33 | basic_filebuf& operator=(basic_filebuf&& rhs); |
34 | void swap(basic_filebuf& rhs); |
35 | |
36 | // 27.9.1.4 Members: |
37 | bool is_open() const; |
38 | basic_filebuf* open(const char* s, ios_base::openmode mode); |
39 | basic_filebuf* open(const string& s, ios_base::openmode mode); |
40 | basic_filebuf* open(const filesystem::path& p, ios_base::openmode mode); // C++17 |
41 | basic_filebuf* close(); |
42 | |
43 | protected: |
44 | // 27.9.1.5 Overridden virtual functions: |
45 | virtual streamsize showmanyc(); |
46 | virtual int_type underflow(); |
47 | virtual int_type uflow(); |
48 | virtual int_type pbackfail(int_type c = traits_type::eof()); |
49 | virtual int_type overflow (int_type c = traits_type::eof()); |
50 | virtual basic_streambuf<char_type, traits_type>* setbuf(char_type* s, streamsize n); |
51 | virtual pos_type seekoff(off_type off, ios_base::seekdir way, |
52 | ios_base::openmode which = ios_base::in | ios_base::out); |
53 | virtual pos_type seekpos(pos_type sp, |
54 | ios_base::openmode which = ios_base::in | ios_base::out); |
55 | virtual int sync(); |
56 | virtual void imbue(const locale& loc); |
57 | }; |
58 | |
59 | template <class charT, class traits> |
60 | void |
61 | swap(basic_filebuf<charT, traits>& x, basic_filebuf<charT, traits>& y); |
62 | |
63 | typedef basic_filebuf<char> filebuf; |
64 | typedef basic_filebuf<wchar_t> wfilebuf; |
65 | |
66 | template <class charT, class traits = char_traits<charT> > |
67 | class basic_ifstream |
68 | : public basic_istream<charT,traits> |
69 | { |
70 | public: |
71 | typedef charT char_type; |
72 | typedef traits traits_type; |
73 | typedef typename traits_type::int_type int_type; |
74 | typedef typename traits_type::pos_type pos_type; |
75 | typedef typename traits_type::off_type off_type; |
76 | |
77 | basic_ifstream(); |
78 | explicit basic_ifstream(const char* s, ios_base::openmode mode = ios_base::in); |
79 | explicit basic_ifstream(const string& s, ios_base::openmode mode = ios_base::in); |
80 | explicit basic_ifstream(const filesystem::path& p, |
81 | ios_base::openmode mode = ios_base::in); // C++17 |
82 | basic_ifstream(basic_ifstream&& rhs); |
83 | |
84 | basic_ifstream& operator=(basic_ifstream&& rhs); |
85 | void swap(basic_ifstream& rhs); |
86 | |
87 | basic_filebuf<char_type, traits_type>* rdbuf() const; |
88 | bool is_open() const; |
89 | void open(const char* s, ios_base::openmode mode = ios_base::in); |
90 | void open(const string& s, ios_base::openmode mode = ios_base::in); |
91 | void open(const filesystem::path& s, ios_base::openmode mode = ios_base::in); // C++17 |
92 | |
93 | void close(); |
94 | }; |
95 | |
96 | template <class charT, class traits> |
97 | void |
98 | swap(basic_ifstream<charT, traits>& x, basic_ifstream<charT, traits>& y); |
99 | |
100 | typedef basic_ifstream<char> ifstream; |
101 | typedef basic_ifstream<wchar_t> wifstream; |
102 | |
103 | template <class charT, class traits = char_traits<charT> > |
104 | class basic_ofstream |
105 | : public basic_ostream<charT,traits> |
106 | { |
107 | public: |
108 | typedef charT char_type; |
109 | typedef traits traits_type; |
110 | typedef typename traits_type::int_type int_type; |
111 | typedef typename traits_type::pos_type pos_type; |
112 | typedef typename traits_type::off_type off_type; |
113 | |
114 | basic_ofstream(); |
115 | explicit basic_ofstream(const char* s, ios_base::openmode mode = ios_base::out); |
116 | explicit basic_ofstream(const string& s, ios_base::openmode mode = ios_base::out); |
117 | explicit basic_ofstream(const filesystem::path& p, |
118 | ios_base::openmode mode = ios_base::out); // C++17 |
119 | basic_ofstream(basic_ofstream&& rhs); |
120 | |
121 | basic_ofstream& operator=(basic_ofstream&& rhs); |
122 | void swap(basic_ofstream& rhs); |
123 | |
124 | basic_filebuf<char_type, traits_type>* rdbuf() const; |
125 | bool is_open() const; |
126 | void open(const char* s, ios_base::openmode mode = ios_base::out); |
127 | void open(const string& s, ios_base::openmode mode = ios_base::out); |
128 | void open(const filesystem::path& p, |
129 | ios_base::openmode mode = ios_base::out); // C++17 |
130 | |
131 | void close(); |
132 | }; |
133 | |
134 | template <class charT, class traits> |
135 | void |
136 | swap(basic_ofstream<charT, traits>& x, basic_ofstream<charT, traits>& y); |
137 | |
138 | typedef basic_ofstream<char> ofstream; |
139 | typedef basic_ofstream<wchar_t> wofstream; |
140 | |
141 | template <class charT, class traits=char_traits<charT> > |
142 | class basic_fstream |
143 | : public basic_iostream<charT,traits> |
144 | { |
145 | public: |
146 | typedef charT char_type; |
147 | typedef traits traits_type; |
148 | typedef typename traits_type::int_type int_type; |
149 | typedef typename traits_type::pos_type pos_type; |
150 | typedef typename traits_type::off_type off_type; |
151 | |
152 | basic_fstream(); |
153 | explicit basic_fstream(const char* s, ios_base::openmode mode = ios_base::in|ios_base::out); |
154 | explicit basic_fstream(const string& s, ios_base::openmode mode = ios_base::in|ios_base::out); |
155 | explicit basic_fstream(const filesystem::path& p, |
156 | ios_base::openmode mode = ios_base::in|ios_base::out); C++17 |
157 | basic_fstream(basic_fstream&& rhs); |
158 | |
159 | basic_fstream& operator=(basic_fstream&& rhs); |
160 | void swap(basic_fstream& rhs); |
161 | |
162 | basic_filebuf<char_type, traits_type>* rdbuf() const; |
163 | bool is_open() const; |
164 | void open(const char* s, ios_base::openmode mode = ios_base::in|ios_base::out); |
165 | void open(const string& s, ios_base::openmode mode = ios_base::in|ios_base::out); |
166 | void open(const filesystem::path& s, |
167 | ios_base::openmode mode = ios_base::in|ios_base::out); // C++17 |
168 | |
169 | void close(); |
170 | }; |
171 | |
172 | template <class charT, class traits> |
173 | void swap(basic_fstream<charT, traits>& x, basic_fstream<charT, traits>& y); |
174 | |
175 | typedef basic_fstream<char> fstream; |
176 | typedef basic_fstream<wchar_t> wfstream; |
177 | |
178 | } // std |
179 | |
180 | */ |
181 | |
182 | #include <__availability> |
183 | #include <__config> |
184 | #include <__debug> |
185 | #include <__locale> |
186 | #include <cstdio> |
187 | #include <cstdlib> |
188 | #include <istream> |
189 | #include <ostream> |
190 | |
191 | #if !defined(_LIBCPP_HAS_NO_FILESYSTEM_LIBRARY) |
192 | # include <filesystem> |
193 | #endif |
194 | |
195 | #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER) |
196 | #pragma GCC system_header |
197 | #endif |
198 | |
199 | _LIBCPP_PUSH_MACROSpush_macro("min") push_macro("max") |
200 | #include <__undef_macros> |
201 | |
202 | #if defined(_LIBCPP_MSVCRT) || defined(_NEWLIB_VERSION) |
203 | # define _LIBCPP_HAS_NO_OFF_T_FUNCTIONS |
204 | #endif |
205 | |
206 | _LIBCPP_BEGIN_NAMESPACE_STDnamespace std { inline namespace __1 { |
207 | |
208 | template <class _CharT, class _Traits> |
209 | class _LIBCPP_TEMPLATE_VIS__attribute__ ((__type_visibility__("default"))) basic_filebuf |
210 | : public basic_streambuf<_CharT, _Traits> |
211 | { |
212 | public: |
213 | typedef _CharT char_type; |
214 | typedef _Traits traits_type; |
215 | typedef typename traits_type::int_type int_type; |
216 | typedef typename traits_type::pos_type pos_type; |
217 | typedef typename traits_type::off_type off_type; |
218 | typedef typename traits_type::state_type state_type; |
219 | |
220 | // 27.9.1.2 Constructors/destructor: |
221 | basic_filebuf(); |
222 | basic_filebuf(basic_filebuf&& __rhs); |
223 | virtual ~basic_filebuf(); |
224 | |
225 | // 27.9.1.3 Assign/swap: |
226 | _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__ )) |
227 | basic_filebuf& operator=(basic_filebuf&& __rhs); |
228 | void swap(basic_filebuf& __rhs); |
229 | |
230 | // 27.9.1.4 Members: |
231 | _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__ )) |
232 | bool is_open() const; |
233 | #ifndef _LIBCPP_HAS_NO_GLOBAL_FILESYSTEM_NAMESPACE |
234 | basic_filebuf* open(const char* __s, ios_base::openmode __mode); |
235 | #ifdef _LIBCPP_HAS_OPEN_WITH_WCHAR |
236 | basic_filebuf* open(const wchar_t* __s, ios_base::openmode __mode); |
237 | #endif |
238 | _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__ )) |
239 | basic_filebuf* open(const string& __s, ios_base::openmode __mode); |
240 | |
241 | #if _LIBCPP_STD_VER14 >= 17 && !defined(_LIBCPP_HAS_NO_FILESYSTEM_LIBRARY) |
242 | _LIBCPP_AVAILABILITY_FILESYSTEM _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__ )) |
243 | basic_filebuf* open(const _VSTD_FSstd::__1::__fs::filesystem::path& __p, ios_base::openmode __mode) { |
244 | return open(__p.c_str(), __mode); |
245 | } |
246 | #endif |
247 | _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__ )) |
248 | basic_filebuf* __open(int __fd, ios_base::openmode __mode); |
249 | #endif |
250 | basic_filebuf* close(); |
251 | |
252 | _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__ )) |
253 | inline static const char* |
254 | __make_mdstring(ios_base::openmode __mode) _NOEXCEPTnoexcept; |
255 | |
256 | protected: |
257 | // 27.9.1.5 Overridden virtual functions: |
258 | virtual int_type underflow(); |
259 | virtual int_type pbackfail(int_type __c = traits_type::eof()); |
260 | virtual int_type overflow (int_type __c = traits_type::eof()); |
261 | virtual basic_streambuf<char_type, traits_type>* setbuf(char_type* __s, streamsize __n); |
262 | virtual pos_type seekoff(off_type __off, ios_base::seekdir __way, |
263 | ios_base::openmode __wch = ios_base::in | ios_base::out); |
264 | virtual pos_type seekpos(pos_type __sp, |
265 | ios_base::openmode __wch = ios_base::in | ios_base::out); |
266 | virtual int sync(); |
267 | virtual void imbue(const locale& __loc); |
268 | |
269 | private: |
270 | char* __extbuf_; |
271 | const char* __extbufnext_; |
272 | const char* __extbufend_; |
273 | char __extbuf_min_[8]; |
274 | size_t __ebs_; |
275 | char_type* __intbuf_; |
276 | size_t __ibs_; |
277 | FILE* __file_; |
278 | const codecvt<char_type, char, state_type>* __cv_; |
279 | state_type __st_; |
280 | state_type __st_last_; |
281 | ios_base::openmode __om_; |
282 | ios_base::openmode __cm_; |
283 | bool __owns_eb_; |
284 | bool __owns_ib_; |
285 | bool __always_noconv_; |
286 | |
287 | bool __read_mode(); |
288 | void __write_mode(); |
289 | }; |
290 | |
291 | template <class _CharT, class _Traits> |
292 | basic_filebuf<_CharT, _Traits>::basic_filebuf() |
293 | : __extbuf_(nullptr), |
294 | __extbufnext_(nullptr), |
295 | __extbufend_(nullptr), |
296 | __ebs_(0), |
297 | __intbuf_(nullptr), |
298 | __ibs_(0), |
299 | __file_(nullptr), |
300 | __cv_(nullptr), |
301 | __st_(), |
302 | __st_last_(), |
303 | __om_(0), |
304 | __cm_(0), |
305 | __owns_eb_(false), |
306 | __owns_ib_(false), |
307 | __always_noconv_(false) |
308 | { |
309 | if (has_facet<codecvt<char_type, char, state_type> >(this->getloc())) |
310 | { |
311 | __cv_ = &use_facet<codecvt<char_type, char, state_type> >(this->getloc()); |
312 | __always_noconv_ = __cv_->always_noconv(); |
313 | } |
314 | setbuf(nullptr, 4096); |
315 | } |
316 | |
317 | template <class _CharT, class _Traits> |
318 | basic_filebuf<_CharT, _Traits>::basic_filebuf(basic_filebuf&& __rhs) |
319 | : basic_streambuf<_CharT, _Traits>(__rhs) |
320 | { |
321 | if (__rhs.__extbuf_ == __rhs.__extbuf_min_) |
322 | { |
323 | __extbuf_ = __extbuf_min_; |
324 | __extbufnext_ = __extbuf_ + (__rhs.__extbufnext_ - __rhs.__extbuf_); |
325 | __extbufend_ = __extbuf_ + (__rhs.__extbufend_ - __rhs.__extbuf_); |
326 | } |
327 | else |
328 | { |
329 | __extbuf_ = __rhs.__extbuf_; |
330 | __extbufnext_ = __rhs.__extbufnext_; |
331 | __extbufend_ = __rhs.__extbufend_; |
332 | } |
333 | __ebs_ = __rhs.__ebs_; |
334 | __intbuf_ = __rhs.__intbuf_; |
335 | __ibs_ = __rhs.__ibs_; |
336 | __file_ = __rhs.__file_; |
337 | __cv_ = __rhs.__cv_; |
338 | __st_ = __rhs.__st_; |
339 | __st_last_ = __rhs.__st_last_; |
340 | __om_ = __rhs.__om_; |
341 | __cm_ = __rhs.__cm_; |
342 | __owns_eb_ = __rhs.__owns_eb_; |
343 | __owns_ib_ = __rhs.__owns_ib_; |
344 | __always_noconv_ = __rhs.__always_noconv_; |
345 | if (__rhs.pbase()) |
346 | { |
347 | if (__rhs.pbase() == __rhs.__intbuf_) |
348 | this->setp(__intbuf_, __intbuf_ + (__rhs. epptr() - __rhs.pbase())); |
349 | else |
350 | this->setp((char_type*)__extbuf_, |
351 | (char_type*)__extbuf_ + (__rhs. epptr() - __rhs.pbase())); |
352 | this->__pbump(__rhs. pptr() - __rhs.pbase()); |
353 | } |
354 | else if (__rhs.eback()) |
355 | { |
356 | if (__rhs.eback() == __rhs.__intbuf_) |
357 | this->setg(__intbuf_, __intbuf_ + (__rhs.gptr() - __rhs.eback()), |
358 | __intbuf_ + (__rhs.egptr() - __rhs.eback())); |
359 | else |
360 | this->setg((char_type*)__extbuf_, |
361 | (char_type*)__extbuf_ + (__rhs.gptr() - __rhs.eback()), |
362 | (char_type*)__extbuf_ + (__rhs.egptr() - __rhs.eback())); |
363 | } |
364 | __rhs.__extbuf_ = nullptr; |
365 | __rhs.__extbufnext_ = nullptr; |
366 | __rhs.__extbufend_ = nullptr; |
367 | __rhs.__ebs_ = 0; |
368 | __rhs.__intbuf_ = 0; |
369 | __rhs.__ibs_ = 0; |
370 | __rhs.__file_ = nullptr; |
371 | __rhs.__st_ = state_type(); |
372 | __rhs.__st_last_ = state_type(); |
373 | __rhs.__om_ = 0; |
374 | __rhs.__cm_ = 0; |
375 | __rhs.__owns_eb_ = false; |
376 | __rhs.__owns_ib_ = false; |
377 | __rhs.setg(0, 0, 0); |
378 | __rhs.setp(0, 0); |
379 | } |
380 | |
381 | template <class _CharT, class _Traits> |
382 | inline |
383 | basic_filebuf<_CharT, _Traits>& |
384 | basic_filebuf<_CharT, _Traits>::operator=(basic_filebuf&& __rhs) |
385 | { |
386 | close(); |
387 | swap(__rhs); |
388 | return *this; |
389 | } |
390 | |
391 | template <class _CharT, class _Traits> |
392 | basic_filebuf<_CharT, _Traits>::~basic_filebuf() |
393 | { |
394 | #ifndef _LIBCPP_NO_EXCEPTIONS |
395 | try |
396 | { |
397 | #endif // _LIBCPP_NO_EXCEPTIONS |
398 | close(); |
399 | #ifndef _LIBCPP_NO_EXCEPTIONS |
400 | } |
401 | catch (...) |
402 | { |
403 | } |
404 | #endif // _LIBCPP_NO_EXCEPTIONS |
405 | if (__owns_eb_) |
406 | delete [] __extbuf_; |
407 | if (__owns_ib_) |
408 | delete [] __intbuf_; |
409 | } |
410 | |
411 | template <class _CharT, class _Traits> |
412 | void |
413 | basic_filebuf<_CharT, _Traits>::swap(basic_filebuf& __rhs) |
414 | { |
415 | basic_streambuf<char_type, traits_type>::swap(__rhs); |
416 | if (__extbuf_ != __extbuf_min_ && __rhs.__extbuf_ != __rhs.__extbuf_min_) |
417 | { |
418 | _VSTDstd::__1::swap(__extbuf_, __rhs.__extbuf_); |
419 | _VSTDstd::__1::swap(__extbufnext_, __rhs.__extbufnext_); |
420 | _VSTDstd::__1::swap(__extbufend_, __rhs.__extbufend_); |
421 | } |
422 | else |
423 | { |
424 | ptrdiff_t __ln = __extbufnext_ - __extbuf_; |
425 | ptrdiff_t __le = __extbufend_ - __extbuf_; |
426 | ptrdiff_t __rn = __rhs.__extbufnext_ - __rhs.__extbuf_; |
427 | ptrdiff_t __re = __rhs.__extbufend_ - __rhs.__extbuf_; |
428 | if (__extbuf_ == __extbuf_min_ && __rhs.__extbuf_ != __rhs.__extbuf_min_) |
429 | { |
430 | __extbuf_ = __rhs.__extbuf_; |
431 | __rhs.__extbuf_ = __rhs.__extbuf_min_; |
432 | } |
433 | else if (__extbuf_ != __extbuf_min_ && __rhs.__extbuf_ == __rhs.__extbuf_min_) |
434 | { |
435 | __rhs.__extbuf_ = __extbuf_; |
436 | __extbuf_ = __extbuf_min_; |
437 | } |
438 | __extbufnext_ = __extbuf_ + __rn; |
439 | __extbufend_ = __extbuf_ + __re; |
440 | __rhs.__extbufnext_ = __rhs.__extbuf_ + __ln; |
441 | __rhs.__extbufend_ = __rhs.__extbuf_ + __le; |
442 | } |
443 | _VSTDstd::__1::swap(__ebs_, __rhs.__ebs_); |
444 | _VSTDstd::__1::swap(__intbuf_, __rhs.__intbuf_); |
445 | _VSTDstd::__1::swap(__ibs_, __rhs.__ibs_); |
446 | _VSTDstd::__1::swap(__file_, __rhs.__file_); |
447 | _VSTDstd::__1::swap(__cv_, __rhs.__cv_); |
448 | _VSTDstd::__1::swap(__st_, __rhs.__st_); |
449 | _VSTDstd::__1::swap(__st_last_, __rhs.__st_last_); |
450 | _VSTDstd::__1::swap(__om_, __rhs.__om_); |
451 | _VSTDstd::__1::swap(__cm_, __rhs.__cm_); |
452 | _VSTDstd::__1::swap(__owns_eb_, __rhs.__owns_eb_); |
453 | _VSTDstd::__1::swap(__owns_ib_, __rhs.__owns_ib_); |
454 | _VSTDstd::__1::swap(__always_noconv_, __rhs.__always_noconv_); |
455 | if (this->eback() == (char_type*)__rhs.__extbuf_min_) |
456 | { |
457 | ptrdiff_t __n = this->gptr() - this->eback(); |
458 | ptrdiff_t __e = this->egptr() - this->eback(); |
459 | this->setg((char_type*)__extbuf_min_, |
460 | (char_type*)__extbuf_min_ + __n, |
461 | (char_type*)__extbuf_min_ + __e); |
462 | } |
463 | else if (this->pbase() == (char_type*)__rhs.__extbuf_min_) |
464 | { |
465 | ptrdiff_t __n = this->pptr() - this->pbase(); |
466 | ptrdiff_t __e = this->epptr() - this->pbase(); |
467 | this->setp((char_type*)__extbuf_min_, |
468 | (char_type*)__extbuf_min_ + __e); |
469 | this->__pbump(__n); |
470 | } |
471 | if (__rhs.eback() == (char_type*)__extbuf_min_) |
472 | { |
473 | ptrdiff_t __n = __rhs.gptr() - __rhs.eback(); |
474 | ptrdiff_t __e = __rhs.egptr() - __rhs.eback(); |
475 | __rhs.setg((char_type*)__rhs.__extbuf_min_, |
476 | (char_type*)__rhs.__extbuf_min_ + __n, |
477 | (char_type*)__rhs.__extbuf_min_ + __e); |
478 | } |
479 | else if (__rhs.pbase() == (char_type*)__extbuf_min_) |
480 | { |
481 | ptrdiff_t __n = __rhs.pptr() - __rhs.pbase(); |
482 | ptrdiff_t __e = __rhs.epptr() - __rhs.pbase(); |
483 | __rhs.setp((char_type*)__rhs.__extbuf_min_, |
484 | (char_type*)__rhs.__extbuf_min_ + __e); |
485 | __rhs.__pbump(__n); |
486 | } |
487 | } |
488 | |
489 | template <class _CharT, class _Traits> |
490 | inline _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__ )) |
491 | void |
492 | swap(basic_filebuf<_CharT, _Traits>& __x, basic_filebuf<_CharT, _Traits>& __y) |
493 | { |
494 | __x.swap(__y); |
495 | } |
496 | |
497 | template <class _CharT, class _Traits> |
498 | inline |
499 | bool |
500 | basic_filebuf<_CharT, _Traits>::is_open() const |
501 | { |
502 | return __file_ != nullptr; |
503 | } |
504 | |
505 | template <class _CharT, class _Traits> |
506 | const char* basic_filebuf<_CharT, _Traits>::__make_mdstring( |
507 | ios_base::openmode __mode) _NOEXCEPTnoexcept { |
508 | switch (__mode & ~ios_base::ate) { |
509 | case ios_base::out: |
510 | case ios_base::out | ios_base::trunc: |
511 | return "w" _LIBCPP_FOPEN_CLOEXEC_MODE; |
512 | case ios_base::out | ios_base::app: |
513 | case ios_base::app: |
514 | return "a" _LIBCPP_FOPEN_CLOEXEC_MODE; |
515 | case ios_base::in: |
516 | return "r" _LIBCPP_FOPEN_CLOEXEC_MODE; |
517 | case ios_base::in | ios_base::out: |
518 | return "r+" _LIBCPP_FOPEN_CLOEXEC_MODE; |
519 | case ios_base::in | ios_base::out | ios_base::trunc: |
520 | return "w+" _LIBCPP_FOPEN_CLOEXEC_MODE; |
521 | case ios_base::in | ios_base::out | ios_base::app: |
522 | case ios_base::in | ios_base::app: |
523 | return "a+" _LIBCPP_FOPEN_CLOEXEC_MODE; |
524 | case ios_base::out | ios_base::binary: |
525 | case ios_base::out | ios_base::trunc | ios_base::binary: |
526 | return "wb" _LIBCPP_FOPEN_CLOEXEC_MODE; |
527 | case ios_base::out | ios_base::app | ios_base::binary: |
528 | case ios_base::app | ios_base::binary: |
529 | return "ab" _LIBCPP_FOPEN_CLOEXEC_MODE; |
530 | case ios_base::in | ios_base::binary: |
531 | return "rb" _LIBCPP_FOPEN_CLOEXEC_MODE; |
532 | case ios_base::in | ios_base::out | ios_base::binary: |
533 | return "r+b" _LIBCPP_FOPEN_CLOEXEC_MODE; |
534 | case ios_base::in | ios_base::out | ios_base::trunc | ios_base::binary: |
535 | return "w+b" _LIBCPP_FOPEN_CLOEXEC_MODE; |
536 | case ios_base::in | ios_base::out | ios_base::app | ios_base::binary: |
537 | case ios_base::in | ios_base::app | ios_base::binary: |
538 | return "a+b" _LIBCPP_FOPEN_CLOEXEC_MODE; |
539 | default: |
540 | return nullptr; |
541 | } |
542 | _LIBCPP_UNREACHABLE()__builtin_unreachable(); |
543 | } |
544 | |
545 | #ifndef _LIBCPP_HAS_NO_GLOBAL_FILESYSTEM_NAMESPACE |
546 | template <class _CharT, class _Traits> |
547 | basic_filebuf<_CharT, _Traits>* |
548 | basic_filebuf<_CharT, _Traits>::open(const char* __s, ios_base::openmode __mode) |
549 | { |
550 | basic_filebuf<_CharT, _Traits>* __rt = nullptr; |
551 | if (__file_ == nullptr) |
552 | { |
553 | if (const char* __mdstr = __make_mdstring(__mode)) { |
554 | __rt = this; |
555 | __file_ = fopen(__s, __mdstr); |
556 | if (__file_) { |
557 | __om_ = __mode; |
558 | if (__mode & ios_base::ate) { |
559 | if (fseek(__file_, 0, SEEK_END2)) { |
560 | fclose(__file_); |
561 | __file_ = nullptr; |
562 | __rt = nullptr; |
563 | } |
564 | } |
565 | } else |
566 | __rt = nullptr; |
567 | } |
568 | } |
569 | return __rt; |
570 | } |
571 | |
572 | template <class _CharT, class _Traits> |
573 | inline |
574 | basic_filebuf<_CharT, _Traits>* |
575 | basic_filebuf<_CharT, _Traits>::__open(int __fd, ios_base::openmode __mode) { |
576 | basic_filebuf<_CharT, _Traits>* __rt = nullptr; |
577 | if (__file_ == nullptr) { |
578 | if (const char* __mdstr = __make_mdstring(__mode)) { |
579 | __rt = this; |
580 | __file_ = fdopen(__fd, __mdstr); |
581 | if (__file_) { |
582 | __om_ = __mode; |
583 | if (__mode & ios_base::ate) { |
584 | if (fseek(__file_, 0, SEEK_END2)) { |
585 | fclose(__file_); |
586 | __file_ = nullptr; |
587 | __rt = nullptr; |
588 | } |
589 | } |
590 | } else |
591 | __rt = nullptr; |
592 | } |
593 | } |
594 | return __rt; |
595 | } |
596 | |
597 | #ifdef _LIBCPP_HAS_OPEN_WITH_WCHAR |
598 | // This is basically the same as the char* overload except that it uses _wfopen |
599 | // and long mode strings. |
600 | template <class _CharT, class _Traits> |
601 | basic_filebuf<_CharT, _Traits>* |
602 | basic_filebuf<_CharT, _Traits>::open(const wchar_t* __s, ios_base::openmode __mode) |
603 | { |
604 | basic_filebuf<_CharT, _Traits>* __rt = nullptr; |
605 | if (__file_ == nullptr) |
606 | { |
607 | __rt = this; |
608 | const wchar_t* __mdstr; |
609 | switch (__mode & ~ios_base::ate) |
610 | { |
611 | case ios_base::out: |
612 | case ios_base::out | ios_base::trunc: |
613 | __mdstr = L"w"; |
614 | break; |
615 | case ios_base::out | ios_base::app: |
616 | case ios_base::app: |
617 | __mdstr = L"a"; |
618 | break; |
619 | case ios_base::in: |
620 | __mdstr = L"r"; |
621 | break; |
622 | case ios_base::in | ios_base::out: |
623 | __mdstr = L"r+"; |
624 | break; |
625 | case ios_base::in | ios_base::out | ios_base::trunc: |
626 | __mdstr = L"w+"; |
627 | break; |
628 | case ios_base::in | ios_base::out | ios_base::app: |
629 | case ios_base::in | ios_base::app: |
630 | __mdstr = L"a+"; |
631 | break; |
632 | case ios_base::out | ios_base::binary: |
633 | case ios_base::out | ios_base::trunc | ios_base::binary: |
634 | __mdstr = L"wb"; |
635 | break; |
636 | case ios_base::out | ios_base::app | ios_base::binary: |
637 | case ios_base::app | ios_base::binary: |
638 | __mdstr = L"ab"; |
639 | break; |
640 | case ios_base::in | ios_base::binary: |
641 | __mdstr = L"rb"; |
642 | break; |
643 | case ios_base::in | ios_base::out | ios_base::binary: |
644 | __mdstr = L"r+b"; |
645 | break; |
646 | case ios_base::in | ios_base::out | ios_base::trunc | ios_base::binary: |
647 | __mdstr = L"w+b"; |
648 | break; |
649 | case ios_base::in | ios_base::out | ios_base::app | ios_base::binary: |
650 | case ios_base::in | ios_base::app | ios_base::binary: |
651 | __mdstr = L"a+b"; |
652 | break; |
653 | default: |
654 | __rt = nullptr; |
655 | break; |
656 | } |
657 | if (__rt) |
658 | { |
659 | __file_ = _wfopen(__s, __mdstr); |
660 | if (__file_) |
661 | { |
662 | __om_ = __mode; |
663 | if (__mode & ios_base::ate) |
664 | { |
665 | if (fseek(__file_, 0, SEEK_END2)) |
666 | { |
667 | fclose(__file_); |
668 | __file_ = nullptr; |
669 | __rt = nullptr; |
670 | } |
671 | } |
672 | } |
673 | else |
674 | __rt = nullptr; |
675 | } |
676 | } |
677 | return __rt; |
678 | } |
679 | #endif |
680 | |
681 | template <class _CharT, class _Traits> |
682 | inline |
683 | basic_filebuf<_CharT, _Traits>* |
684 | basic_filebuf<_CharT, _Traits>::open(const string& __s, ios_base::openmode __mode) |
685 | { |
686 | return open(__s.c_str(), __mode); |
687 | } |
688 | #endif |
689 | |
690 | template <class _CharT, class _Traits> |
691 | basic_filebuf<_CharT, _Traits>* |
692 | basic_filebuf<_CharT, _Traits>::close() |
693 | { |
694 | basic_filebuf<_CharT, _Traits>* __rt = nullptr; |
695 | if (__file_) |
696 | { |
697 | __rt = this; |
698 | unique_ptr<FILE, int(*)(FILE*)> __h(__file_, fclose); |
699 | if (sync()) |
700 | __rt = nullptr; |
701 | if (fclose(__h.release())) |
702 | __rt = nullptr; |
703 | __file_ = nullptr; |
704 | setbuf(0, 0); |
705 | } |
706 | return __rt; |
707 | } |
708 | |
709 | template <class _CharT, class _Traits> |
710 | typename basic_filebuf<_CharT, _Traits>::int_type |
711 | basic_filebuf<_CharT, _Traits>::underflow() |
712 | { |
713 | if (__file_ == nullptr) |
714 | return traits_type::eof(); |
715 | bool __initial = __read_mode(); |
716 | char_type __1buf; |
717 | if (this->gptr() == nullptr) |
718 | this->setg(&__1buf, &__1buf+1, &__1buf+1); |
719 | const size_t __unget_sz = __initial ? 0 : min<size_t>((this->egptr() - this->eback()) / 2, 4); |
720 | int_type __c = traits_type::eof(); |
721 | if (this->gptr() == this->egptr()) |
722 | { |
723 | _VSTDstd::__1::memmove(this->eback(), this->egptr() - __unget_sz, __unget_sz * sizeof(char_type)); |
724 | if (__always_noconv_) |
725 | { |
726 | size_t __nmemb = static_cast<size_t>(this->egptr() - this->eback() - __unget_sz); |
727 | __nmemb = fread(this->eback() + __unget_sz, 1, __nmemb, __file_); |
728 | if (__nmemb != 0) |
729 | { |
730 | this->setg(this->eback(), |
731 | this->eback() + __unget_sz, |
732 | this->eback() + __unget_sz + __nmemb); |
733 | __c = traits_type::to_int_type(*this->gptr()); |
734 | } |
735 | } |
736 | else |
737 | { |
738 | _LIBCPP_ASSERT ( !(__extbufnext_ == NULL && (__extbufend_ != __extbufnext_)), "underflow moving from NULL" )((void)0); |
739 | if (__extbufend_ != __extbufnext_) |
740 | _VSTDstd::__1::memmove(__extbuf_, __extbufnext_, __extbufend_ - __extbufnext_); |
741 | __extbufnext_ = __extbuf_ + (__extbufend_ - __extbufnext_); |
742 | __extbufend_ = __extbuf_ + (__extbuf_ == __extbuf_min_ ? sizeof(__extbuf_min_) : __ebs_); |
743 | size_t __nmemb = _VSTDstd::__1::min(static_cast<size_t>(__ibs_ - __unget_sz), |
744 | static_cast<size_t>(__extbufend_ - __extbufnext_)); |
745 | codecvt_base::result __r; |
746 | __st_last_ = __st_; |
747 | size_t __nr = fread((void*) const_cast<char *>(__extbufnext_), 1, __nmemb, __file_); |
748 | if (__nr != 0) |
749 | { |
750 | if (!__cv_) |
751 | __throw_bad_cast(); |
752 | |
753 | __extbufend_ = __extbufnext_ + __nr; |
754 | char_type* __inext; |
755 | __r = __cv_->in(__st_, __extbuf_, __extbufend_, __extbufnext_, |
756 | this->eback() + __unget_sz, |
757 | this->eback() + __ibs_, __inext); |
758 | if (__r == codecvt_base::noconv) |
759 | { |
760 | this->setg((char_type*)__extbuf_, (char_type*)__extbuf_, |
761 | (char_type*)const_cast<char *>(__extbufend_)); |
762 | __c = traits_type::to_int_type(*this->gptr()); |
763 | } |
764 | else if (__inext != this->eback() + __unget_sz) |
765 | { |
766 | this->setg(this->eback(), this->eback() + __unget_sz, __inext); |
767 | __c = traits_type::to_int_type(*this->gptr()); |
768 | } |
769 | } |
770 | } |
771 | } |
772 | else |
773 | __c = traits_type::to_int_type(*this->gptr()); |
774 | if (this->eback() == &__1buf) |
775 | this->setg(nullptr, nullptr, nullptr); |
776 | return __c; |
777 | } |
778 | |
779 | template <class _CharT, class _Traits> |
780 | typename basic_filebuf<_CharT, _Traits>::int_type |
781 | basic_filebuf<_CharT, _Traits>::pbackfail(int_type __c) |
782 | { |
783 | if (__file_ && this->eback() < this->gptr()) |
784 | { |
785 | if (traits_type::eq_int_type(__c, traits_type::eof())) |
786 | { |
787 | this->gbump(-1); |
788 | return traits_type::not_eof(__c); |
789 | } |
790 | if ((__om_ & ios_base::out) || |
791 | traits_type::eq(traits_type::to_char_type(__c), this->gptr()[-1])) |
792 | { |
793 | this->gbump(-1); |
794 | *this->gptr() = traits_type::to_char_type(__c); |
795 | return __c; |
796 | } |
797 | } |
798 | return traits_type::eof(); |
799 | } |
800 | |
801 | template <class _CharT, class _Traits> |
802 | typename basic_filebuf<_CharT, _Traits>::int_type |
803 | basic_filebuf<_CharT, _Traits>::overflow(int_type __c) |
804 | { |
805 | if (__file_ == nullptr) |
806 | return traits_type::eof(); |
807 | __write_mode(); |
808 | char_type __1buf; |
809 | char_type* __pb_save = this->pbase(); |
810 | char_type* __epb_save = this->epptr(); |
811 | if (!traits_type::eq_int_type(__c, traits_type::eof())) |
812 | { |
813 | if (this->pptr() == nullptr) |
814 | this->setp(&__1buf, &__1buf+1); |
815 | *this->pptr() = traits_type::to_char_type(__c); |
816 | this->pbump(1); |
817 | } |
818 | if (this->pptr() != this->pbase()) |
819 | { |
820 | if (__always_noconv_) |
821 | { |
822 | size_t __nmemb = static_cast<size_t>(this->pptr() - this->pbase()); |
823 | if (fwrite(this->pbase(), sizeof(char_type), __nmemb, __file_) != __nmemb) |
824 | return traits_type::eof(); |
825 | } |
826 | else |
827 | { |
828 | char* __extbe = __extbuf_; |
829 | codecvt_base::result __r; |
830 | do |
831 | { |
832 | if (!__cv_) |
833 | __throw_bad_cast(); |
834 | |
835 | const char_type* __e; |
836 | __r = __cv_->out(__st_, this->pbase(), this->pptr(), __e, |
837 | __extbuf_, __extbuf_ + __ebs_, __extbe); |
838 | if (__e == this->pbase()) |
839 | return traits_type::eof(); |
840 | if (__r == codecvt_base::noconv) |
841 | { |
842 | size_t __nmemb = static_cast<size_t>(this->pptr() - this->pbase()); |
843 | if (fwrite(this->pbase(), 1, __nmemb, __file_) != __nmemb) |
844 | return traits_type::eof(); |
845 | } |
846 | else if (__r == codecvt_base::ok || __r == codecvt_base::partial) |
847 | { |
848 | size_t __nmemb = static_cast<size_t>(__extbe - __extbuf_); |
849 | if (fwrite(__extbuf_, 1, __nmemb, __file_) != __nmemb) |
850 | return traits_type::eof(); |
851 | if (__r == codecvt_base::partial) |
852 | { |
853 | this->setp(const_cast<char_type*>(__e), this->pptr()); |
854 | this->__pbump(this->epptr() - this->pbase()); |
855 | } |
856 | } |
857 | else |
858 | return traits_type::eof(); |
859 | } while (__r == codecvt_base::partial); |
860 | } |
861 | this->setp(__pb_save, __epb_save); |
862 | } |
863 | return traits_type::not_eof(__c); |
864 | } |
865 | |
866 | template <class _CharT, class _Traits> |
867 | basic_streambuf<_CharT, _Traits>* |
868 | basic_filebuf<_CharT, _Traits>::setbuf(char_type* __s, streamsize __n) |
869 | { |
870 | this->setg(nullptr, nullptr, nullptr); |
871 | this->setp(nullptr, nullptr); |
872 | if (__owns_eb_) |
873 | delete [] __extbuf_; |
874 | if (__owns_ib_) |
875 | delete [] __intbuf_; |
876 | __ebs_ = __n; |
877 | if (__ebs_ > sizeof(__extbuf_min_)) |
878 | { |
879 | if (__always_noconv_ && __s) |
880 | { |
881 | __extbuf_ = (char*)__s; |
882 | __owns_eb_ = false; |
883 | } |
884 | else |
885 | { |
886 | __extbuf_ = new char[__ebs_]; |
887 | __owns_eb_ = true; |
888 | } |
889 | } |
890 | else |
891 | { |
892 | __extbuf_ = __extbuf_min_; |
893 | __ebs_ = sizeof(__extbuf_min_); |
894 | __owns_eb_ = false; |
895 | } |
896 | if (!__always_noconv_) |
897 | { |
898 | __ibs_ = max<streamsize>(__n, sizeof(__extbuf_min_)); |
899 | if (__s && __ibs_ >= sizeof(__extbuf_min_)) |
900 | { |
901 | __intbuf_ = __s; |
902 | __owns_ib_ = false; |
903 | } |
904 | else |
905 | { |
906 | __intbuf_ = new char_type[__ibs_]; |
907 | __owns_ib_ = true; |
908 | } |
909 | } |
910 | else |
911 | { |
912 | __ibs_ = 0; |
913 | __intbuf_ = nullptr; |
914 | __owns_ib_ = false; |
915 | } |
916 | return this; |
917 | } |
918 | |
919 | template <class _CharT, class _Traits> |
920 | typename basic_filebuf<_CharT, _Traits>::pos_type |
921 | basic_filebuf<_CharT, _Traits>::seekoff(off_type __off, ios_base::seekdir __way, |
922 | ios_base::openmode) |
923 | { |
924 | if (!__cv_) |
925 | __throw_bad_cast(); |
926 | |
927 | int __width = __cv_->encoding(); |
928 | if (__file_ == nullptr || (__width <= 0 && __off != 0) || sync()) |
929 | return pos_type(off_type(-1)); |
930 | // __width > 0 || __off == 0 |
931 | int __whence; |
932 | switch (__way) |
933 | { |
934 | case ios_base::beg: |
935 | __whence = SEEK_SET0; |
936 | break; |
937 | case ios_base::cur: |
938 | __whence = SEEK_CUR1; |
939 | break; |
940 | case ios_base::end: |
941 | __whence = SEEK_END2; |
942 | break; |
943 | default: |
944 | return pos_type(off_type(-1)); |
945 | } |
946 | #if defined(_LIBCPP_HAS_NO_OFF_T_FUNCTIONS) |
947 | if (fseek(__file_, __width > 0 ? __width * __off : 0, __whence)) |
948 | return pos_type(off_type(-1)); |
949 | pos_type __r = ftell(__file_); |
950 | #else |
951 | if (fseeko(__file_, __width > 0 ? __width * __off : 0, __whence)) |
952 | return pos_type(off_type(-1)); |
953 | pos_type __r = ftello(__file_); |
954 | #endif |
955 | __r.state(__st_); |
956 | return __r; |
957 | } |
958 | |
959 | template <class _CharT, class _Traits> |
960 | typename basic_filebuf<_CharT, _Traits>::pos_type |
961 | basic_filebuf<_CharT, _Traits>::seekpos(pos_type __sp, ios_base::openmode) |
962 | { |
963 | if (__file_ == nullptr || sync()) |
964 | return pos_type(off_type(-1)); |
965 | #if defined(_LIBCPP_HAS_NO_OFF_T_FUNCTIONS) |
966 | if (fseek(__file_, __sp, SEEK_SET0)) |
967 | return pos_type(off_type(-1)); |
968 | #else |
969 | if (fseeko(__file_, __sp, SEEK_SET0)) |
970 | return pos_type(off_type(-1)); |
971 | #endif |
972 | __st_ = __sp.state(); |
973 | return __sp; |
974 | } |
975 | |
976 | template <class _CharT, class _Traits> |
977 | int |
978 | basic_filebuf<_CharT, _Traits>::sync() |
979 | { |
980 | if (__file_ == nullptr) |
981 | return 0; |
982 | if (!__cv_) |
983 | __throw_bad_cast(); |
984 | |
985 | if (__cm_ & ios_base::out) |
986 | { |
987 | if (this->pptr() != this->pbase()) |
988 | if (overflow() == traits_type::eof()) |
989 | return -1; |
990 | codecvt_base::result __r; |
991 | do |
992 | { |
993 | char* __extbe; |
994 | __r = __cv_->unshift(__st_, __extbuf_, __extbuf_ + __ebs_, __extbe); |
995 | size_t __nmemb = static_cast<size_t>(__extbe - __extbuf_); |
996 | if (fwrite(__extbuf_, 1, __nmemb, __file_) != __nmemb) |
997 | return -1; |
998 | } while (__r == codecvt_base::partial); |
999 | if (__r == codecvt_base::error) |
1000 | return -1; |
1001 | if (fflush(__file_)) |
1002 | return -1; |
1003 | } |
1004 | else if (__cm_ & ios_base::in) |
1005 | { |
1006 | off_type __c; |
1007 | state_type __state = __st_last_; |
1008 | bool __update_st = false; |
1009 | if (__always_noconv_) |
1010 | __c = this->egptr() - this->gptr(); |
1011 | else |
1012 | { |
1013 | int __width = __cv_->encoding(); |
1014 | __c = __extbufend_ - __extbufnext_; |
1015 | if (__width > 0) |
1016 | __c += __width * (this->egptr() - this->gptr()); |
1017 | else |
1018 | { |
1019 | if (this->gptr() != this->egptr()) |
1020 | { |
1021 | const int __off = __cv_->length(__state, __extbuf_, |
1022 | __extbufnext_, |
1023 | this->gptr() - this->eback()); |
1024 | __c += __extbufnext_ - __extbuf_ - __off; |
1025 | __update_st = true; |
1026 | } |
1027 | } |
1028 | } |
1029 | #if defined(_LIBCPP_HAS_NO_OFF_T_FUNCTIONS) |
1030 | if (fseek(__file_, -__c, SEEK_CUR1)) |
1031 | return -1; |
1032 | #else |
1033 | if (fseeko(__file_, -__c, SEEK_CUR1)) |
1034 | return -1; |
1035 | #endif |
1036 | if (__update_st) |
1037 | __st_ = __state; |
1038 | __extbufnext_ = __extbufend_ = __extbuf_; |
1039 | this->setg(nullptr, nullptr, nullptr); |
1040 | __cm_ = 0; |
1041 | } |
1042 | return 0; |
1043 | } |
1044 | |
1045 | template <class _CharT, class _Traits> |
1046 | void |
1047 | basic_filebuf<_CharT, _Traits>::imbue(const locale& __loc) |
1048 | { |
1049 | sync(); |
1050 | __cv_ = &use_facet<codecvt<char_type, char, state_type> >(__loc); |
1051 | bool __old_anc = __always_noconv_; |
1052 | __always_noconv_ = __cv_->always_noconv(); |
1053 | if (__old_anc != __always_noconv_) |
1054 | { |
1055 | this->setg(nullptr, nullptr, nullptr); |
1056 | this->setp(nullptr, nullptr); |
1057 | // invariant, char_type is char, else we couldn't get here |
1058 | if (__always_noconv_) // need to dump __intbuf_ |
1059 | { |
1060 | if (__owns_eb_) |
1061 | delete [] __extbuf_; |
1062 | __owns_eb_ = __owns_ib_; |
1063 | __ebs_ = __ibs_; |
1064 | __extbuf_ = (char*)__intbuf_; |
1065 | __ibs_ = 0; |
1066 | __intbuf_ = nullptr; |
1067 | __owns_ib_ = false; |
1068 | } |
1069 | else // need to obtain an __intbuf_. |
1070 | { // If __extbuf_ is user-supplied, use it, else new __intbuf_ |
1071 | if (!__owns_eb_ && __extbuf_ != __extbuf_min_) |
1072 | { |
1073 | __ibs_ = __ebs_; |
1074 | __intbuf_ = (char_type*)__extbuf_; |
1075 | __owns_ib_ = false; |
1076 | __extbuf_ = new char[__ebs_]; |
1077 | __owns_eb_ = true; |
1078 | } |
1079 | else |
1080 | { |
1081 | __ibs_ = __ebs_; |
1082 | __intbuf_ = new char_type[__ibs_]; |
1083 | __owns_ib_ = true; |
1084 | } |
1085 | } |
1086 | } |
1087 | } |
1088 | |
1089 | template <class _CharT, class _Traits> |
1090 | bool |
1091 | basic_filebuf<_CharT, _Traits>::__read_mode() |
1092 | { |
1093 | if (!(__cm_ & ios_base::in)) |
1094 | { |
1095 | this->setp(nullptr, nullptr); |
1096 | if (__always_noconv_) |
1097 | this->setg((char_type*)__extbuf_, |
1098 | (char_type*)__extbuf_ + __ebs_, |
1099 | (char_type*)__extbuf_ + __ebs_); |
1100 | else |
1101 | this->setg(__intbuf_, __intbuf_ + __ibs_, __intbuf_ + __ibs_); |
1102 | __cm_ = ios_base::in; |
1103 | return true; |
1104 | } |
1105 | return false; |
1106 | } |
1107 | |
1108 | template <class _CharT, class _Traits> |
1109 | void |
1110 | basic_filebuf<_CharT, _Traits>::__write_mode() |
1111 | { |
1112 | if (!(__cm_ & ios_base::out)) |
1113 | { |
1114 | this->setg(nullptr, nullptr, nullptr); |
1115 | if (__ebs_ > sizeof(__extbuf_min_)) |
1116 | { |
1117 | if (__always_noconv_) |
1118 | this->setp((char_type*)__extbuf_, |
1119 | (char_type*)__extbuf_ + (__ebs_ - 1)); |
1120 | else |
1121 | this->setp(__intbuf_, __intbuf_ + (__ibs_ - 1)); |
1122 | } |
1123 | else |
1124 | this->setp(nullptr, nullptr); |
1125 | __cm_ = ios_base::out; |
1126 | } |
1127 | } |
1128 | |
1129 | // basic_ifstream |
1130 | |
1131 | template <class _CharT, class _Traits> |
1132 | class _LIBCPP_TEMPLATE_VIS__attribute__ ((__type_visibility__("default"))) basic_ifstream |
1133 | : public basic_istream<_CharT, _Traits> |
1134 | { |
1135 | public: |
1136 | typedef _CharT char_type; |
1137 | typedef _Traits traits_type; |
1138 | typedef typename traits_type::int_type int_type; |
1139 | typedef typename traits_type::pos_type pos_type; |
1140 | typedef typename traits_type::off_type off_type; |
1141 | |
1142 | _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__ )) |
1143 | basic_ifstream(); |
1144 | #ifndef _LIBCPP_HAS_NO_GLOBAL_FILESYSTEM_NAMESPACE |
1145 | _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__ )) |
1146 | explicit basic_ifstream(const char* __s, ios_base::openmode __mode = ios_base::in); |
1147 | #ifdef _LIBCPP_HAS_OPEN_WITH_WCHAR |
1148 | _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__ )) |
1149 | explicit basic_ifstream(const wchar_t* __s, ios_base::openmode __mode = ios_base::in); |
1150 | #endif |
1151 | _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__ )) |
1152 | explicit basic_ifstream(const string& __s, ios_base::openmode __mode = ios_base::in); |
1153 | #if _LIBCPP_STD_VER14 >= 17 && !defined(_LIBCPP_HAS_NO_FILESYSTEM_LIBRARY) |
1154 | _LIBCPP_AVAILABILITY_FILESYSTEM _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__ )) |
1155 | explicit basic_ifstream(const filesystem::path& __p, ios_base::openmode __mode = ios_base::in) |
1156 | : basic_ifstream(__p.c_str(), __mode) {} |
1157 | #endif // _LIBCPP_STD_VER >= 17 |
1158 | #endif |
1159 | _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__ )) |
1160 | basic_ifstream(basic_ifstream&& __rhs); |
1161 | _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__ )) |
1162 | basic_ifstream& operator=(basic_ifstream&& __rhs); |
1163 | _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__ )) |
1164 | void swap(basic_ifstream& __rhs); |
1165 | |
1166 | _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__ )) |
1167 | basic_filebuf<char_type, traits_type>* rdbuf() const; |
1168 | _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__ )) |
1169 | bool is_open() const; |
1170 | #ifndef _LIBCPP_HAS_NO_GLOBAL_FILESYSTEM_NAMESPACE |
1171 | void open(const char* __s, ios_base::openmode __mode = ios_base::in); |
1172 | #ifdef _LIBCPP_HAS_OPEN_WITH_WCHAR |
1173 | void open(const wchar_t* __s, ios_base::openmode __mode = ios_base::in); |
1174 | #endif |
1175 | void open(const string& __s, ios_base::openmode __mode = ios_base::in); |
1176 | #if _LIBCPP_STD_VER14 >= 17 && !defined(_LIBCPP_HAS_NO_FILESYSTEM_LIBRARY) |
1177 | _LIBCPP_AVAILABILITY_FILESYSTEM _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__ )) |
1178 | void open(const filesystem::path& __p, |
1179 | ios_base::openmode __mode = ios_base::in) { |
1180 | return open(__p.c_str(), __mode); |
1181 | } |
1182 | #endif // _LIBCPP_STD_VER >= 17 |
1183 | |
1184 | _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__ )) |
1185 | void __open(int __fd, ios_base::openmode __mode); |
1186 | #endif |
1187 | _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__ )) |
1188 | void close(); |
1189 | |
1190 | private: |
1191 | basic_filebuf<char_type, traits_type> __sb_; |
1192 | }; |
1193 | |
1194 | template <class _CharT, class _Traits> |
1195 | inline |
1196 | basic_ifstream<_CharT, _Traits>::basic_ifstream() |
1197 | : basic_istream<char_type, traits_type>(&__sb_) |
1198 | { |
1199 | } |
1200 | |
1201 | #ifndef _LIBCPP_HAS_NO_GLOBAL_FILESYSTEM_NAMESPACE |
1202 | template <class _CharT, class _Traits> |
1203 | inline |
1204 | basic_ifstream<_CharT, _Traits>::basic_ifstream(const char* __s, ios_base::openmode __mode) |
1205 | : basic_istream<char_type, traits_type>(&__sb_) |
1206 | { |
1207 | if (__sb_.open(__s, __mode | ios_base::in) == nullptr) |
1208 | this->setstate(ios_base::failbit); |
1209 | } |
1210 | |
1211 | #ifdef _LIBCPP_HAS_OPEN_WITH_WCHAR |
1212 | template <class _CharT, class _Traits> |
1213 | inline |
1214 | basic_ifstream<_CharT, _Traits>::basic_ifstream(const wchar_t* __s, ios_base::openmode __mode) |
1215 | : basic_istream<char_type, traits_type>(&__sb_) |
1216 | { |
1217 | if (__sb_.open(__s, __mode | ios_base::in) == nullptr) |
1218 | this->setstate(ios_base::failbit); |
1219 | } |
1220 | #endif |
1221 | |
1222 | template <class _CharT, class _Traits> |
1223 | inline |
1224 | basic_ifstream<_CharT, _Traits>::basic_ifstream(const string& __s, ios_base::openmode __mode) |
1225 | : basic_istream<char_type, traits_type>(&__sb_) |
1226 | { |
1227 | if (__sb_.open(__s, __mode | ios_base::in) == nullptr) |
1228 | this->setstate(ios_base::failbit); |
1229 | } |
1230 | #endif |
1231 | |
1232 | template <class _CharT, class _Traits> |
1233 | inline |
1234 | basic_ifstream<_CharT, _Traits>::basic_ifstream(basic_ifstream&& __rhs) |
1235 | : basic_istream<char_type, traits_type>(_VSTDstd::__1::move(__rhs)), |
1236 | __sb_(_VSTDstd::__1::move(__rhs.__sb_)) |
1237 | { |
1238 | this->set_rdbuf(&__sb_); |
1239 | } |
1240 | |
1241 | template <class _CharT, class _Traits> |
1242 | inline |
1243 | basic_ifstream<_CharT, _Traits>& |
1244 | basic_ifstream<_CharT, _Traits>::operator=(basic_ifstream&& __rhs) |
1245 | { |
1246 | basic_istream<char_type, traits_type>::operator=(_VSTDstd::__1::move(__rhs)); |
1247 | __sb_ = _VSTDstd::__1::move(__rhs.__sb_); |
1248 | return *this; |
1249 | } |
1250 | |
1251 | template <class _CharT, class _Traits> |
1252 | inline |
1253 | void |
1254 | basic_ifstream<_CharT, _Traits>::swap(basic_ifstream& __rhs) |
1255 | { |
1256 | basic_istream<char_type, traits_type>::swap(__rhs); |
1257 | __sb_.swap(__rhs.__sb_); |
1258 | } |
1259 | |
1260 | template <class _CharT, class _Traits> |
1261 | inline _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__ )) |
1262 | void |
1263 | swap(basic_ifstream<_CharT, _Traits>& __x, basic_ifstream<_CharT, _Traits>& __y) |
1264 | { |
1265 | __x.swap(__y); |
1266 | } |
1267 | |
1268 | template <class _CharT, class _Traits> |
1269 | inline |
1270 | basic_filebuf<_CharT, _Traits>* |
1271 | basic_ifstream<_CharT, _Traits>::rdbuf() const |
1272 | { |
1273 | return const_cast<basic_filebuf<char_type, traits_type>*>(&__sb_); |
1274 | } |
1275 | |
1276 | template <class _CharT, class _Traits> |
1277 | inline |
1278 | bool |
1279 | basic_ifstream<_CharT, _Traits>::is_open() const |
1280 | { |
1281 | return __sb_.is_open(); |
1282 | } |
1283 | |
1284 | #ifndef _LIBCPP_HAS_NO_GLOBAL_FILESYSTEM_NAMESPACE |
1285 | template <class _CharT, class _Traits> |
1286 | void |
1287 | basic_ifstream<_CharT, _Traits>::open(const char* __s, ios_base::openmode __mode) |
1288 | { |
1289 | if (__sb_.open(__s, __mode | ios_base::in)) |
1290 | this->clear(); |
1291 | else |
1292 | this->setstate(ios_base::failbit); |
1293 | } |
1294 | |
1295 | #ifdef _LIBCPP_HAS_OPEN_WITH_WCHAR |
1296 | template <class _CharT, class _Traits> |
1297 | void |
1298 | basic_ifstream<_CharT, _Traits>::open(const wchar_t* __s, ios_base::openmode __mode) |
1299 | { |
1300 | if (__sb_.open(__s, __mode | ios_base::in)) |
1301 | this->clear(); |
1302 | else |
1303 | this->setstate(ios_base::failbit); |
1304 | } |
1305 | #endif |
1306 | |
1307 | template <class _CharT, class _Traits> |
1308 | void |
1309 | basic_ifstream<_CharT, _Traits>::open(const string& __s, ios_base::openmode __mode) |
1310 | { |
1311 | if (__sb_.open(__s, __mode | ios_base::in)) |
1312 | this->clear(); |
1313 | else |
1314 | this->setstate(ios_base::failbit); |
1315 | } |
1316 | |
1317 | template <class _CharT, class _Traits> |
1318 | inline |
1319 | void basic_ifstream<_CharT, _Traits>::__open(int __fd, |
1320 | ios_base::openmode __mode) { |
1321 | if (__sb_.__open(__fd, __mode | ios_base::in)) |
1322 | this->clear(); |
1323 | else |
1324 | this->setstate(ios_base::failbit); |
1325 | } |
1326 | #endif |
1327 | |
1328 | template <class _CharT, class _Traits> |
1329 | inline |
1330 | void |
1331 | basic_ifstream<_CharT, _Traits>::close() |
1332 | { |
1333 | if (__sb_.close() == 0) |
1334 | this->setstate(ios_base::failbit); |
1335 | } |
1336 | |
1337 | // basic_ofstream |
1338 | |
1339 | template <class _CharT, class _Traits> |
1340 | class _LIBCPP_TEMPLATE_VIS__attribute__ ((__type_visibility__("default"))) basic_ofstream |
1341 | : public basic_ostream<_CharT, _Traits> |
1342 | { |
1343 | public: |
1344 | typedef _CharT char_type; |
1345 | typedef _Traits traits_type; |
1346 | typedef typename traits_type::int_type int_type; |
1347 | typedef typename traits_type::pos_type pos_type; |
1348 | typedef typename traits_type::off_type off_type; |
1349 | |
1350 | _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__ )) |
1351 | basic_ofstream(); |
1352 | _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__ )) |
1353 | explicit basic_ofstream(const char* __s, ios_base::openmode __mode = ios_base::out); |
1354 | #ifdef _LIBCPP_HAS_OPEN_WITH_WCHAR |
1355 | _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__ )) |
1356 | explicit basic_ofstream(const wchar_t* __s, ios_base::openmode __mode = ios_base::out); |
1357 | #endif |
1358 | _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__ )) |
1359 | explicit basic_ofstream(const string& __s, ios_base::openmode __mode = ios_base::out); |
1360 | |
1361 | #if _LIBCPP_STD_VER14 >= 17 && !defined(_LIBCPP_HAS_NO_FILESYSTEM_LIBRARY) |
1362 | _LIBCPP_AVAILABILITY_FILESYSTEM _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__ )) |
1363 | explicit basic_ofstream(const filesystem::path& __p, ios_base::openmode __mode = ios_base::out) |
1364 | : basic_ofstream(__p.c_str(), __mode) {} |
1365 | #endif // _LIBCPP_STD_VER >= 17 |
1366 | |
1367 | _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__ )) |
1368 | basic_ofstream(basic_ofstream&& __rhs); |
1369 | _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__ )) |
1370 | basic_ofstream& operator=(basic_ofstream&& __rhs); |
1371 | _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__ )) |
1372 | void swap(basic_ofstream& __rhs); |
1373 | |
1374 | _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__ )) |
1375 | basic_filebuf<char_type, traits_type>* rdbuf() const; |
1376 | _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__ )) |
1377 | bool is_open() const; |
1378 | #ifndef _LIBCPP_HAS_NO_GLOBAL_FILESYSTEM_NAMESPACE |
1379 | void open(const char* __s, ios_base::openmode __mode = ios_base::out); |
1380 | #ifdef _LIBCPP_HAS_OPEN_WITH_WCHAR |
1381 | void open(const wchar_t* __s, ios_base::openmode __mode = ios_base::out); |
1382 | #endif |
1383 | void open(const string& __s, ios_base::openmode __mode = ios_base::out); |
1384 | |
1385 | #if _LIBCPP_STD_VER14 >= 17 && !defined(_LIBCPP_HAS_NO_FILESYSTEM_LIBRARY) |
1386 | _LIBCPP_AVAILABILITY_FILESYSTEM _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__ )) |
1387 | void open(const filesystem::path& __p, ios_base::openmode __mode = ios_base::out) |
1388 | { return open(__p.c_str(), __mode); } |
1389 | #endif // _LIBCPP_STD_VER >= 17 |
1390 | |
1391 | _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__ )) |
1392 | void __open(int __fd, ios_base::openmode __mode); |
1393 | #endif |
1394 | _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__ )) |
1395 | void close(); |
1396 | |
1397 | private: |
1398 | basic_filebuf<char_type, traits_type> __sb_; |
1399 | }; |
1400 | |
1401 | template <class _CharT, class _Traits> |
1402 | inline |
1403 | basic_ofstream<_CharT, _Traits>::basic_ofstream() |
1404 | : basic_ostream<char_type, traits_type>(&__sb_) |
1405 | { |
1406 | } |
1407 | |
1408 | #ifndef _LIBCPP_HAS_NO_GLOBAL_FILESYSTEM_NAMESPACE |
1409 | template <class _CharT, class _Traits> |
1410 | inline |
1411 | basic_ofstream<_CharT, _Traits>::basic_ofstream(const char* __s, ios_base::openmode __mode) |
1412 | : basic_ostream<char_type, traits_type>(&__sb_) |
1413 | { |
1414 | if (__sb_.open(__s, __mode | ios_base::out) == nullptr) |
1415 | this->setstate(ios_base::failbit); |
1416 | } |
1417 | |
1418 | #ifdef _LIBCPP_HAS_OPEN_WITH_WCHAR |
1419 | template <class _CharT, class _Traits> |
1420 | inline |
1421 | basic_ofstream<_CharT, _Traits>::basic_ofstream(const wchar_t* __s, ios_base::openmode __mode) |
1422 | : basic_ostream<char_type, traits_type>(&__sb_) |
1423 | { |
1424 | if (__sb_.open(__s, __mode | ios_base::out) == nullptr) |
1425 | this->setstate(ios_base::failbit); |
1426 | } |
1427 | #endif |
1428 | |
1429 | template <class _CharT, class _Traits> |
1430 | inline |
1431 | basic_ofstream<_CharT, _Traits>::basic_ofstream(const string& __s, ios_base::openmode __mode) |
1432 | : basic_ostream<char_type, traits_type>(&__sb_) |
1433 | { |
1434 | if (__sb_.open(__s, __mode | ios_base::out) == nullptr) |
1435 | this->setstate(ios_base::failbit); |
1436 | } |
1437 | #endif |
1438 | |
1439 | template <class _CharT, class _Traits> |
1440 | inline |
1441 | basic_ofstream<_CharT, _Traits>::basic_ofstream(basic_ofstream&& __rhs) |
1442 | : basic_ostream<char_type, traits_type>(_VSTDstd::__1::move(__rhs)), |
1443 | __sb_(_VSTDstd::__1::move(__rhs.__sb_)) |
1444 | { |
1445 | this->set_rdbuf(&__sb_); |
1446 | } |
1447 | |
1448 | template <class _CharT, class _Traits> |
1449 | inline |
1450 | basic_ofstream<_CharT, _Traits>& |
1451 | basic_ofstream<_CharT, _Traits>::operator=(basic_ofstream&& __rhs) |
1452 | { |
1453 | basic_ostream<char_type, traits_type>::operator=(_VSTDstd::__1::move(__rhs)); |
1454 | __sb_ = _VSTDstd::__1::move(__rhs.__sb_); |
1455 | return *this; |
1456 | } |
1457 | |
1458 | template <class _CharT, class _Traits> |
1459 | inline |
1460 | void |
1461 | basic_ofstream<_CharT, _Traits>::swap(basic_ofstream& __rhs) |
1462 | { |
1463 | basic_ostream<char_type, traits_type>::swap(__rhs); |
1464 | __sb_.swap(__rhs.__sb_); |
1465 | } |
1466 | |
1467 | template <class _CharT, class _Traits> |
1468 | inline _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__ )) |
1469 | void |
1470 | swap(basic_ofstream<_CharT, _Traits>& __x, basic_ofstream<_CharT, _Traits>& __y) |
1471 | { |
1472 | __x.swap(__y); |
1473 | } |
1474 | |
1475 | template <class _CharT, class _Traits> |
1476 | inline |
1477 | basic_filebuf<_CharT, _Traits>* |
1478 | basic_ofstream<_CharT, _Traits>::rdbuf() const |
1479 | { |
1480 | return const_cast<basic_filebuf<char_type, traits_type>*>(&__sb_); |
1481 | } |
1482 | |
1483 | template <class _CharT, class _Traits> |
1484 | inline |
1485 | bool |
1486 | basic_ofstream<_CharT, _Traits>::is_open() const |
1487 | { |
1488 | return __sb_.is_open(); |
1489 | } |
1490 | |
1491 | #ifndef _LIBCPP_HAS_NO_GLOBAL_FILESYSTEM_NAMESPACE |
1492 | template <class _CharT, class _Traits> |
1493 | void |
1494 | basic_ofstream<_CharT, _Traits>::open(const char* __s, ios_base::openmode __mode) |
1495 | { |
1496 | if (__sb_.open(__s, __mode | ios_base::out)) |
1497 | this->clear(); |
1498 | else |
1499 | this->setstate(ios_base::failbit); |
1500 | } |
1501 | |
1502 | #ifdef _LIBCPP_HAS_OPEN_WITH_WCHAR |
1503 | template <class _CharT, class _Traits> |
1504 | void |
1505 | basic_ofstream<_CharT, _Traits>::open(const wchar_t* __s, ios_base::openmode __mode) |
1506 | { |
1507 | if (__sb_.open(__s, __mode | ios_base::out)) |
1508 | this->clear(); |
1509 | else |
1510 | this->setstate(ios_base::failbit); |
1511 | } |
1512 | #endif |
1513 | |
1514 | template <class _CharT, class _Traits> |
1515 | void |
1516 | basic_ofstream<_CharT, _Traits>::open(const string& __s, ios_base::openmode __mode) |
1517 | { |
1518 | if (__sb_.open(__s, __mode | ios_base::out)) |
1519 | this->clear(); |
1520 | else |
1521 | this->setstate(ios_base::failbit); |
1522 | } |
1523 | |
1524 | template <class _CharT, class _Traits> |
1525 | inline |
1526 | void basic_ofstream<_CharT, _Traits>::__open(int __fd, |
1527 | ios_base::openmode __mode) { |
1528 | if (__sb_.__open(__fd, __mode | ios_base::out)) |
1529 | this->clear(); |
1530 | else |
1531 | this->setstate(ios_base::failbit); |
1532 | } |
1533 | #endif |
1534 | |
1535 | template <class _CharT, class _Traits> |
1536 | inline |
1537 | void |
1538 | basic_ofstream<_CharT, _Traits>::close() |
1539 | { |
1540 | if (__sb_.close() == nullptr) |
1541 | this->setstate(ios_base::failbit); |
1542 | } |
1543 | |
1544 | // basic_fstream |
1545 | |
1546 | template <class _CharT, class _Traits> |
1547 | class _LIBCPP_TEMPLATE_VIS__attribute__ ((__type_visibility__("default"))) basic_fstream |
1548 | : public basic_iostream<_CharT, _Traits> |
1549 | { |
1550 | public: |
1551 | typedef _CharT char_type; |
1552 | typedef _Traits traits_type; |
1553 | typedef typename traits_type::int_type int_type; |
1554 | typedef typename traits_type::pos_type pos_type; |
1555 | typedef typename traits_type::off_type off_type; |
1556 | |
1557 | _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__ )) |
1558 | basic_fstream(); |
1559 | #ifndef _LIBCPP_HAS_NO_GLOBAL_FILESYSTEM_NAMESPACE |
1560 | _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__ )) |
1561 | explicit basic_fstream(const char* __s, ios_base::openmode __mode = ios_base::in | ios_base::out); |
1562 | #ifdef _LIBCPP_HAS_OPEN_WITH_WCHAR |
1563 | _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__ )) |
1564 | explicit basic_fstream(const wchar_t* __s, ios_base::openmode __mode = ios_base::in | ios_base::out); |
1565 | #endif |
1566 | _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__ )) |
1567 | explicit basic_fstream(const string& __s, ios_base::openmode __mode = ios_base::in | ios_base::out); |
1568 | |
1569 | #if _LIBCPP_STD_VER14 >= 17 && !defined(_LIBCPP_HAS_NO_FILESYSTEM_LIBRARY) |
1570 | _LIBCPP_AVAILABILITY_FILESYSTEM _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__ )) |
1571 | explicit basic_fstream(const filesystem::path& __p, ios_base::openmode __mode = ios_base::in | ios_base::out) |
1572 | : basic_fstream(__p.c_str(), __mode) {} |
1573 | #endif // _LIBCPP_STD_VER >= 17 |
1574 | |
1575 | #endif |
1576 | _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__ )) |
1577 | basic_fstream(basic_fstream&& __rhs); |
1578 | |
1579 | _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__ )) |
1580 | basic_fstream& operator=(basic_fstream&& __rhs); |
1581 | |
1582 | _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__ )) |
1583 | void swap(basic_fstream& __rhs); |
1584 | |
1585 | _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__ )) |
1586 | basic_filebuf<char_type, traits_type>* rdbuf() const; |
1587 | _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__ )) |
1588 | bool is_open() const; |
1589 | #ifndef _LIBCPP_HAS_NO_GLOBAL_FILESYSTEM_NAMESPACE |
1590 | void open(const char* __s, ios_base::openmode __mode = ios_base::in | ios_base::out); |
1591 | #ifdef _LIBCPP_HAS_OPEN_WITH_WCHAR |
1592 | void open(const wchar_t* __s, ios_base::openmode __mode = ios_base::in | ios_base::out); |
1593 | #endif |
1594 | void open(const string& __s, ios_base::openmode __mode = ios_base::in | ios_base::out); |
1595 | |
1596 | #if _LIBCPP_STD_VER14 >= 17 && !defined(_LIBCPP_HAS_NO_FILESYSTEM_LIBRARY) |
1597 | _LIBCPP_AVAILABILITY_FILESYSTEM _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__ )) |
1598 | void open(const filesystem::path& __p, ios_base::openmode __mode = ios_base::in|ios_base::out) |
1599 | { return open(__p.c_str(), __mode); } |
1600 | #endif // _LIBCPP_STD_VER >= 17 |
1601 | |
1602 | #endif |
1603 | _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__ )) |
1604 | void close(); |
1605 | |
1606 | private: |
1607 | basic_filebuf<char_type, traits_type> __sb_; |
1608 | }; |
1609 | |
1610 | template <class _CharT, class _Traits> |
1611 | inline |
1612 | basic_fstream<_CharT, _Traits>::basic_fstream() |
1613 | : basic_iostream<char_type, traits_type>(&__sb_) |
1614 | { |
1615 | } |
1616 | |
1617 | #ifndef _LIBCPP_HAS_NO_GLOBAL_FILESYSTEM_NAMESPACE |
1618 | template <class _CharT, class _Traits> |
1619 | inline |
1620 | basic_fstream<_CharT, _Traits>::basic_fstream(const char* __s, ios_base::openmode __mode) |
1621 | : basic_iostream<char_type, traits_type>(&__sb_) |
1622 | { |
1623 | if (__sb_.open(__s, __mode) == nullptr) |
1624 | this->setstate(ios_base::failbit); |
1625 | } |
1626 | |
1627 | #ifdef _LIBCPP_HAS_OPEN_WITH_WCHAR |
1628 | template <class _CharT, class _Traits> |
1629 | inline |
1630 | basic_fstream<_CharT, _Traits>::basic_fstream(const wchar_t* __s, ios_base::openmode __mode) |
1631 | : basic_iostream<char_type, traits_type>(&__sb_) |
1632 | { |
1633 | if (__sb_.open(__s, __mode) == nullptr) |
1634 | this->setstate(ios_base::failbit); |
1635 | } |
1636 | #endif |
1637 | |
1638 | template <class _CharT, class _Traits> |
1639 | inline |
1640 | basic_fstream<_CharT, _Traits>::basic_fstream(const string& __s, ios_base::openmode __mode) |
1641 | : basic_iostream<char_type, traits_type>(&__sb_) |
1642 | { |
1643 | if (__sb_.open(__s, __mode) == nullptr) |
1644 | this->setstate(ios_base::failbit); |
1645 | } |
1646 | #endif |
1647 | |
1648 | template <class _CharT, class _Traits> |
1649 | inline |
1650 | basic_fstream<_CharT, _Traits>::basic_fstream(basic_fstream&& __rhs) |
1651 | : basic_iostream<char_type, traits_type>(_VSTDstd::__1::move(__rhs)), |
1652 | __sb_(_VSTDstd::__1::move(__rhs.__sb_)) |
1653 | { |
1654 | this->set_rdbuf(&__sb_); |
1655 | } |
1656 | |
1657 | template <class _CharT, class _Traits> |
1658 | inline |
1659 | basic_fstream<_CharT, _Traits>& |
1660 | basic_fstream<_CharT, _Traits>::operator=(basic_fstream&& __rhs) |
1661 | { |
1662 | basic_iostream<char_type, traits_type>::operator=(_VSTDstd::__1::move(__rhs)); |
1663 | __sb_ = _VSTDstd::__1::move(__rhs.__sb_); |
1664 | return *this; |
1665 | } |
1666 | |
1667 | template <class _CharT, class _Traits> |
1668 | inline |
1669 | void |
1670 | basic_fstream<_CharT, _Traits>::swap(basic_fstream& __rhs) |
1671 | { |
1672 | basic_iostream<char_type, traits_type>::swap(__rhs); |
1673 | __sb_.swap(__rhs.__sb_); |
1674 | } |
1675 | |
1676 | template <class _CharT, class _Traits> |
1677 | inline _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__ )) |
1678 | void |
1679 | swap(basic_fstream<_CharT, _Traits>& __x, basic_fstream<_CharT, _Traits>& __y) |
1680 | { |
1681 | __x.swap(__y); |
1682 | } |
1683 | |
1684 | template <class _CharT, class _Traits> |
1685 | inline |
1686 | basic_filebuf<_CharT, _Traits>* |
1687 | basic_fstream<_CharT, _Traits>::rdbuf() const |
1688 | { |
1689 | return const_cast<basic_filebuf<char_type, traits_type>*>(&__sb_); |
1690 | } |
1691 | |
1692 | template <class _CharT, class _Traits> |
1693 | inline |
1694 | bool |
1695 | basic_fstream<_CharT, _Traits>::is_open() const |
1696 | { |
1697 | return __sb_.is_open(); |
1698 | } |
1699 | |
1700 | #ifndef _LIBCPP_HAS_NO_GLOBAL_FILESYSTEM_NAMESPACE |
1701 | template <class _CharT, class _Traits> |
1702 | void |
1703 | basic_fstream<_CharT, _Traits>::open(const char* __s, ios_base::openmode __mode) |
1704 | { |
1705 | if (__sb_.open(__s, __mode)) |
1706 | this->clear(); |
1707 | else |
1708 | this->setstate(ios_base::failbit); |
1709 | } |
1710 | |
1711 | #ifdef _LIBCPP_HAS_OPEN_WITH_WCHAR |
1712 | template <class _CharT, class _Traits> |
1713 | void |
1714 | basic_fstream<_CharT, _Traits>::open(const wchar_t* __s, ios_base::openmode __mode) |
1715 | { |
1716 | if (__sb_.open(__s, __mode)) |
1717 | this->clear(); |
1718 | else |
1719 | this->setstate(ios_base::failbit); |
1720 | } |
1721 | #endif |
1722 | |
1723 | template <class _CharT, class _Traits> |
1724 | void |
1725 | basic_fstream<_CharT, _Traits>::open(const string& __s, ios_base::openmode __mode) |
1726 | { |
1727 | if (__sb_.open(__s, __mode)) |
1728 | this->clear(); |
1729 | else |
1730 | this->setstate(ios_base::failbit); |
1731 | } |
1732 | #endif |
1733 | |
1734 | template <class _CharT, class _Traits> |
1735 | inline |
1736 | void |
1737 | basic_fstream<_CharT, _Traits>::close() |
1738 | { |
1739 | if (__sb_.close() == nullptr) |
1740 | this->setstate(ios_base::failbit); |
1741 | } |
1742 | |
1743 | #if defined(_LIBCPP_ABI_ENABLE_ADDITIONAL_IOSTREAM_EXPLICIT_INSTANTIATIONS_1) |
1744 | _LIBCPP_EXTERN_TEMPLATE(class _LIBCPP_EXTERN_TEMPLATE_TYPE_VIS basic_ifstream<char>)extern template class __attribute__ ((__visibility__("default" ))) basic_ifstream<char>; |
1745 | _LIBCPP_EXTERN_TEMPLATE(class _LIBCPP_EXTERN_TEMPLATE_TYPE_VIS basic_ofstream<char>)extern template class __attribute__ ((__visibility__("default" ))) basic_ofstream<char>; |
1746 | _LIBCPP_EXTERN_TEMPLATE(class _LIBCPP_EXTERN_TEMPLATE_TYPE_VIS basic_filebuf<char>)extern template class __attribute__ ((__visibility__("default" ))) basic_filebuf<char>; |
1747 | #endif |
1748 | |
1749 | _LIBCPP_END_NAMESPACE_STD} } |
1750 | |
1751 | _LIBCPP_POP_MACROSpop_macro("min") pop_macro("max") |
1752 | |
1753 | #endif // _LIBCPP_FSTREAM |
1 | // -*- C++ -*- |
2 | //===---------------------------- ios -------------------------------------===// |
3 | // |
4 | // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. |
5 | // See https://llvm.org/LICENSE.txt for license information. |
6 | // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception |
7 | // |
8 | //===----------------------------------------------------------------------===// |
9 | |
10 | #ifndef _LIBCPP_IOS |
11 | #define _LIBCPP_IOS |
12 | |
13 | /* |
14 | ios synopsis |
15 | |
16 | #include <iosfwd> |
17 | |
18 | namespace std |
19 | { |
20 | |
21 | typedef OFF_T streamoff; |
22 | typedef SZ_T streamsize; |
23 | template <class stateT> class fpos; |
24 | |
25 | class ios_base |
26 | { |
27 | public: |
28 | class failure; |
29 | |
30 | typedef T1 fmtflags; |
31 | static constexpr fmtflags boolalpha; |
32 | static constexpr fmtflags dec; |
33 | static constexpr fmtflags fixed; |
34 | static constexpr fmtflags hex; |
35 | static constexpr fmtflags internal; |
36 | static constexpr fmtflags left; |
37 | static constexpr fmtflags oct; |
38 | static constexpr fmtflags right; |
39 | static constexpr fmtflags scientific; |
40 | static constexpr fmtflags showbase; |
41 | static constexpr fmtflags showpoint; |
42 | static constexpr fmtflags showpos; |
43 | static constexpr fmtflags skipws; |
44 | static constexpr fmtflags unitbuf; |
45 | static constexpr fmtflags uppercase; |
46 | static constexpr fmtflags adjustfield; |
47 | static constexpr fmtflags basefield; |
48 | static constexpr fmtflags floatfield; |
49 | |
50 | typedef T2 iostate; |
51 | static constexpr iostate badbit; |
52 | static constexpr iostate eofbit; |
53 | static constexpr iostate failbit; |
54 | static constexpr iostate goodbit; |
55 | |
56 | typedef T3 openmode; |
57 | static constexpr openmode app; |
58 | static constexpr openmode ate; |
59 | static constexpr openmode binary; |
60 | static constexpr openmode in; |
61 | static constexpr openmode out; |
62 | static constexpr openmode trunc; |
63 | |
64 | typedef T4 seekdir; |
65 | static constexpr seekdir beg; |
66 | static constexpr seekdir cur; |
67 | static constexpr seekdir end; |
68 | |
69 | class Init; |
70 | |
71 | // 27.5.2.2 fmtflags state: |
72 | fmtflags flags() const; |
73 | fmtflags flags(fmtflags fmtfl); |
74 | fmtflags setf(fmtflags fmtfl); |
75 | fmtflags setf(fmtflags fmtfl, fmtflags mask); |
76 | void unsetf(fmtflags mask); |
77 | |
78 | streamsize precision() const; |
79 | streamsize precision(streamsize prec); |
80 | streamsize width() const; |
81 | streamsize width(streamsize wide); |
82 | |
83 | // 27.5.2.3 locales: |
84 | locale imbue(const locale& loc); |
85 | locale getloc() const; |
86 | |
87 | // 27.5.2.5 storage: |
88 | static int xalloc(); |
89 | long& iword(int index); |
90 | void*& pword(int index); |
91 | |
92 | // destructor |
93 | virtual ~ios_base(); |
94 | |
95 | // 27.5.2.6 callbacks; |
96 | enum event { erase_event, imbue_event, copyfmt_event }; |
97 | typedef void (*event_callback)(event, ios_base&, int index); |
98 | void register_callback(event_callback fn, int index); |
99 | |
100 | ios_base(const ios_base&) = delete; |
101 | ios_base& operator=(const ios_base&) = delete; |
102 | |
103 | static bool sync_with_stdio(bool sync = true); |
104 | |
105 | protected: |
106 | ios_base(); |
107 | }; |
108 | |
109 | template <class charT, class traits = char_traits<charT> > |
110 | class basic_ios |
111 | : public ios_base |
112 | { |
113 | public: |
114 | // types: |
115 | typedef charT char_type; |
116 | typedef typename traits::int_type int_type; // removed in C++17 |
117 | typedef typename traits::pos_type pos_type; // removed in C++17 |
118 | typedef typename traits::off_type off_type; // removed in C++17 |
119 | typedef traits traits_type; |
120 | |
121 | operator unspecified-bool-type() const; |
122 | bool operator!() const; |
123 | iostate rdstate() const; |
124 | void clear(iostate state = goodbit); |
125 | void setstate(iostate state); |
126 | bool good() const; |
127 | bool eof() const; |
128 | bool fail() const; |
129 | bool bad() const; |
130 | |
131 | iostate exceptions() const; |
132 | void exceptions(iostate except); |
133 | |
134 | // 27.5.4.1 Constructor/destructor: |
135 | explicit basic_ios(basic_streambuf<charT,traits>* sb); |
136 | virtual ~basic_ios(); |
137 | |
138 | // 27.5.4.2 Members: |
139 | basic_ostream<charT,traits>* tie() const; |
140 | basic_ostream<charT,traits>* tie(basic_ostream<charT,traits>* tiestr); |
141 | |
142 | basic_streambuf<charT,traits>* rdbuf() const; |
143 | basic_streambuf<charT,traits>* rdbuf(basic_streambuf<charT,traits>* sb); |
144 | |
145 | basic_ios& copyfmt(const basic_ios& rhs); |
146 | |
147 | char_type fill() const; |
148 | char_type fill(char_type ch); |
149 | |
150 | locale imbue(const locale& loc); |
151 | |
152 | char narrow(char_type c, char dfault) const; |
153 | char_type widen(char c) const; |
154 | |
155 | basic_ios(const basic_ios& ) = delete; |
156 | basic_ios& operator=(const basic_ios&) = delete; |
157 | |
158 | protected: |
159 | basic_ios(); |
160 | void init(basic_streambuf<charT,traits>* sb); |
161 | void move(basic_ios& rhs); |
162 | void swap(basic_ios& rhs) noexcept; |
163 | void set_rdbuf(basic_streambuf<charT, traits>* sb); |
164 | }; |
165 | |
166 | // 27.5.5, manipulators: |
167 | ios_base& boolalpha (ios_base& str); |
168 | ios_base& noboolalpha(ios_base& str); |
169 | ios_base& showbase (ios_base& str); |
170 | ios_base& noshowbase (ios_base& str); |
171 | ios_base& showpoint (ios_base& str); |
172 | ios_base& noshowpoint(ios_base& str); |
173 | ios_base& showpos (ios_base& str); |
174 | ios_base& noshowpos (ios_base& str); |
175 | ios_base& skipws (ios_base& str); |
176 | ios_base& noskipws (ios_base& str); |
177 | ios_base& uppercase (ios_base& str); |
178 | ios_base& nouppercase(ios_base& str); |
179 | ios_base& unitbuf (ios_base& str); |
180 | ios_base& nounitbuf (ios_base& str); |
181 | |
182 | // 27.5.5.2 adjustfield: |
183 | ios_base& internal (ios_base& str); |
184 | ios_base& left (ios_base& str); |
185 | ios_base& right (ios_base& str); |
186 | |
187 | // 27.5.5.3 basefield: |
188 | ios_base& dec (ios_base& str); |
189 | ios_base& hex (ios_base& str); |
190 | ios_base& oct (ios_base& str); |
191 | |
192 | // 27.5.5.4 floatfield: |
193 | ios_base& fixed (ios_base& str); |
194 | ios_base& scientific (ios_base& str); |
195 | ios_base& hexfloat (ios_base& str); |
196 | ios_base& defaultfloat(ios_base& str); |
197 | |
198 | // 27.5.5.5 error reporting: |
199 | enum class io_errc |
200 | { |
201 | stream = 1 |
202 | }; |
203 | |
204 | concept_map ErrorCodeEnum<io_errc> { }; |
205 | error_code make_error_code(io_errc e) noexcept; |
206 | error_condition make_error_condition(io_errc e) noexcept; |
207 | storage-class-specifier const error_category& iostream_category() noexcept; |
208 | |
209 | } // std |
210 | |
211 | */ |
212 | |
213 | #include <__config> |
214 | #include <__locale> |
215 | #include <iosfwd> |
216 | #include <system_error> |
217 | |
218 | #if !defined(_LIBCPP_HAS_NO_ATOMIC_HEADER) |
219 | #include <atomic> // for __xindex_ |
220 | #endif |
221 | |
222 | #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER) |
223 | #pragma GCC system_header |
224 | #endif |
225 | |
226 | _LIBCPP_BEGIN_NAMESPACE_STDnamespace std { inline namespace __1 { |
227 | |
228 | typedef ptrdiff_t streamsize; |
229 | |
230 | class _LIBCPP_TYPE_VIS__attribute__ ((__visibility__("default"))) ios_base |
231 | { |
232 | public: |
233 | class _LIBCPP_EXCEPTION_ABI__attribute__ ((__visibility__("default"))) failure; |
234 | |
235 | typedef unsigned int fmtflags; |
236 | static const fmtflags boolalpha = 0x0001; |
237 | static const fmtflags dec = 0x0002; |
238 | static const fmtflags fixed = 0x0004; |
239 | static const fmtflags hex = 0x0008; |
240 | static const fmtflags internal = 0x0010; |
241 | static const fmtflags left = 0x0020; |
242 | static const fmtflags oct = 0x0040; |
243 | static const fmtflags right = 0x0080; |
244 | static const fmtflags scientific = 0x0100; |
245 | static const fmtflags showbase = 0x0200; |
246 | static const fmtflags showpoint = 0x0400; |
247 | static const fmtflags showpos = 0x0800; |
248 | static const fmtflags skipws = 0x1000; |
249 | static const fmtflags unitbuf = 0x2000; |
250 | static const fmtflags uppercase = 0x4000; |
251 | static const fmtflags adjustfield = left | right | internal; |
252 | static const fmtflags basefield = dec | oct | hex; |
253 | static const fmtflags floatfield = scientific | fixed; |
254 | |
255 | typedef unsigned int iostate; |
256 | static const iostate badbit = 0x1; |
257 | static const iostate eofbit = 0x2; |
258 | static const iostate failbit = 0x4; |
259 | static const iostate goodbit = 0x0; |
260 | |
261 | typedef unsigned int openmode; |
262 | static const openmode app = 0x01; |
263 | static const openmode ate = 0x02; |
264 | static const openmode binary = 0x04; |
265 | static const openmode in = 0x08; |
266 | static const openmode out = 0x10; |
267 | static const openmode trunc = 0x20; |
268 | |
269 | enum seekdir {beg, cur, end}; |
270 | |
271 | #if _LIBCPP_STD_VER14 <= 14 |
272 | typedef iostate io_state; |
273 | typedef openmode open_mode; |
274 | typedef seekdir seek_dir; |
275 | |
276 | typedef _VSTDstd::__1::streamoff streamoff; |
277 | typedef _VSTDstd::__1::streampos streampos; |
278 | #endif |
279 | |
280 | class _LIBCPP_TYPE_VIS__attribute__ ((__visibility__("default"))) Init; |
281 | |
282 | // 27.5.2.2 fmtflags state: |
283 | _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__ )) fmtflags flags() const; |
284 | _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__ )) fmtflags flags(fmtflags __fmtfl); |
285 | _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__ )) fmtflags setf(fmtflags __fmtfl); |
286 | _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__ )) fmtflags setf(fmtflags __fmtfl, fmtflags __mask); |
287 | _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__ )) void unsetf(fmtflags __mask); |
288 | |
289 | _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__ )) streamsize precision() const; |
290 | _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__ )) streamsize precision(streamsize __prec); |
291 | _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__ )) streamsize width() const; |
292 | _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__ )) streamsize width(streamsize __wide); |
293 | |
294 | // 27.5.2.3 locales: |
295 | locale imbue(const locale& __loc); |
296 | locale getloc() const; |
297 | |
298 | // 27.5.2.5 storage: |
299 | static int xalloc(); |
300 | long& iword(int __index); |
301 | void*& pword(int __index); |
302 | |
303 | // destructor |
304 | virtual ~ios_base(); |
305 | |
306 | // 27.5.2.6 callbacks; |
307 | enum event { erase_event, imbue_event, copyfmt_event }; |
308 | typedef void (*event_callback)(event, ios_base&, int __index); |
309 | void register_callback(event_callback __fn, int __index); |
310 | |
311 | private: |
312 | ios_base(const ios_base&); // = delete; |
313 | ios_base& operator=(const ios_base&); // = delete; |
314 | |
315 | public: |
316 | static bool sync_with_stdio(bool __sync = true); |
317 | |
318 | _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__ )) iostate rdstate() const; |
319 | void clear(iostate __state = goodbit); |
320 | _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__ )) void setstate(iostate __state); |
321 | |
322 | _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__ )) bool good() const; |
323 | _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__ )) bool eof() const; |
324 | _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__ )) bool fail() const; |
325 | _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__ )) bool bad() const; |
326 | |
327 | _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__ )) iostate exceptions() const; |
328 | _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__ )) void exceptions(iostate __iostate); |
329 | |
330 | void __set_badbit_and_consider_rethrow(); |
331 | void __set_failbit_and_consider_rethrow(); |
332 | |
333 | _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__ )) |
334 | void __setstate_nothrow(iostate __state) |
335 | { |
336 | if (__rdbuf_) |
337 | __rdstate_ |= __state; |
338 | else |
339 | __rdstate_ |= __state | ios_base::badbit; |
340 | } |
341 | |
342 | protected: |
343 | _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__ )) |
344 | ios_base() {// purposefully does no initialization |
345 | } |
346 | |
347 | void init(void* __sb); |
348 | _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__ )) void* rdbuf() const {return __rdbuf_;} |
349 | |
350 | _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__ )) |
351 | void rdbuf(void* __sb) |
352 | { |
353 | __rdbuf_ = __sb; |
354 | clear(); |
355 | } |
356 | |
357 | void __call_callbacks(event); |
358 | void copyfmt(const ios_base&); |
359 | void move(ios_base&); |
360 | void swap(ios_base&) _NOEXCEPTnoexcept; |
361 | |
362 | _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__ )) |
363 | void set_rdbuf(void* __sb) |
364 | { |
365 | __rdbuf_ = __sb; |
366 | } |
367 | |
368 | private: |
369 | // All data members must be scalars |
370 | fmtflags __fmtflags_; |
371 | streamsize __precision_; |
372 | streamsize __width_; |
373 | iostate __rdstate_; |
374 | iostate __exceptions_; |
375 | void* __rdbuf_; |
376 | void* __loc_; |
377 | event_callback* __fn_; |
378 | int* __index_; |
379 | size_t __event_size_; |
380 | size_t __event_cap_; |
381 | // TODO(EricWF): Enable this for both Clang and GCC. Currently it is only |
382 | // enabled with clang. |
383 | #if defined(_LIBCPP_HAS_C_ATOMIC_IMP) && !defined(_LIBCPP_HAS_NO_THREADS) |
384 | static atomic<int> __xindex_; |
385 | #else |
386 | static int __xindex_; |
387 | #endif |
388 | long* __iarray_; |
389 | size_t __iarray_size_; |
390 | size_t __iarray_cap_; |
391 | void** __parray_; |
392 | size_t __parray_size_; |
393 | size_t __parray_cap_; |
394 | }; |
395 | |
396 | //enum class io_errc |
397 | _LIBCPP_DECLARE_STRONG_ENUM(io_errc)enum class __attribute__ ((__type_visibility__("default"))) io_errc |
398 | { |
399 | stream = 1 |
400 | }; |
401 | _LIBCPP_DECLARE_STRONG_ENUM_EPILOG(io_errc) |
402 | |
403 | template <> |
404 | struct _LIBCPP_TEMPLATE_VIS__attribute__ ((__type_visibility__("default"))) is_error_code_enum<io_errc> : public true_type { }; |
405 | |
406 | #ifdef _LIBCPP_HAS_NO_STRONG_ENUMS |
407 | template <> |
408 | struct _LIBCPP_TEMPLATE_VIS__attribute__ ((__type_visibility__("default"))) is_error_code_enum<io_errc::__lx> : public true_type { }; |
409 | #endif |
410 | |
411 | _LIBCPP_FUNC_VIS__attribute__ ((__visibility__("default"))) |
412 | const error_category& iostream_category() _NOEXCEPTnoexcept; |
413 | |
414 | inline _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__ )) |
415 | error_code |
416 | make_error_code(io_errc __e) _NOEXCEPTnoexcept |
417 | { |
418 | return error_code(static_cast<int>(__e), iostream_category()); |
419 | } |
420 | |
421 | inline _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__ )) |
422 | error_condition |
423 | make_error_condition(io_errc __e) _NOEXCEPTnoexcept |
424 | { |
425 | return error_condition(static_cast<int>(__e), iostream_category()); |
426 | } |
427 | |
428 | class _LIBCPP_EXCEPTION_ABI__attribute__ ((__visibility__("default"))) ios_base::failure |
429 | : public system_error |
430 | { |
431 | public: |
432 | explicit failure(const string& __msg, const error_code& __ec = io_errc::stream); |
433 | explicit failure(const char* __msg, const error_code& __ec = io_errc::stream); |
434 | failure(const failure&) _NOEXCEPTnoexcept = default; |
435 | virtual ~failure() _NOEXCEPTnoexcept; |
436 | }; |
437 | |
438 | _LIBCPP_NORETURN[[noreturn]] inline _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__ )) |
439 | void __throw_failure(char const* __msg) { |
440 | #ifndef _LIBCPP_NO_EXCEPTIONS |
441 | throw ios_base::failure(__msg); |
442 | #else |
443 | ((void)__msg); |
444 | _VSTDstd::__1::abort(); |
445 | #endif |
446 | } |
447 | |
448 | class _LIBCPP_TYPE_VIS__attribute__ ((__visibility__("default"))) ios_base::Init |
449 | { |
450 | public: |
451 | Init(); |
452 | ~Init(); |
453 | }; |
454 | |
455 | // fmtflags |
456 | |
457 | inline _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__ )) |
458 | ios_base::fmtflags |
459 | ios_base::flags() const |
460 | { |
461 | return __fmtflags_; |
462 | } |
463 | |
464 | inline _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__ )) |
465 | ios_base::fmtflags |
466 | ios_base::flags(fmtflags __fmtfl) |
467 | { |
468 | fmtflags __r = __fmtflags_; |
469 | __fmtflags_ = __fmtfl; |
470 | return __r; |
471 | } |
472 | |
473 | inline _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__ )) |
474 | ios_base::fmtflags |
475 | ios_base::setf(fmtflags __fmtfl) |
476 | { |
477 | fmtflags __r = __fmtflags_; |
478 | __fmtflags_ |= __fmtfl; |
479 | return __r; |
480 | } |
481 | |
482 | inline _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__ )) |
483 | void |
484 | ios_base::unsetf(fmtflags __mask) |
485 | { |
486 | __fmtflags_ &= ~__mask; |
487 | } |
488 | |
489 | inline _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__ )) |
490 | ios_base::fmtflags |
491 | ios_base::setf(fmtflags __fmtfl, fmtflags __mask) |
492 | { |
493 | fmtflags __r = __fmtflags_; |
494 | unsetf(__mask); |
495 | __fmtflags_ |= __fmtfl & __mask; |
496 | return __r; |
497 | } |
498 | |
499 | // precision |
500 | |
501 | inline _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__ )) |
502 | streamsize |
503 | ios_base::precision() const |
504 | { |
505 | return __precision_; |
506 | } |
507 | |
508 | inline _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__ )) |
509 | streamsize |
510 | ios_base::precision(streamsize __prec) |
511 | { |
512 | streamsize __r = __precision_; |
513 | __precision_ = __prec; |
514 | return __r; |
515 | } |
516 | |
517 | // width |
518 | |
519 | inline _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__ )) |
520 | streamsize |
521 | ios_base::width() const |
522 | { |
523 | return __width_; |
524 | } |
525 | |
526 | inline _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__ )) |
527 | streamsize |
528 | ios_base::width(streamsize __wide) |
529 | { |
530 | streamsize __r = __width_; |
531 | __width_ = __wide; |
532 | return __r; |
533 | } |
534 | |
535 | // iostate |
536 | |
537 | inline _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__ )) |
538 | ios_base::iostate |
539 | ios_base::rdstate() const |
540 | { |
541 | return __rdstate_; |
542 | } |
543 | |
544 | inline _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__ )) |
545 | void |
546 | ios_base::setstate(iostate __state) |
547 | { |
548 | clear(__rdstate_ | __state); |
549 | } |
550 | |
551 | inline _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__ )) |
552 | bool |
553 | ios_base::good() const |
554 | { |
555 | return __rdstate_ == 0; |
556 | } |
557 | |
558 | inline _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__ )) |
559 | bool |
560 | ios_base::eof() const |
561 | { |
562 | return (__rdstate_ & eofbit) != 0; |
563 | } |
564 | |
565 | inline _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__ )) |
566 | bool |
567 | ios_base::fail() const |
568 | { |
569 | return (__rdstate_ & (failbit | badbit)) != 0; |
570 | } |
571 | |
572 | inline _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__ )) |
573 | bool |
574 | ios_base::bad() const |
575 | { |
576 | return (__rdstate_ & badbit) != 0; |
577 | } |
578 | |
579 | inline _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__ )) |
580 | ios_base::iostate |
581 | ios_base::exceptions() const |
582 | { |
583 | return __exceptions_; |
584 | } |
585 | |
586 | inline _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__ )) |
587 | void |
588 | ios_base::exceptions(iostate __iostate) |
589 | { |
590 | __exceptions_ = __iostate; |
591 | clear(__rdstate_); |
592 | } |
593 | |
594 | template <class _CharT, class _Traits> |
595 | class _LIBCPP_TEMPLATE_VIS__attribute__ ((__type_visibility__("default"))) basic_ios |
596 | : public ios_base |
597 | { |
598 | public: |
599 | // types: |
600 | typedef _CharT char_type; |
601 | typedef _Traits traits_type; |
602 | |
603 | typedef typename traits_type::int_type int_type; |
604 | typedef typename traits_type::pos_type pos_type; |
605 | typedef typename traits_type::off_type off_type; |
606 | |
607 | static_assert((is_same<_CharT, typename traits_type::char_type>::value), |
608 | "traits_type::char_type must be the same type as CharT"); |
609 | |
610 | #ifdef _LIBCPP_CXX03_LANG |
611 | // Preserve the ability to compare with literal 0, |
612 | // and implicitly convert to bool, but not implicitly convert to int. |
613 | _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__ )) |
614 | operator void*() const {return fail() ? nullptr : (void*)this;} |
615 | #else |
616 | _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__ )) |
617 | explicit operator bool() const {return !fail();} |
618 | #endif |
619 | |
620 | _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__ )) bool operator!() const {return fail();} |
621 | _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__ )) iostate rdstate() const {return ios_base::rdstate();} |
622 | _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__ )) void clear(iostate __state = goodbit) {ios_base::clear(__state);} |
623 | _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__ )) void setstate(iostate __state) {ios_base::setstate(__state);} |
624 | _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__ )) bool good() const {return ios_base::good();} |
625 | _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__ )) bool eof() const {return ios_base::eof();} |
626 | _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__ )) bool fail() const {return ios_base::fail();} |
627 | _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__ )) bool bad() const {return ios_base::bad();} |
628 | |
629 | _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__ )) iostate exceptions() const {return ios_base::exceptions();} |
630 | _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__ )) void exceptions(iostate __iostate) {ios_base::exceptions(__iostate);} |
631 | |
632 | // 27.5.4.1 Constructor/destructor: |
633 | _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__ )) |
634 | explicit basic_ios(basic_streambuf<char_type,traits_type>* __sb); |
635 | virtual ~basic_ios(); |
636 | |
637 | // 27.5.4.2 Members: |
638 | _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__ )) |
639 | basic_ostream<char_type, traits_type>* tie() const; |
640 | _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__ )) |
641 | basic_ostream<char_type, traits_type>* tie(basic_ostream<char_type, traits_type>* __tiestr); |
642 | |
643 | _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__ )) |
644 | basic_streambuf<char_type, traits_type>* rdbuf() const; |
645 | _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__ )) |
646 | basic_streambuf<char_type, traits_type>* rdbuf(basic_streambuf<char_type, traits_type>* __sb); |
647 | |
648 | basic_ios& copyfmt(const basic_ios& __rhs); |
649 | |
650 | _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__ )) |
651 | char_type fill() const; |
652 | _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__ )) |
653 | char_type fill(char_type __ch); |
654 | |
655 | _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__ )) |
656 | locale imbue(const locale& __loc); |
657 | |
658 | _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__ )) |
659 | char narrow(char_type __c, char __dfault) const; |
660 | _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__ )) |
661 | char_type widen(char __c) const; |
662 | |
663 | protected: |
664 | _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__ )) |
665 | basic_ios() {// purposefully does no initialization |
666 | } |
667 | _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__ )) |
668 | void init(basic_streambuf<char_type, traits_type>* __sb); |
669 | |
670 | _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__ )) |
671 | void move(basic_ios& __rhs); |
672 | _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__ )) |
673 | void move(basic_ios&& __rhs) {move(__rhs);} |
674 | _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__ )) |
675 | void swap(basic_ios& __rhs) _NOEXCEPTnoexcept; |
676 | _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__ )) |
677 | void set_rdbuf(basic_streambuf<char_type, traits_type>* __sb); |
678 | private: |
679 | basic_ostream<char_type, traits_type>* __tie_; |
680 | mutable int_type __fill_; |
681 | }; |
682 | |
683 | template <class _CharT, class _Traits> |
684 | inline _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__ )) |
685 | basic_ios<_CharT, _Traits>::basic_ios(basic_streambuf<char_type,traits_type>* __sb) |
686 | { |
687 | init(__sb); |
688 | } |
689 | |
690 | template <class _CharT, class _Traits> |
691 | basic_ios<_CharT, _Traits>::~basic_ios() |
692 | { |
693 | } |
694 | |
695 | template <class _CharT, class _Traits> |
696 | inline _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__ )) |
697 | void |
698 | basic_ios<_CharT, _Traits>::init(basic_streambuf<char_type, traits_type>* __sb) |
699 | { |
700 | ios_base::init(__sb); |
701 | __tie_ = nullptr; |
702 | __fill_ = traits_type::eof(); |
703 | } |
704 | |
705 | template <class _CharT, class _Traits> |
706 | inline _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__ )) |
707 | basic_ostream<_CharT, _Traits>* |
708 | basic_ios<_CharT, _Traits>::tie() const |
709 | { |
710 | return __tie_; |
711 | } |
712 | |
713 | template <class _CharT, class _Traits> |
714 | inline _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__ )) |
715 | basic_ostream<_CharT, _Traits>* |
716 | basic_ios<_CharT, _Traits>::tie(basic_ostream<char_type, traits_type>* __tiestr) |
717 | { |
718 | basic_ostream<char_type, traits_type>* __r = __tie_; |
719 | __tie_ = __tiestr; |
720 | return __r; |
721 | } |
722 | |
723 | template <class _CharT, class _Traits> |
724 | inline _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__ )) |
725 | basic_streambuf<_CharT, _Traits>* |
726 | basic_ios<_CharT, _Traits>::rdbuf() const |
727 | { |
728 | return static_cast<basic_streambuf<char_type, traits_type>*>(ios_base::rdbuf()); |
729 | } |
730 | |
731 | template <class _CharT, class _Traits> |
732 | inline _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__ )) |
733 | basic_streambuf<_CharT, _Traits>* |
734 | basic_ios<_CharT, _Traits>::rdbuf(basic_streambuf<char_type, traits_type>* __sb) |
735 | { |
736 | basic_streambuf<char_type, traits_type>* __r = rdbuf(); |
737 | ios_base::rdbuf(__sb); |
738 | return __r; |
739 | } |
740 | |
741 | template <class _CharT, class _Traits> |
742 | inline _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__ )) |
743 | locale |
744 | basic_ios<_CharT, _Traits>::imbue(const locale& __loc) |
745 | { |
746 | locale __r = getloc(); |
747 | ios_base::imbue(__loc); |
748 | if (rdbuf()) |
749 | rdbuf()->pubimbue(__loc); |
750 | return __r; |
751 | } |
752 | |
753 | template <class _CharT, class _Traits> |
754 | inline _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__ )) |
755 | char |
756 | basic_ios<_CharT, _Traits>::narrow(char_type __c, char __dfault) const |
757 | { |
758 | return use_facet<ctype<char_type> >(getloc()).narrow(__c, __dfault); |
759 | } |
760 | |
761 | template <class _CharT, class _Traits> |
762 | inline _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__ )) |
763 | _CharT |
764 | basic_ios<_CharT, _Traits>::widen(char __c) const |
765 | { |
766 | return use_facet<ctype<char_type> >(getloc()).widen(__c); |
767 | } |
768 | |
769 | template <class _CharT, class _Traits> |
770 | inline _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__ )) |
771 | _CharT |
772 | basic_ios<_CharT, _Traits>::fill() const |
773 | { |
774 | if (traits_type::eq_int_type(traits_type::eof(), __fill_)) |
775 | __fill_ = widen(' '); |
776 | return __fill_; |
777 | } |
778 | |
779 | template <class _CharT, class _Traits> |
780 | inline _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__ )) |
781 | _CharT |
782 | basic_ios<_CharT, _Traits>::fill(char_type __ch) |
783 | { |
784 | char_type __r = __fill_; |
785 | __fill_ = __ch; |
786 | return __r; |
787 | } |
788 | |
789 | template <class _CharT, class _Traits> |
790 | basic_ios<_CharT, _Traits>& |
791 | basic_ios<_CharT, _Traits>::copyfmt(const basic_ios& __rhs) |
792 | { |
793 | if (this != &__rhs) |
794 | { |
795 | __call_callbacks(erase_event); |
796 | ios_base::copyfmt(__rhs); |
797 | __tie_ = __rhs.__tie_; |
798 | __fill_ = __rhs.__fill_; |
799 | __call_callbacks(copyfmt_event); |
800 | exceptions(__rhs.exceptions()); |
801 | } |
802 | return *this; |
803 | } |
804 | |
805 | template <class _CharT, class _Traits> |
806 | inline _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__ )) |
807 | void |
808 | basic_ios<_CharT, _Traits>::move(basic_ios& __rhs) |
809 | { |
810 | ios_base::move(__rhs); |
811 | __tie_ = __rhs.__tie_; |
812 | __rhs.__tie_ = nullptr; |
813 | __fill_ = __rhs.__fill_; |
814 | } |
815 | |
816 | template <class _CharT, class _Traits> |
817 | inline _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__ )) |
818 | void |
819 | basic_ios<_CharT, _Traits>::swap(basic_ios& __rhs) _NOEXCEPTnoexcept |
820 | { |
821 | ios_base::swap(__rhs); |
822 | _VSTDstd::__1::swap(__tie_, __rhs.__tie_); |
823 | _VSTDstd::__1::swap(__fill_, __rhs.__fill_); |
824 | } |
825 | |
826 | template <class _CharT, class _Traits> |
827 | inline _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__ )) |
828 | void |
829 | basic_ios<_CharT, _Traits>::set_rdbuf(basic_streambuf<char_type, traits_type>* __sb) |
830 | { |
831 | ios_base::set_rdbuf(__sb); |
832 | } |
833 | |
834 | inline |
835 | ios_base& |
836 | boolalpha(ios_base& __str) |
837 | { |
838 | __str.setf(ios_base::boolalpha); |
839 | return __str; |
840 | } |
841 | |
842 | inline |
843 | ios_base& |
844 | noboolalpha(ios_base& __str) |
845 | { |
846 | __str.unsetf(ios_base::boolalpha); |
847 | return __str; |
848 | } |
849 | |
850 | inline |
851 | ios_base& |
852 | showbase(ios_base& __str) |
853 | { |
854 | __str.setf(ios_base::showbase); |
855 | return __str; |
856 | } |
857 | |
858 | inline |
859 | ios_base& |
860 | noshowbase(ios_base& __str) |
861 | { |
862 | __str.unsetf(ios_base::showbase); |
863 | return __str; |
864 | } |
865 | |
866 | inline |
867 | ios_base& |
868 | showpoint(ios_base& __str) |
869 | { |
870 | __str.setf(ios_base::showpoint); |
871 | return __str; |
872 | } |
873 | |
874 | inline |
875 | ios_base& |
876 | noshowpoint(ios_base& __str) |
877 | { |
878 | __str.unsetf(ios_base::showpoint); |
879 | return __str; |
880 | } |
881 | |
882 | inline |
883 | ios_base& |
884 | showpos(ios_base& __str) |
885 | { |
886 | __str.setf(ios_base::showpos); |
887 | return __str; |
888 | } |
889 | |
890 | inline |
891 | ios_base& |
892 | noshowpos(ios_base& __str) |
893 | { |
894 | __str.unsetf(ios_base::showpos); |
895 | return __str; |
896 | } |
897 | |
898 | inline |
899 | ios_base& |
900 | skipws(ios_base& __str) |
901 | { |
902 | __str.setf(ios_base::skipws); |
903 | return __str; |
904 | } |
905 | |
906 | inline |
907 | ios_base& |
908 | noskipws(ios_base& __str) |
909 | { |
910 | __str.unsetf(ios_base::skipws); |
911 | return __str; |
912 | } |
913 | |
914 | inline |
915 | ios_base& |
916 | uppercase(ios_base& __str) |
917 | { |
918 | __str.setf(ios_base::uppercase); |
919 | return __str; |
920 | } |
921 | |
922 | inline |
923 | ios_base& |
924 | nouppercase(ios_base& __str) |
925 | { |
926 | __str.unsetf(ios_base::uppercase); |
927 | return __str; |
928 | } |
929 | |
930 | inline |
931 | ios_base& |
932 | unitbuf(ios_base& __str) |
933 | { |
934 | __str.setf(ios_base::unitbuf); |
935 | return __str; |
936 | } |
937 | |
938 | inline |
939 | ios_base& |
940 | nounitbuf(ios_base& __str) |
941 | { |
942 | __str.unsetf(ios_base::unitbuf); |
943 | return __str; |
944 | } |
945 | |
946 | inline |
947 | ios_base& |
948 | internal(ios_base& __str) |
949 | { |
950 | __str.setf(ios_base::internal, ios_base::adjustfield); |
951 | return __str; |
952 | } |
953 | |
954 | inline |
955 | ios_base& |
956 | left(ios_base& __str) |
957 | { |
958 | __str.setf(ios_base::left, ios_base::adjustfield); |
959 | return __str; |
960 | } |
961 | |
962 | inline |
963 | ios_base& |
964 | right(ios_base& __str) |
965 | { |
966 | __str.setf(ios_base::right, ios_base::adjustfield); |
967 | return __str; |
968 | } |
969 | |
970 | inline |
971 | ios_base& |
972 | dec(ios_base& __str) |
973 | { |
974 | __str.setf(ios_base::dec, ios_base::basefield); |
975 | return __str; |
976 | } |
977 | |
978 | inline |
979 | ios_base& |
980 | hex(ios_base& __str) |
981 | { |
982 | __str.setf(ios_base::hex, ios_base::basefield); |
983 | return __str; |
984 | } |
985 | |
986 | inline |
987 | ios_base& |
988 | oct(ios_base& __str) |
989 | { |
990 | __str.setf(ios_base::oct, ios_base::basefield); |
991 | return __str; |
992 | } |
993 | |
994 | inline |
995 | ios_base& |
996 | fixed(ios_base& __str) |
997 | { |
998 | __str.setf(ios_base::fixed, ios_base::floatfield); |
999 | return __str; |
1000 | } |
1001 | |
1002 | inline |
1003 | ios_base& |
1004 | scientific(ios_base& __str) |
1005 | { |
1006 | __str.setf(ios_base::scientific, ios_base::floatfield); |
1007 | return __str; |
1008 | } |
1009 | |
1010 | inline |
1011 | ios_base& |
1012 | hexfloat(ios_base& __str) |
1013 | { |
1014 | __str.setf(ios_base::fixed | ios_base::scientific, ios_base::floatfield); |
1015 | return __str; |
1016 | } |
1017 | |
1018 | inline |
1019 | ios_base& |
1020 | defaultfloat(ios_base& __str) |
1021 | { |
1022 | __str.unsetf(ios_base::floatfield); |
1023 | return __str; |
1024 | } |
1025 | |
1026 | _LIBCPP_END_NAMESPACE_STD} } |
1027 | |
1028 | #endif // _LIBCPP_IOS |
1 | // -*- C++ -*- |
2 | //===--------------------------- string -----------------------------------===// |
3 | // |
4 | // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. |
5 | // See https://llvm.org/LICENSE.txt for license information. |
6 | // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception |
7 | // |
8 | //===----------------------------------------------------------------------===// |
9 | |
10 | #ifndef _LIBCPP_STRING |
11 | #define _LIBCPP_STRING |
12 | |
13 | /* |
14 | string synopsis |
15 | |
16 | namespace std |
17 | { |
18 | |
19 | template <class stateT> |
20 | class fpos |
21 | { |
22 | private: |
23 | stateT st; |
24 | public: |
25 | fpos(streamoff = streamoff()); |
26 | |
27 | operator streamoff() const; |
28 | |
29 | stateT state() const; |
30 | void state(stateT); |
31 | |
32 | fpos& operator+=(streamoff); |
33 | fpos operator+ (streamoff) const; |
34 | fpos& operator-=(streamoff); |
35 | fpos operator- (streamoff) const; |
36 | }; |
37 | |
38 | template <class stateT> streamoff operator-(const fpos<stateT>& x, const fpos<stateT>& y); |
39 | |
40 | template <class stateT> bool operator==(const fpos<stateT>& x, const fpos<stateT>& y); |
41 | template <class stateT> bool operator!=(const fpos<stateT>& x, const fpos<stateT>& y); |
42 | |
43 | template <class charT> |
44 | struct char_traits |
45 | { |
46 | typedef charT char_type; |
47 | typedef ... int_type; |
48 | typedef streamoff off_type; |
49 | typedef streampos pos_type; |
50 | typedef mbstate_t state_type; |
51 | |
52 | static void assign(char_type& c1, const char_type& c2) noexcept; |
53 | static constexpr bool eq(char_type c1, char_type c2) noexcept; |
54 | static constexpr bool lt(char_type c1, char_type c2) noexcept; |
55 | |
56 | static int compare(const char_type* s1, const char_type* s2, size_t n); |
57 | static size_t length(const char_type* s); |
58 | static const char_type* find(const char_type* s, size_t n, const char_type& a); |
59 | static char_type* move(char_type* s1, const char_type* s2, size_t n); |
60 | static char_type* copy(char_type* s1, const char_type* s2, size_t n); |
61 | static char_type* assign(char_type* s, size_t n, char_type a); |
62 | |
63 | static constexpr int_type not_eof(int_type c) noexcept; |
64 | static constexpr char_type to_char_type(int_type c) noexcept; |
65 | static constexpr int_type to_int_type(char_type c) noexcept; |
66 | static constexpr bool eq_int_type(int_type c1, int_type c2) noexcept; |
67 | static constexpr int_type eof() noexcept; |
68 | }; |
69 | |
70 | template <> struct char_traits<char>; |
71 | template <> struct char_traits<wchar_t>; |
72 | template <> struct char_traits<char8_t>; // C++20 |
73 | template <> struct char_traits<char16_t>; |
74 | template <> struct char_traits<char32_t>; |
75 | |
76 | template<class charT, class traits = char_traits<charT>, class Allocator = allocator<charT> > |
77 | class basic_string |
78 | { |
79 | public: |
80 | // types: |
81 | typedef traits traits_type; |
82 | typedef typename traits_type::char_type value_type; |
83 | typedef Allocator allocator_type; |
84 | typedef typename allocator_type::size_type size_type; |
85 | typedef typename allocator_type::difference_type difference_type; |
86 | typedef typename allocator_type::reference reference; |
87 | typedef typename allocator_type::const_reference const_reference; |
88 | typedef typename allocator_type::pointer pointer; |
89 | typedef typename allocator_type::const_pointer const_pointer; |
90 | typedef implementation-defined iterator; |
91 | typedef implementation-defined const_iterator; |
92 | typedef std::reverse_iterator<iterator> reverse_iterator; |
93 | typedef std::reverse_iterator<const_iterator> const_reverse_iterator; |
94 | |
95 | static const size_type npos = -1; |
96 | |
97 | basic_string() |
98 | noexcept(is_nothrow_default_constructible<allocator_type>::value); |
99 | explicit basic_string(const allocator_type& a); |
100 | basic_string(const basic_string& str); |
101 | basic_string(basic_string&& str) |
102 | noexcept(is_nothrow_move_constructible<allocator_type>::value); |
103 | basic_string(const basic_string& str, size_type pos, |
104 | const allocator_type& a = allocator_type()); |
105 | basic_string(const basic_string& str, size_type pos, size_type n, |
106 | const Allocator& a = Allocator()); |
107 | template<class T> |
108 | basic_string(const T& t, size_type pos, size_type n, const Allocator& a = Allocator()); // C++17 |
109 | template <class T> |
110 | explicit basic_string(const T& t, const Allocator& a = Allocator()); // C++17 |
111 | basic_string(const value_type* s, const allocator_type& a = allocator_type()); |
112 | basic_string(const value_type* s, size_type n, const allocator_type& a = allocator_type()); |
113 | basic_string(nullptr_t) = delete; // C++2b |
114 | basic_string(size_type n, value_type c, const allocator_type& a = allocator_type()); |
115 | template<class InputIterator> |
116 | basic_string(InputIterator begin, InputIterator end, |
117 | const allocator_type& a = allocator_type()); |
118 | basic_string(initializer_list<value_type>, const Allocator& = Allocator()); |
119 | basic_string(const basic_string&, const Allocator&); |
120 | basic_string(basic_string&&, const Allocator&); |
121 | |
122 | ~basic_string(); |
123 | |
124 | operator basic_string_view<charT, traits>() const noexcept; |
125 | |
126 | basic_string& operator=(const basic_string& str); |
127 | template <class T> |
128 | basic_string& operator=(const T& t); // C++17 |
129 | basic_string& operator=(basic_string&& str) |
130 | noexcept( |
131 | allocator_type::propagate_on_container_move_assignment::value || |
132 | allocator_type::is_always_equal::value ); // C++17 |
133 | basic_string& operator=(const value_type* s); |
134 | basic_string& operator=(nullptr_t) = delete; // C++2b |
135 | basic_string& operator=(value_type c); |
136 | basic_string& operator=(initializer_list<value_type>); |
137 | |
138 | iterator begin() noexcept; |
139 | const_iterator begin() const noexcept; |
140 | iterator end() noexcept; |
141 | const_iterator end() const noexcept; |
142 | |
143 | reverse_iterator rbegin() noexcept; |
144 | const_reverse_iterator rbegin() const noexcept; |
145 | reverse_iterator rend() noexcept; |
146 | const_reverse_iterator rend() const noexcept; |
147 | |
148 | const_iterator cbegin() const noexcept; |
149 | const_iterator cend() const noexcept; |
150 | const_reverse_iterator crbegin() const noexcept; |
151 | const_reverse_iterator crend() const noexcept; |
152 | |
153 | size_type size() const noexcept; |
154 | size_type length() const noexcept; |
155 | size_type max_size() const noexcept; |
156 | size_type capacity() const noexcept; |
157 | |
158 | void resize(size_type n, value_type c); |
159 | void resize(size_type n); |
160 | |
161 | void reserve(size_type res_arg); |
162 | void reserve(); // deprecated in C++20 |
163 | void shrink_to_fit(); |
164 | void clear() noexcept; |
165 | bool empty() const noexcept; |
166 | |
167 | const_reference operator[](size_type pos) const; |
168 | reference operator[](size_type pos); |
169 | |
170 | const_reference at(size_type n) const; |
171 | reference at(size_type n); |
172 | |
173 | basic_string& operator+=(const basic_string& str); |
174 | template <class T> |
175 | basic_string& operator+=(const T& t); // C++17 |
176 | basic_string& operator+=(const value_type* s); |
177 | basic_string& operator+=(value_type c); |
178 | basic_string& operator+=(initializer_list<value_type>); |
179 | |
180 | basic_string& append(const basic_string& str); |
181 | template <class T> |
182 | basic_string& append(const T& t); // C++17 |
183 | basic_string& append(const basic_string& str, size_type pos, size_type n=npos); //C++14 |
184 | template <class T> |
185 | basic_string& append(const T& t, size_type pos, size_type n=npos); // C++17 |
186 | basic_string& append(const value_type* s, size_type n); |
187 | basic_string& append(const value_type* s); |
188 | basic_string& append(size_type n, value_type c); |
189 | template<class InputIterator> |
190 | basic_string& append(InputIterator first, InputIterator last); |
191 | basic_string& append(initializer_list<value_type>); |
192 | |
193 | void push_back(value_type c); |
194 | void pop_back(); |
195 | reference front(); |
196 | const_reference front() const; |
197 | reference back(); |
198 | const_reference back() const; |
199 | |
200 | basic_string& assign(const basic_string& str); |
201 | template <class T> |
202 | basic_string& assign(const T& t); // C++17 |
203 | basic_string& assign(basic_string&& str); |
204 | basic_string& assign(const basic_string& str, size_type pos, size_type n=npos); // C++14 |
205 | template <class T> |
206 | basic_string& assign(const T& t, size_type pos, size_type n=npos); // C++17 |
207 | basic_string& assign(const value_type* s, size_type n); |
208 | basic_string& assign(const value_type* s); |
209 | basic_string& assign(size_type n, value_type c); |
210 | template<class InputIterator> |
211 | basic_string& assign(InputIterator first, InputIterator last); |
212 | basic_string& assign(initializer_list<value_type>); |
213 | |
214 | basic_string& insert(size_type pos1, const basic_string& str); |
215 | template <class T> |
216 | basic_string& insert(size_type pos1, const T& t); |
217 | basic_string& insert(size_type pos1, const basic_string& str, |
218 | size_type pos2, size_type n); |
219 | template <class T> |
220 | basic_string& insert(size_type pos1, const T& t, size_type pos2, size_type n); // C++17 |
221 | basic_string& insert(size_type pos, const value_type* s, size_type n=npos); //C++14 |
222 | basic_string& insert(size_type pos, const value_type* s); |
223 | basic_string& insert(size_type pos, size_type n, value_type c); |
224 | iterator insert(const_iterator p, value_type c); |
225 | iterator insert(const_iterator p, size_type n, value_type c); |
226 | template<class InputIterator> |
227 | iterator insert(const_iterator p, InputIterator first, InputIterator last); |
228 | iterator insert(const_iterator p, initializer_list<value_type>); |
229 | |
230 | basic_string& erase(size_type pos = 0, size_type n = npos); |
231 | iterator erase(const_iterator position); |
232 | iterator erase(const_iterator first, const_iterator last); |
233 | |
234 | basic_string& replace(size_type pos1, size_type n1, const basic_string& str); |
235 | template <class T> |
236 | basic_string& replace(size_type pos1, size_type n1, const T& t); // C++17 |
237 | basic_string& replace(size_type pos1, size_type n1, const basic_string& str, |
238 | size_type pos2, size_type n2=npos); // C++14 |
239 | template <class T> |
240 | basic_string& replace(size_type pos1, size_type n1, const T& t, |
241 | size_type pos2, size_type n); // C++17 |
242 | basic_string& replace(size_type pos, size_type n1, const value_type* s, size_type n2); |
243 | basic_string& replace(size_type pos, size_type n1, const value_type* s); |
244 | basic_string& replace(size_type pos, size_type n1, size_type n2, value_type c); |
245 | basic_string& replace(const_iterator i1, const_iterator i2, const basic_string& str); |
246 | template <class T> |
247 | basic_string& replace(const_iterator i1, const_iterator i2, const T& t); // C++17 |
248 | basic_string& replace(const_iterator i1, const_iterator i2, const value_type* s, size_type n); |
249 | basic_string& replace(const_iterator i1, const_iterator i2, const value_type* s); |
250 | basic_string& replace(const_iterator i1, const_iterator i2, size_type n, value_type c); |
251 | template<class InputIterator> |
252 | basic_string& replace(const_iterator i1, const_iterator i2, InputIterator j1, InputIterator j2); |
253 | basic_string& replace(const_iterator i1, const_iterator i2, initializer_list<value_type>); |
254 | |
255 | size_type copy(value_type* s, size_type n, size_type pos = 0) const; |
256 | basic_string substr(size_type pos = 0, size_type n = npos) const; |
257 | |
258 | void swap(basic_string& str) |
259 | noexcept(allocator_traits<allocator_type>::propagate_on_container_swap::value || |
260 | allocator_traits<allocator_type>::is_always_equal::value); // C++17 |
261 | |
262 | const value_type* c_str() const noexcept; |
263 | const value_type* data() const noexcept; |
264 | value_type* data() noexcept; // C++17 |
265 | |
266 | allocator_type get_allocator() const noexcept; |
267 | |
268 | size_type find(const basic_string& str, size_type pos = 0) const noexcept; |
269 | template <class T> |
270 | size_type find(const T& t, size_type pos = 0) const noexcept; // C++17, noexcept as an extension |
271 | size_type find(const value_type* s, size_type pos, size_type n) const noexcept; |
272 | size_type find(const value_type* s, size_type pos = 0) const noexcept; |
273 | size_type find(value_type c, size_type pos = 0) const noexcept; |
274 | |
275 | size_type rfind(const basic_string& str, size_type pos = npos) const noexcept; |
276 | template <class T> |
277 | size_type rfind(const T& t, size_type pos = npos) const noexcept; // C++17, noexcept as an extension |
278 | size_type rfind(const value_type* s, size_type pos, size_type n) const noexcept; |
279 | size_type rfind(const value_type* s, size_type pos = npos) const noexcept; |
280 | size_type rfind(value_type c, size_type pos = npos) const noexcept; |
281 | |
282 | size_type find_first_of(const basic_string& str, size_type pos = 0) const noexcept; |
283 | template <class T> |
284 | size_type find_first_of(const T& t, size_type pos = 0) const noexcept; // C++17, noexcept as an extension |
285 | size_type find_first_of(const value_type* s, size_type pos, size_type n) const noexcept; |
286 | size_type find_first_of(const value_type* s, size_type pos = 0) const noexcept; |
287 | size_type find_first_of(value_type c, size_type pos = 0) const noexcept; |
288 | |
289 | size_type find_last_of(const basic_string& str, size_type pos = npos) const noexcept; |
290 | template <class T> |
291 | size_type find_last_of(const T& t, size_type pos = npos) const noexcept noexcept; // C++17, noexcept as an extension |
292 | size_type find_last_of(const value_type* s, size_type pos, size_type n) const noexcept; |
293 | size_type find_last_of(const value_type* s, size_type pos = npos) const noexcept; |
294 | size_type find_last_of(value_type c, size_type pos = npos) const noexcept; |
295 | |
296 | size_type find_first_not_of(const basic_string& str, size_type pos = 0) const noexcept; |
297 | template <class T> |
298 | size_type find_first_not_of(const T& t, size_type pos = 0) const noexcept; // C++17, noexcept as an extension |
299 | size_type find_first_not_of(const value_type* s, size_type pos, size_type n) const noexcept; |
300 | size_type find_first_not_of(const value_type* s, size_type pos = 0) const noexcept; |
301 | size_type find_first_not_of(value_type c, size_type pos = 0) const noexcept; |
302 | |
303 | size_type find_last_not_of(const basic_string& str, size_type pos = npos) const noexcept; |
304 | template <class T> |
305 | size_type find_last_not_of(const T& t, size_type pos = npos) const noexcept; // C++17, noexcept as an extension |
306 | size_type find_last_not_of(const value_type* s, size_type pos, size_type n) const noexcept; |
307 | size_type find_last_not_of(const value_type* s, size_type pos = npos) const noexcept; |
308 | size_type find_last_not_of(value_type c, size_type pos = npos) const noexcept; |
309 | |
310 | int compare(const basic_string& str) const noexcept; |
311 | template <class T> |
312 | int compare(const T& t) const noexcept; // C++17, noexcept as an extension |
313 | int compare(size_type pos1, size_type n1, const basic_string& str) const; |
314 | template <class T> |
315 | int compare(size_type pos1, size_type n1, const T& t) const; // C++17 |
316 | int compare(size_type pos1, size_type n1, const basic_string& str, |
317 | size_type pos2, size_type n2=npos) const; // C++14 |
318 | template <class T> |
319 | int compare(size_type pos1, size_type n1, const T& t, |
320 | size_type pos2, size_type n2=npos) const; // C++17 |
321 | int compare(const value_type* s) const noexcept; |
322 | int compare(size_type pos1, size_type n1, const value_type* s) const; |
323 | int compare(size_type pos1, size_type n1, const value_type* s, size_type n2) const; |
324 | |
325 | bool starts_with(basic_string_view<charT, traits> sv) const noexcept; // C++20 |
326 | bool starts_with(charT c) const noexcept; // C++20 |
327 | bool starts_with(const charT* s) const; // C++20 |
328 | bool ends_with(basic_string_view<charT, traits> sv) const noexcept; // C++20 |
329 | bool ends_with(charT c) const noexcept; // C++20 |
330 | bool ends_with(const charT* s) const; // C++20 |
331 | |
332 | constexpr bool contains(basic_string_view<charT, traits> sv) const noexcept; // C++2b |
333 | constexpr bool contains(charT c) const noexcept; // C++2b |
334 | constexpr bool contains(const charT* s) const; // C++2b |
335 | |
336 | bool __invariants() const; |
337 | }; |
338 | |
339 | template<class InputIterator, |
340 | class Allocator = allocator<typename iterator_traits<InputIterator>::value_type>> |
341 | basic_string(InputIterator, InputIterator, Allocator = Allocator()) |
342 | -> basic_string<typename iterator_traits<InputIterator>::value_type, |
343 | char_traits<typename iterator_traits<InputIterator>::value_type>, |
344 | Allocator>; // C++17 |
345 | |
346 | template<class charT, class traits, class Allocator> |
347 | basic_string<charT, traits, Allocator> |
348 | operator+(const basic_string<charT, traits, Allocator>& lhs, |
349 | const basic_string<charT, traits, Allocator>& rhs); |
350 | |
351 | template<class charT, class traits, class Allocator> |
352 | basic_string<charT, traits, Allocator> |
353 | operator+(const charT* lhs , const basic_string<charT,traits,Allocator>&rhs); |
354 | |
355 | template<class charT, class traits, class Allocator> |
356 | basic_string<charT, traits, Allocator> |
357 | operator+(charT lhs, const basic_string<charT,traits,Allocator>& rhs); |
358 | |
359 | template<class charT, class traits, class Allocator> |
360 | basic_string<charT, traits, Allocator> |
361 | operator+(const basic_string<charT, traits, Allocator>& lhs, const charT* rhs); |
362 | |
363 | template<class charT, class traits, class Allocator> |
364 | basic_string<charT, traits, Allocator> |
365 | operator+(const basic_string<charT, traits, Allocator>& lhs, charT rhs); |
366 | |
367 | template<class charT, class traits, class Allocator> |
368 | bool operator==(const basic_string<charT, traits, Allocator>& lhs, |
369 | const basic_string<charT, traits, Allocator>& rhs) noexcept; |
370 | |
371 | template<class charT, class traits, class Allocator> |
372 | bool operator==(const charT* lhs, const basic_string<charT, traits, Allocator>& rhs) noexcept; |
373 | |
374 | template<class charT, class traits, class Allocator> |
375 | bool operator==(const basic_string<charT,traits,Allocator>& lhs, const charT* rhs) noexcept; |
376 | |
377 | template<class charT, class traits, class Allocator> |
378 | bool operator!=(const basic_string<charT,traits,Allocator>& lhs, |
379 | const basic_string<charT, traits, Allocator>& rhs) noexcept; |
380 | |
381 | template<class charT, class traits, class Allocator> |
382 | bool operator!=(const charT* lhs, const basic_string<charT, traits, Allocator>& rhs) noexcept; |
383 | |
384 | template<class charT, class traits, class Allocator> |
385 | bool operator!=(const basic_string<charT, traits, Allocator>& lhs, const charT* rhs) noexcept; |
386 | |
387 | template<class charT, class traits, class Allocator> |
388 | bool operator< (const basic_string<charT, traits, Allocator>& lhs, |
389 | const basic_string<charT, traits, Allocator>& rhs) noexcept; |
390 | |
391 | template<class charT, class traits, class Allocator> |
392 | bool operator< (const basic_string<charT, traits, Allocator>& lhs, const charT* rhs) noexcept; |
393 | |
394 | template<class charT, class traits, class Allocator> |
395 | bool operator< (const charT* lhs, const basic_string<charT, traits, Allocator>& rhs) noexcept; |
396 | |
397 | template<class charT, class traits, class Allocator> |
398 | bool operator> (const basic_string<charT, traits, Allocator>& lhs, |
399 | const basic_string<charT, traits, Allocator>& rhs) noexcept; |
400 | |
401 | template<class charT, class traits, class Allocator> |
402 | bool operator> (const basic_string<charT, traits, Allocator>& lhs, const charT* rhs) noexcept; |
403 | |
404 | template<class charT, class traits, class Allocator> |
405 | bool operator> (const charT* lhs, const basic_string<charT, traits, Allocator>& rhs) noexcept; |
406 | |
407 | template<class charT, class traits, class Allocator> |
408 | bool operator<=(const basic_string<charT, traits, Allocator>& lhs, |
409 | const basic_string<charT, traits, Allocator>& rhs) noexcept; |
410 | |
411 | template<class charT, class traits, class Allocator> |
412 | bool operator<=(const basic_string<charT, traits, Allocator>& lhs, const charT* rhs) noexcept; |
413 | |
414 | template<class charT, class traits, class Allocator> |
415 | bool operator<=(const charT* lhs, const basic_string<charT, traits, Allocator>& rhs) noexcept; |
416 | |
417 | template<class charT, class traits, class Allocator> |
418 | bool operator>=(const basic_string<charT, traits, Allocator>& lhs, |
419 | const basic_string<charT, traits, Allocator>& rhs) noexcept; |
420 | |
421 | template<class charT, class traits, class Allocator> |
422 | bool operator>=(const basic_string<charT, traits, Allocator>& lhs, const charT* rhs) noexcept; |
423 | |
424 | template<class charT, class traits, class Allocator> |
425 | bool operator>=(const charT* lhs, const basic_string<charT, traits, Allocator>& rhs) noexcept; |
426 | |
427 | template<class charT, class traits, class Allocator> |
428 | void swap(basic_string<charT, traits, Allocator>& lhs, |
429 | basic_string<charT, traits, Allocator>& rhs) |
430 | noexcept(noexcept(lhs.swap(rhs))); |
431 | |
432 | template<class charT, class traits, class Allocator> |
433 | basic_istream<charT, traits>& |
434 | operator>>(basic_istream<charT, traits>& is, basic_string<charT, traits, Allocator>& str); |
435 | |
436 | template<class charT, class traits, class Allocator> |
437 | basic_ostream<charT, traits>& |
438 | operator<<(basic_ostream<charT, traits>& os, const basic_string<charT, traits, Allocator>& str); |
439 | |
440 | template<class charT, class traits, class Allocator> |
441 | basic_istream<charT, traits>& |
442 | getline(basic_istream<charT, traits>& is, basic_string<charT, traits, Allocator>& str, |
443 | charT delim); |
444 | |
445 | template<class charT, class traits, class Allocator> |
446 | basic_istream<charT, traits>& |
447 | getline(basic_istream<charT, traits>& is, basic_string<charT, traits, Allocator>& str); |
448 | |
449 | template<class charT, class traits, class Allocator, class U> |
450 | typename basic_string<charT, traits, Allocator>::size_type |
451 | erase(basic_string<charT, traits, Allocator>& c, const U& value); // C++20 |
452 | template<class charT, class traits, class Allocator, class Predicate> |
453 | typename basic_string<charT, traits, Allocator>::size_type |
454 | erase_if(basic_string<charT, traits, Allocator>& c, Predicate pred); // C++20 |
455 | |
456 | typedef basic_string<char> string; |
457 | typedef basic_string<wchar_t> wstring; |
458 | typedef basic_string<char8_t> u8string; // C++20 |
459 | typedef basic_string<char16_t> u16string; |
460 | typedef basic_string<char32_t> u32string; |
461 | |
462 | int stoi (const string& str, size_t* idx = nullptr, int base = 10); |
463 | long stol (const string& str, size_t* idx = nullptr, int base = 10); |
464 | unsigned long stoul (const string& str, size_t* idx = nullptr, int base = 10); |
465 | long long stoll (const string& str, size_t* idx = nullptr, int base = 10); |
466 | unsigned long long stoull(const string& str, size_t* idx = nullptr, int base = 10); |
467 | |
468 | float stof (const string& str, size_t* idx = nullptr); |
469 | double stod (const string& str, size_t* idx = nullptr); |
470 | long double stold(const string& str, size_t* idx = nullptr); |
471 | |
472 | string to_string(int val); |
473 | string to_string(unsigned val); |
474 | string to_string(long val); |
475 | string to_string(unsigned long val); |
476 | string to_string(long long val); |
477 | string to_string(unsigned long long val); |
478 | string to_string(float val); |
479 | string to_string(double val); |
480 | string to_string(long double val); |
481 | |
482 | int stoi (const wstring& str, size_t* idx = nullptr, int base = 10); |
483 | long stol (const wstring& str, size_t* idx = nullptr, int base = 10); |
484 | unsigned long stoul (const wstring& str, size_t* idx = nullptr, int base = 10); |
485 | long long stoll (const wstring& str, size_t* idx = nullptr, int base = 10); |
486 | unsigned long long stoull(const wstring& str, size_t* idx = nullptr, int base = 10); |
487 | |
488 | float stof (const wstring& str, size_t* idx = nullptr); |
489 | double stod (const wstring& str, size_t* idx = nullptr); |
490 | long double stold(const wstring& str, size_t* idx = nullptr); |
491 | |
492 | wstring to_wstring(int val); |
493 | wstring to_wstring(unsigned val); |
494 | wstring to_wstring(long val); |
495 | wstring to_wstring(unsigned long val); |
496 | wstring to_wstring(long long val); |
497 | wstring to_wstring(unsigned long long val); |
498 | wstring to_wstring(float val); |
499 | wstring to_wstring(double val); |
500 | wstring to_wstring(long double val); |
501 | |
502 | template <> struct hash<string>; |
503 | template <> struct hash<u8string>; // C++20 |
504 | template <> struct hash<u16string>; |
505 | template <> struct hash<u32string>; |
506 | template <> struct hash<wstring>; |
507 | |
508 | basic_string<char> operator "" s( const char *str, size_t len ); // C++14 |
509 | basic_string<wchar_t> operator "" s( const wchar_t *str, size_t len ); // C++14 |
510 | basic_string<char8_t> operator "" s( const char8_t *str, size_t len ); // C++20 |
511 | basic_string<char16_t> operator "" s( const char16_t *str, size_t len ); // C++14 |
512 | basic_string<char32_t> operator "" s( const char32_t *str, size_t len ); // C++14 |
513 | |
514 | } // std |
515 | |
516 | */ |
517 | |
518 | #include <__config> |
519 | #include <__debug> |
520 | #include <__functional_base> |
521 | #include <__iterator/wrap_iter.h> |
522 | #include <algorithm> |
523 | #include <compare> |
524 | #include <cstdio> // EOF |
525 | #include <cstdlib> |
526 | #include <cstring> |
527 | #include <cwchar> |
528 | #include <initializer_list> |
529 | #include <iosfwd> |
530 | #include <iterator> |
531 | #include <memory> |
532 | #include <stdexcept> |
533 | #include <string_view> |
534 | #include <type_traits> |
535 | #include <utility> |
536 | #include <version> |
537 | |
538 | #ifndef _LIBCPP_HAS_NO_UNICODE_CHARS |
539 | # include <cstdint> |
540 | #endif |
541 | |
542 | #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER) |
543 | #pragma GCC system_header |
544 | #endif |
545 | |
546 | _LIBCPP_PUSH_MACROSpush_macro("min") push_macro("max") |
547 | #include <__undef_macros> |
548 | |
549 | |
550 | _LIBCPP_BEGIN_NAMESPACE_STDnamespace std { inline namespace __1 { |
551 | |
552 | // fpos |
553 | |
554 | template <class _StateT> |
555 | class _LIBCPP_TEMPLATE_VIS__attribute__ ((__type_visibility__("default"))) fpos |
556 | { |
557 | private: |
558 | _StateT __st_; |
559 | streamoff __off_; |
560 | public: |
561 | _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__ )) fpos(streamoff __off = streamoff()) : __st_(), __off_(__off) {} |
562 | |
563 | _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__ )) operator streamoff() const {return __off_;} |
564 | |
565 | _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__ )) _StateT state() const {return __st_;} |
566 | _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__ )) void state(_StateT __st) {__st_ = __st;} |
567 | |
568 | _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__ )) fpos& operator+=(streamoff __off) {__off_ += __off; return *this;} |
569 | _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__ )) fpos operator+ (streamoff __off) const {fpos __t(*this); __t += __off; return __t;} |
570 | _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__ )) fpos& operator-=(streamoff __off) {__off_ -= __off; return *this;} |
571 | _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__ )) fpos operator- (streamoff __off) const {fpos __t(*this); __t -= __off; return __t;} |
572 | }; |
573 | |
574 | template <class _StateT> |
575 | inline _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__ )) |
576 | streamoff operator-(const fpos<_StateT>& __x, const fpos<_StateT>& __y) |
577 | {return streamoff(__x) - streamoff(__y);} |
578 | |
579 | template <class _StateT> |
580 | inline _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__ )) |
581 | bool operator==(const fpos<_StateT>& __x, const fpos<_StateT>& __y) |
582 | {return streamoff(__x) == streamoff(__y);} |
583 | |
584 | template <class _StateT> |
585 | inline _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__ )) |
586 | bool operator!=(const fpos<_StateT>& __x, const fpos<_StateT>& __y) |
587 | {return streamoff(__x) != streamoff(__y);} |
588 | |
589 | // basic_string |
590 | |
591 | template<class _CharT, class _Traits, class _Allocator> |
592 | basic_string<_CharT, _Traits, _Allocator> |
593 | operator+(const basic_string<_CharT, _Traits, _Allocator>& __x, |
594 | const basic_string<_CharT, _Traits, _Allocator>& __y); |
595 | |
596 | template<class _CharT, class _Traits, class _Allocator> |
597 | basic_string<_CharT, _Traits, _Allocator> |
598 | operator+(const _CharT* __x, const basic_string<_CharT,_Traits,_Allocator>& __y); |
599 | |
600 | template<class _CharT, class _Traits, class _Allocator> |
601 | basic_string<_CharT, _Traits, _Allocator> |
602 | operator+(_CharT __x, const basic_string<_CharT,_Traits,_Allocator>& __y); |
603 | |
604 | template<class _CharT, class _Traits, class _Allocator> |
605 | inline _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__ )) |
606 | basic_string<_CharT, _Traits, _Allocator> |
607 | operator+(const basic_string<_CharT, _Traits, _Allocator>& __x, const _CharT* __y); |
608 | |
609 | template<class _CharT, class _Traits, class _Allocator> |
610 | basic_string<_CharT, _Traits, _Allocator> |
611 | operator+(const basic_string<_CharT, _Traits, _Allocator>& __x, _CharT __y); |
612 | |
613 | _LIBCPP_EXTERN_TEMPLATE(_LIBCPP_FUNC_VIS string operator+<char, char_traits<char>, allocator<char> >(char const*, string const&))extern template __attribute__ ((__visibility__("default"))) string operator+<char, char_traits<char>, allocator<char > >(char const*, string const&); |
614 | |
615 | template <bool> |
616 | class _LIBCPP_TEMPLATE_VIS__attribute__ ((__type_visibility__("default"))) __basic_string_common |
617 | { |
618 | protected: |
619 | _LIBCPP_NORETURN[[noreturn]] void __throw_length_error() const; |
620 | _LIBCPP_NORETURN[[noreturn]] void __throw_out_of_range() const; |
621 | }; |
622 | |
623 | template <bool __b> |
624 | void |
625 | __basic_string_common<__b>::__throw_length_error() const |
626 | { |
627 | _VSTDstd::__1::__throw_length_error("basic_string"); |
628 | } |
629 | |
630 | template <bool __b> |
631 | void |
632 | __basic_string_common<__b>::__throw_out_of_range() const |
633 | { |
634 | _VSTDstd::__1::__throw_out_of_range("basic_string"); |
635 | } |
636 | |
637 | _LIBCPP_EXTERN_TEMPLATE(class _LIBCPP_EXTERN_TEMPLATE_TYPE_VIS __basic_string_common<true>)extern template class __attribute__ ((__visibility__("default" ))) __basic_string_common<true>; |
638 | |
639 | template <class _Iter> |
640 | struct __string_is_trivial_iterator : public false_type {}; |
641 | |
642 | template <class _Tp> |
643 | struct __string_is_trivial_iterator<_Tp*> |
644 | : public is_arithmetic<_Tp> {}; |
645 | |
646 | template <class _Iter> |
647 | struct __string_is_trivial_iterator<__wrap_iter<_Iter> > |
648 | : public __string_is_trivial_iterator<_Iter> {}; |
649 | |
650 | template <class _CharT, class _Traits, class _Tp> |
651 | struct __can_be_converted_to_string_view : public _BoolConstant< |
652 | is_convertible<const _Tp&, basic_string_view<_CharT, _Traits> >::value && |
653 | !is_convertible<const _Tp&, const _CharT*>::value |
654 | > {}; |
655 | |
656 | #ifdef _LIBCPP_ABI_ALTERNATE_STRING_LAYOUT |
657 | |
658 | template <class _CharT, size_t = sizeof(_CharT)> |
659 | struct __padding |
660 | { |
661 | unsigned char __xx[sizeof(_CharT)-1]; |
662 | }; |
663 | |
664 | template <class _CharT> |
665 | struct __padding<_CharT, 1> |
666 | { |
667 | }; |
668 | |
669 | #endif // _LIBCPP_ABI_ALTERNATE_STRING_LAYOUT |
670 | |
671 | #ifndef _LIBCPP_HAS_NO_CHAR8_T |
672 | typedef basic_string<char8_t> u8string; |
673 | #endif |
674 | |
675 | #ifndef _LIBCPP_HAS_NO_UNICODE_CHARS |
676 | typedef basic_string<char16_t> u16string; |
677 | typedef basic_string<char32_t> u32string; |
678 | #endif // _LIBCPP_HAS_NO_UNICODE_CHARS |
679 | |
680 | template<class _CharT, class _Traits, class _Allocator> |
681 | class |
682 | _LIBCPP_TEMPLATE_VIS__attribute__ ((__type_visibility__("default"))) |
683 | #ifndef _LIBCPP_HAS_NO_CHAR8_T |
684 | _LIBCPP_PREFERRED_NAME(u8string)__attribute__((__preferred_name__(u8string))) |
685 | #endif |
686 | #ifndef _LIBCPP_HAS_NO_UNICODE_CHARS |
687 | _LIBCPP_PREFERRED_NAME(u16string)__attribute__((__preferred_name__(u16string))) |
688 | _LIBCPP_PREFERRED_NAME(u32string)__attribute__((__preferred_name__(u32string))) |
689 | #endif |
690 | basic_string |
691 | : private __basic_string_common<true> |
692 | { |
693 | public: |
694 | typedef basic_string __self; |
695 | typedef basic_string_view<_CharT, _Traits> __self_view; |
696 | typedef _Traits traits_type; |
697 | typedef _CharT value_type; |
698 | typedef _Allocator allocator_type; |
699 | typedef allocator_traits<allocator_type> __alloc_traits; |
700 | typedef typename __alloc_traits::size_type size_type; |
701 | typedef typename __alloc_traits::difference_type difference_type; |
702 | typedef value_type& reference; |
703 | typedef const value_type& const_reference; |
704 | typedef typename __alloc_traits::pointer pointer; |
705 | typedef typename __alloc_traits::const_pointer const_pointer; |
706 | |
707 | static_assert((!is_array<value_type>::value), "Character type of basic_string must not be an array"); |
708 | static_assert(( is_standard_layout<value_type>::value), "Character type of basic_string must be standard-layout"); |
709 | static_assert(( is_trivial<value_type>::value), "Character type of basic_string must be trivial"); |
710 | static_assert(( is_same<_CharT, typename traits_type::char_type>::value), |
711 | "traits_type::char_type must be the same type as CharT"); |
712 | static_assert(( is_same<typename allocator_type::value_type, value_type>::value), |
713 | "Allocator::value_type must be same type as value_type"); |
714 | |
715 | typedef __wrap_iter<pointer> iterator; |
716 | typedef __wrap_iter<const_pointer> const_iterator; |
717 | typedef _VSTDstd::__1::reverse_iterator<iterator> reverse_iterator; |
718 | typedef _VSTDstd::__1::reverse_iterator<const_iterator> const_reverse_iterator; |
719 | |
720 | private: |
721 | |
722 | #ifdef _LIBCPP_ABI_ALTERNATE_STRING_LAYOUT |
723 | |
724 | struct __long |
725 | { |
726 | pointer __data_; |
727 | size_type __size_; |
728 | size_type __cap_; |
729 | }; |
730 | |
731 | #ifdef _LIBCPP_BIG_ENDIAN |
732 | static const size_type __short_mask = 0x01; |
733 | static const size_type __long_mask = 0x1ul; |
734 | #else // _LIBCPP_BIG_ENDIAN |
735 | static const size_type __short_mask = 0x80; |
736 | static const size_type __long_mask = ~(size_type(~0) >> 1); |
737 | #endif // _LIBCPP_BIG_ENDIAN |
738 | |
739 | enum {__min_cap = (sizeof(__long) - 1)/sizeof(value_type) > 2 ? |
740 | (sizeof(__long) - 1)/sizeof(value_type) : 2}; |
741 | |
742 | struct __short |
743 | { |
744 | value_type __data_[__min_cap]; |
745 | struct |
746 | : __padding<value_type> |
747 | { |
748 | unsigned char __size_; |
749 | }; |
750 | }; |
751 | |
752 | #else |
753 | |
754 | struct __long |
755 | { |
756 | size_type __cap_; |
757 | size_type __size_; |
758 | pointer __data_; |
759 | }; |
760 | |
761 | #ifdef _LIBCPP_BIG_ENDIAN |
762 | static const size_type __short_mask = 0x80; |
763 | static const size_type __long_mask = ~(size_type(~0) >> 1); |
764 | #else // _LIBCPP_BIG_ENDIAN |
765 | static const size_type __short_mask = 0x01; |
766 | static const size_type __long_mask = 0x1ul; |
767 | #endif // _LIBCPP_BIG_ENDIAN |
768 | |
769 | enum {__min_cap = (sizeof(__long) - 1)/sizeof(value_type) > 2 ? |
770 | (sizeof(__long) - 1)/sizeof(value_type) : 2}; |
771 | |
772 | struct __short |
773 | { |
774 | union |
775 | { |
776 | unsigned char __size_; |
777 | value_type __lx; |
778 | }; |
779 | value_type __data_[__min_cap]; |
780 | }; |
781 | |
782 | #endif // _LIBCPP_ABI_ALTERNATE_STRING_LAYOUT |
783 | |
784 | union __ulx{__long __lx; __short __lxx;}; |
785 | |
786 | enum {__n_words = sizeof(__ulx) / sizeof(size_type)}; |
787 | |
788 | struct __raw |
789 | { |
790 | size_type __words[__n_words]; |
791 | }; |
792 | |
793 | struct __rep |
794 | { |
795 | union |
796 | { |
797 | __long __l; |
798 | __short __s; |
799 | __raw __r; |
800 | }; |
801 | }; |
802 | |
803 | __compressed_pair<__rep, allocator_type> __r_; |
804 | |
805 | public: |
806 | _LIBCPP_TEMPLATE_DATA_VIS__attribute__ ((__visibility__("default"))) |
807 | static const size_type npos = -1; |
808 | |
809 | _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__ )) basic_string() |
810 | _NOEXCEPT_(is_nothrow_default_constructible<allocator_type>::value)noexcept(is_nothrow_default_constructible<allocator_type> ::value); |
811 | |
812 | _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__ )) explicit basic_string(const allocator_type& __a) |
813 | #if _LIBCPP_STD_VER14 <= 14 |
814 | _NOEXCEPT_(is_nothrow_copy_constructible<allocator_type>::value)noexcept(is_nothrow_copy_constructible<allocator_type>:: value); |
815 | #else |
816 | _NOEXCEPTnoexcept; |
817 | #endif |
818 | |
819 | basic_string(const basic_string& __str); |
820 | basic_string(const basic_string& __str, const allocator_type& __a); |
821 | |
822 | #ifndef _LIBCPP_CXX03_LANG |
823 | _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__ )) |
824 | basic_string(basic_string&& __str) |
825 | #if _LIBCPP_STD_VER14 <= 14 |
826 | _NOEXCEPT_(is_nothrow_move_constructible<allocator_type>::value)noexcept(is_nothrow_move_constructible<allocator_type>:: value); |
827 | #else |
828 | _NOEXCEPTnoexcept; |
829 | #endif |
830 | |
831 | _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__ )) |
832 | basic_string(basic_string&& __str, const allocator_type& __a); |
833 | #endif // _LIBCPP_CXX03_LANG |
834 | |
835 | template <class = _EnableIf<__is_allocator<_Allocator>::value, nullptr_t> > |
836 | _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__ )) |
837 | basic_string(const _CharT* __s) : __r_(__default_init_tag(), __default_init_tag()) { |
838 | _LIBCPP_ASSERT(__s != nullptr, "basic_string(const char*) detected nullptr")((void)0); |
839 | __init(__s, traits_type::length(__s)); |
840 | # if _LIBCPP_DEBUG_LEVEL0 == 2 |
841 | __get_db()->__insert_c(this); |
842 | # endif |
843 | } |
844 | |
845 | template <class = _EnableIf<__is_allocator<_Allocator>::value, nullptr_t> > |
846 | _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__ )) |
847 | basic_string(const _CharT* __s, const _Allocator& __a); |
848 | |
849 | #if _LIBCPP_STD_VER14 > 20 |
850 | basic_string(nullptr_t) = delete; |
851 | #endif |
852 | |
853 | _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__ )) |
854 | basic_string(const _CharT* __s, size_type __n); |
855 | _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__ )) |
856 | basic_string(const _CharT* __s, size_type __n, const _Allocator& __a); |
857 | _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__ )) |
858 | basic_string(size_type __n, _CharT __c); |
859 | |
860 | template <class = _EnableIf<__is_allocator<_Allocator>::value, nullptr_t> > |
861 | _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__ )) |
862 | basic_string(size_type __n, _CharT __c, const _Allocator& __a); |
863 | |
864 | basic_string(const basic_string& __str, size_type __pos, size_type __n, |
865 | const _Allocator& __a = _Allocator()); |
866 | _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__ )) |
867 | basic_string(const basic_string& __str, size_type __pos, |
868 | const _Allocator& __a = _Allocator()); |
869 | |
870 | template<class _Tp, class = _EnableIf<__can_be_converted_to_string_view<_CharT, _Traits, _Tp>::value && !__is_same_uncvref<_Tp, basic_string>::value> > |
871 | _LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VISinline __attribute__ ((__visibility__("hidden"))) |
872 | basic_string(const _Tp& __t, size_type __pos, size_type __n, |
873 | const allocator_type& __a = allocator_type()); |
874 | |
875 | template<class _Tp, class = _EnableIf<__can_be_converted_to_string_view<_CharT, _Traits, _Tp>::value && |
876 | !__is_same_uncvref<_Tp, basic_string>::value> > |
877 | _LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VISinline __attribute__ ((__visibility__("hidden"))) |
878 | explicit basic_string(const _Tp& __t); |
879 | |
880 | template<class _Tp, class = _EnableIf<__can_be_converted_to_string_view<_CharT, _Traits, _Tp>::value && !__is_same_uncvref<_Tp, basic_string>::value> > |
881 | _LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VISinline __attribute__ ((__visibility__("hidden"))) |
882 | explicit basic_string(const _Tp& __t, const allocator_type& __a); |
883 | |
884 | template<class _InputIterator, class = _EnableIf<__is_cpp17_input_iterator<_InputIterator>::value> > |
885 | _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__ )) |
886 | basic_string(_InputIterator __first, _InputIterator __last); |
887 | template<class _InputIterator, class = _EnableIf<__is_cpp17_input_iterator<_InputIterator>::value> > |
888 | _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__ )) |
889 | basic_string(_InputIterator __first, _InputIterator __last, const allocator_type& __a); |
890 | #ifndef _LIBCPP_CXX03_LANG |
891 | _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__ )) |
892 | basic_string(initializer_list<_CharT> __il); |
893 | _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__ )) |
894 | basic_string(initializer_list<_CharT> __il, const _Allocator& __a); |
895 | #endif // _LIBCPP_CXX03_LANG |
896 | |
897 | inline ~basic_string(); |
898 | |
899 | _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__ )) |
900 | operator __self_view() const _NOEXCEPTnoexcept { return __self_view(data(), size()); } |
901 | |
902 | basic_string& operator=(const basic_string& __str); |
903 | |
904 | template <class _Tp, class = _EnableIf<__can_be_converted_to_string_view<_CharT, _Traits, _Tp>::value && !__is_same_uncvref<_Tp, basic_string>::value> > |
905 | basic_string& operator=(const _Tp& __t) |
906 | {__self_view __sv = __t; return assign(__sv);} |
907 | |
908 | #ifndef _LIBCPP_CXX03_LANG |
909 | _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__ )) |
910 | basic_string& operator=(basic_string&& __str) |
911 | _NOEXCEPT_((__noexcept_move_assign_container<_Allocator, __alloc_traits>::value))noexcept((__noexcept_move_assign_container<_Allocator, __alloc_traits >::value)); |
912 | _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__ )) |
913 | basic_string& operator=(initializer_list<value_type> __il) {return assign(__il.begin(), __il.size());} |
914 | #endif |
915 | _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__ )) basic_string& operator=(const value_type* __s) {return assign(__s);} |
916 | #if _LIBCPP_STD_VER14 > 20 |
917 | basic_string& operator=(nullptr_t) = delete; |
918 | #endif |
919 | basic_string& operator=(value_type __c); |
920 | |
921 | #if _LIBCPP_DEBUG_LEVEL0 == 2 |
922 | _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__ )) |
923 | iterator begin() _NOEXCEPTnoexcept |
924 | {return iterator(this, __get_pointer());} |
925 | _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__ )) |
926 | const_iterator begin() const _NOEXCEPTnoexcept |
927 | {return const_iterator(this, __get_pointer());} |
928 | _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__ )) |
929 | iterator end() _NOEXCEPTnoexcept |
930 | {return iterator(this, __get_pointer() + size());} |
931 | _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__ )) |
932 | const_iterator end() const _NOEXCEPTnoexcept |
933 | {return const_iterator(this, __get_pointer() + size());} |
934 | #else |
935 | _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__ )) |
936 | iterator begin() _NOEXCEPTnoexcept |
937 | {return iterator(__get_pointer());} |
938 | _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__ )) |
939 | const_iterator begin() const _NOEXCEPTnoexcept |
940 | {return const_iterator(__get_pointer());} |
941 | _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__ )) |
942 | iterator end() _NOEXCEPTnoexcept |
943 | {return iterator(__get_pointer() + size());} |
944 | _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__ )) |
945 | const_iterator end() const _NOEXCEPTnoexcept |
946 | {return const_iterator(__get_pointer() + size());} |
947 | #endif // _LIBCPP_DEBUG_LEVEL == 2 |
948 | _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__ )) |
949 | reverse_iterator rbegin() _NOEXCEPTnoexcept |
950 | {return reverse_iterator(end());} |
951 | _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__ )) |
952 | const_reverse_iterator rbegin() const _NOEXCEPTnoexcept |
953 | {return const_reverse_iterator(end());} |
954 | _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__ )) |
955 | reverse_iterator rend() _NOEXCEPTnoexcept |
956 | {return reverse_iterator(begin());} |
957 | _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__ )) |
958 | const_reverse_iterator rend() const _NOEXCEPTnoexcept |
959 | {return const_reverse_iterator(begin());} |
960 | |
961 | _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__ )) |
962 | const_iterator cbegin() const _NOEXCEPTnoexcept |
963 | {return begin();} |
964 | _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__ )) |
965 | const_iterator cend() const _NOEXCEPTnoexcept |
966 | {return end();} |
967 | _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__ )) |
968 | const_reverse_iterator crbegin() const _NOEXCEPTnoexcept |
969 | {return rbegin();} |
970 | _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__ )) |
971 | const_reverse_iterator crend() const _NOEXCEPTnoexcept |
972 | {return rend();} |
973 | |
974 | _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__ )) size_type size() const _NOEXCEPTnoexcept |
975 | {return __is_long() ? __get_long_size() : __get_short_size();} |
976 | _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__ )) size_type length() const _NOEXCEPTnoexcept {return size();} |
977 | _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__ )) size_type max_size() const _NOEXCEPTnoexcept; |
978 | _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__ )) size_type capacity() const _NOEXCEPTnoexcept |
979 | {return (__is_long() ? __get_long_cap() |
980 | : static_cast<size_type>(__min_cap)) - 1;} |
981 | |
982 | void resize(size_type __n, value_type __c); |
983 | _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__ )) void resize(size_type __n) {resize(__n, value_type());} |
984 | |
985 | void reserve(size_type __requested_capacity); |
986 | _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__ )) void __resize_default_init(size_type __n); |
987 | |
988 | _LIBCPP_DEPRECATED_IN_CXX20 _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__ )) |
989 | void reserve() _NOEXCEPTnoexcept {shrink_to_fit();} |
990 | _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__ )) |
991 | void shrink_to_fit() _NOEXCEPTnoexcept; |
992 | _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__ )) |
993 | void clear() _NOEXCEPTnoexcept; |
994 | _LIBCPP_NODISCARD_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__ )) |
995 | bool empty() const _NOEXCEPTnoexcept {return size() == 0;} |
996 | |
997 | _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__ )) const_reference operator[](size_type __pos) const _NOEXCEPTnoexcept; |
998 | _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__ )) reference operator[](size_type __pos) _NOEXCEPTnoexcept; |
999 | |
1000 | const_reference at(size_type __n) const; |
1001 | reference at(size_type __n); |
1002 | |
1003 | _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__ )) basic_string& operator+=(const basic_string& __str) {return append(__str);} |
1004 | |
1005 | template <class _Tp> |
1006 | _LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VISinline __attribute__ ((__visibility__("hidden"))) |
1007 | _EnableIf |
1008 | < |
1009 | __can_be_converted_to_string_view<_CharT, _Traits, _Tp>::value |
1010 | && !__is_same_uncvref<_Tp, basic_string >::value, |
1011 | basic_string& |
1012 | > |
1013 | operator+=(const _Tp& __t) {__self_view __sv = __t; return append(__sv);} |
1014 | _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__ )) basic_string& operator+=(const value_type* __s) {return append(__s);} |
1015 | _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__ )) basic_string& operator+=(value_type __c) {push_back(__c); return *this;} |
1016 | #ifndef _LIBCPP_CXX03_LANG |
1017 | _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__ )) basic_string& operator+=(initializer_list<value_type> __il) {return append(__il);} |
1018 | #endif // _LIBCPP_CXX03_LANG |
1019 | |
1020 | _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__ )) |
1021 | basic_string& append(const basic_string& __str); |
1022 | |
1023 | template <class _Tp> |
1024 | _LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VISinline __attribute__ ((__visibility__("hidden"))) |
1025 | _EnableIf< |
1026 | __can_be_converted_to_string_view<_CharT, _Traits, _Tp>::value |
1027 | && !__is_same_uncvref<_Tp, basic_string>::value, |
1028 | basic_string& |
1029 | > |
1030 | append(const _Tp& __t) { __self_view __sv = __t; return append(__sv.data(), __sv.size()); } |
1031 | basic_string& append(const basic_string& __str, size_type __pos, size_type __n=npos); |
1032 | |
1033 | template <class _Tp> |
1034 | _LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VISinline __attribute__ ((__visibility__("hidden"))) |
1035 | _EnableIf |
1036 | < |
1037 | __can_be_converted_to_string_view<_CharT, _Traits, _Tp>::value |
1038 | && !__is_same_uncvref<_Tp, basic_string>::value, |
1039 | basic_string& |
1040 | > |
1041 | append(const _Tp& __t, size_type __pos, size_type __n=npos); |
1042 | basic_string& append(const value_type* __s, size_type __n); |
1043 | basic_string& append(const value_type* __s); |
1044 | basic_string& append(size_type __n, value_type __c); |
1045 | |
1046 | _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__ )) |
1047 | void __append_default_init(size_type __n); |
1048 | |
1049 | template<class _InputIterator> |
1050 | _LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VISinline __attribute__ ((__visibility__("hidden"))) |
1051 | _EnableIf |
1052 | < |
1053 | __is_exactly_cpp17_input_iterator<_InputIterator>::value, |
1054 | basic_string& |
1055 | > |
1056 | _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__ )) |
1057 | append(_InputIterator __first, _InputIterator __last) { |
1058 | const basic_string __temp(__first, __last, __alloc()); |
1059 | append(__temp.data(), __temp.size()); |
1060 | return *this; |
1061 | } |
1062 | template<class _ForwardIterator> |
1063 | _LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VISinline __attribute__ ((__visibility__("hidden"))) |
1064 | _EnableIf |
1065 | < |
1066 | __is_cpp17_forward_iterator<_ForwardIterator>::value, |
1067 | basic_string& |
1068 | > |
1069 | _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__ )) |
1070 | append(_ForwardIterator __first, _ForwardIterator __last); |
1071 | |
1072 | #ifndef _LIBCPP_CXX03_LANG |
1073 | _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__ )) |
1074 | basic_string& append(initializer_list<value_type> __il) {return append(__il.begin(), __il.size());} |
1075 | #endif // _LIBCPP_CXX03_LANG |
1076 | |
1077 | void push_back(value_type __c); |
1078 | _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__ )) |
1079 | void pop_back(); |
1080 | _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__ )) reference front() _NOEXCEPTnoexcept; |
1081 | _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__ )) const_reference front() const _NOEXCEPTnoexcept; |
1082 | _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__ )) reference back() _NOEXCEPTnoexcept; |
1083 | _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__ )) const_reference back() const _NOEXCEPTnoexcept; |
1084 | |
1085 | template <class _Tp> |
1086 | _LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VISinline __attribute__ ((__visibility__("hidden"))) |
1087 | _EnableIf |
1088 | < |
1089 | __can_be_converted_to_string_view<_CharT, _Traits, _Tp>::value, |
1090 | basic_string& |
1091 | > |
1092 | assign(const _Tp & __t) { __self_view __sv = __t; return assign(__sv.data(), __sv.size()); } |
1093 | _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__ )) |
1094 | basic_string& assign(const basic_string& __str) { return *this = __str; } |
1095 | #ifndef _LIBCPP_CXX03_LANG |
1096 | _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__ )) |
1097 | basic_string& assign(basic_string&& __str) |
1098 | _NOEXCEPT_((__noexcept_move_assign_container<_Allocator, __alloc_traits>::value))noexcept((__noexcept_move_assign_container<_Allocator, __alloc_traits >::value)) |
1099 | {*this = _VSTDstd::__1::move(__str); return *this;} |
1100 | #endif |
1101 | basic_string& assign(const basic_string& __str, size_type __pos, size_type __n=npos); |
1102 | template <class _Tp> |
1103 | _LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VISinline __attribute__ ((__visibility__("hidden"))) |
1104 | _EnableIf |
1105 | < |
1106 | __can_be_converted_to_string_view<_CharT, _Traits, _Tp>::value |
1107 | && !__is_same_uncvref<_Tp, basic_string>::value, |
1108 | basic_string& |
1109 | > |
1110 | assign(const _Tp & __t, size_type __pos, size_type __n=npos); |
1111 | basic_string& assign(const value_type* __s, size_type __n); |
1112 | basic_string& assign(const value_type* __s); |
1113 | basic_string& assign(size_type __n, value_type __c); |
1114 | template<class _InputIterator> |
1115 | _LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VISinline __attribute__ ((__visibility__("hidden"))) |
1116 | _EnableIf |
1117 | < |
1118 | __is_exactly_cpp17_input_iterator<_InputIterator>::value, |
1119 | basic_string& |
1120 | > |
1121 | assign(_InputIterator __first, _InputIterator __last); |
1122 | template<class _ForwardIterator> |
1123 | _LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VISinline __attribute__ ((__visibility__("hidden"))) |
1124 | _EnableIf |
1125 | < |
1126 | __is_cpp17_forward_iterator<_ForwardIterator>::value, |
1127 | basic_string& |
1128 | > |
1129 | assign(_ForwardIterator __first, _ForwardIterator __last); |
1130 | #ifndef _LIBCPP_CXX03_LANG |
1131 | _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__ )) |
1132 | basic_string& assign(initializer_list<value_type> __il) {return assign(__il.begin(), __il.size());} |
1133 | #endif // _LIBCPP_CXX03_LANG |
1134 | |
1135 | _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__ )) |
1136 | basic_string& insert(size_type __pos1, const basic_string& __str); |
1137 | |
1138 | template <class _Tp> |
1139 | _LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VISinline __attribute__ ((__visibility__("hidden"))) |
1140 | _EnableIf |
1141 | < |
1142 | __can_be_converted_to_string_view<_CharT, _Traits, _Tp>::value, |
1143 | basic_string& |
1144 | > |
1145 | insert(size_type __pos1, const _Tp& __t) |
1146 | { __self_view __sv = __t; return insert(__pos1, __sv.data(), __sv.size()); } |
1147 | |
1148 | template <class _Tp> |
1149 | _LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VISinline __attribute__ ((__visibility__("hidden"))) |
1150 | _EnableIf |
1151 | < |
1152 | __can_be_converted_to_string_view<_CharT, _Traits, _Tp>::value && !__is_same_uncvref<_Tp, basic_string>::value, |
1153 | basic_string& |
1154 | > |
1155 | insert(size_type __pos1, const _Tp& __t, size_type __pos2, size_type __n=npos); |
1156 | basic_string& insert(size_type __pos1, const basic_string& __str, size_type __pos2, size_type __n=npos); |
1157 | basic_string& insert(size_type __pos, const value_type* __s, size_type __n); |
1158 | basic_string& insert(size_type __pos, const value_type* __s); |
1159 | basic_string& insert(size_type __pos, size_type __n, value_type __c); |
1160 | iterator insert(const_iterator __pos, value_type __c); |
1161 | _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__ )) |
1162 | iterator insert(const_iterator __pos, size_type __n, value_type __c); |
1163 | template<class _InputIterator> |
1164 | _LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VISinline __attribute__ ((__visibility__("hidden"))) |
1165 | _EnableIf |
1166 | < |
1167 | __is_exactly_cpp17_input_iterator<_InputIterator>::value, |
1168 | iterator |
1169 | > |
1170 | insert(const_iterator __pos, _InputIterator __first, _InputIterator __last); |
1171 | template<class _ForwardIterator> |
1172 | _LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VISinline __attribute__ ((__visibility__("hidden"))) |
1173 | _EnableIf |
1174 | < |
1175 | __is_cpp17_forward_iterator<_ForwardIterator>::value, |
1176 | iterator |
1177 | > |
1178 | insert(const_iterator __pos, _ForwardIterator __first, _ForwardIterator __last); |
1179 | #ifndef _LIBCPP_CXX03_LANG |
1180 | _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__ )) |
1181 | iterator insert(const_iterator __pos, initializer_list<value_type> __il) |
1182 | {return insert(__pos, __il.begin(), __il.end());} |
1183 | #endif // _LIBCPP_CXX03_LANG |
1184 | |
1185 | basic_string& erase(size_type __pos = 0, size_type __n = npos); |
1186 | _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__ )) |
1187 | iterator erase(const_iterator __pos); |
1188 | _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__ )) |
1189 | iterator erase(const_iterator __first, const_iterator __last); |
1190 | |
1191 | _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__ )) |
1192 | basic_string& replace(size_type __pos1, size_type __n1, const basic_string& __str); |
1193 | |
1194 | template <class _Tp> |
1195 | _LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VISinline __attribute__ ((__visibility__("hidden"))) |
1196 | _EnableIf |
1197 | < |
1198 | __can_be_converted_to_string_view<_CharT, _Traits, _Tp>::value, |
1199 | basic_string& |
1200 | > |
1201 | replace(size_type __pos1, size_type __n1, const _Tp& __t) { __self_view __sv = __t; return replace(__pos1, __n1, __sv.data(), __sv.size()); } |
1202 | basic_string& replace(size_type __pos1, size_type __n1, const basic_string& __str, size_type __pos2, size_type __n2=npos); |
1203 | template <class _Tp> |
1204 | _LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VISinline __attribute__ ((__visibility__("hidden"))) |
1205 | _EnableIf |
1206 | < |
1207 | __can_be_converted_to_string_view<_CharT, _Traits, _Tp>::value && !__is_same_uncvref<_Tp, basic_string>::value, |
1208 | basic_string& |
1209 | > |
1210 | replace(size_type __pos1, size_type __n1, const _Tp& __t, size_type __pos2, size_type __n2=npos); |
1211 | basic_string& replace(size_type __pos, size_type __n1, const value_type* __s, size_type __n2); |
1212 | basic_string& replace(size_type __pos, size_type __n1, const value_type* __s); |
1213 | basic_string& replace(size_type __pos, size_type __n1, size_type __n2, value_type __c); |
1214 | _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__ )) |
1215 | basic_string& replace(const_iterator __i1, const_iterator __i2, const basic_string& __str); |
1216 | |
1217 | template <class _Tp> |
1218 | _LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VISinline __attribute__ ((__visibility__("hidden"))) |
1219 | _EnableIf |
1220 | < |
1221 | __can_be_converted_to_string_view<_CharT, _Traits, _Tp>::value, |
1222 | basic_string& |
1223 | > |
1224 | replace(const_iterator __i1, const_iterator __i2, const _Tp& __t) { __self_view __sv = __t; return replace(__i1 - begin(), __i2 - __i1, __sv); } |
1225 | |
1226 | _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__ )) |
1227 | basic_string& replace(const_iterator __i1, const_iterator __i2, const value_type* __s, size_type __n); |
1228 | _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__ )) |
1229 | basic_string& replace(const_iterator __i1, const_iterator __i2, const value_type* __s); |
1230 | _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__ )) |
1231 | basic_string& replace(const_iterator __i1, const_iterator __i2, size_type __n, value_type __c); |
1232 | template<class _InputIterator> |
1233 | _LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VISinline __attribute__ ((__visibility__("hidden"))) |
1234 | _EnableIf |
1235 | < |
1236 | __is_cpp17_input_iterator<_InputIterator>::value, |
1237 | basic_string& |
1238 | > |
1239 | replace(const_iterator __i1, const_iterator __i2, _InputIterator __j1, _InputIterator __j2); |
1240 | #ifndef _LIBCPP_CXX03_LANG |
1241 | _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__ )) |
1242 | basic_string& replace(const_iterator __i1, const_iterator __i2, initializer_list<value_type> __il) |
1243 | {return replace(__i1, __i2, __il.begin(), __il.end());} |
1244 | #endif // _LIBCPP_CXX03_LANG |
1245 | |
1246 | size_type copy(value_type* __s, size_type __n, size_type __pos = 0) const; |
1247 | _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__ )) |
1248 | basic_string substr(size_type __pos = 0, size_type __n = npos) const; |
1249 | |
1250 | _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__ )) |
1251 | void swap(basic_string& __str) |
1252 | #if _LIBCPP_STD_VER14 >= 14 |
1253 | _NOEXCEPTnoexcept; |
1254 | #else |
1255 | _NOEXCEPT_(!__alloc_traits::propagate_on_container_swap::value ||noexcept(!__alloc_traits::propagate_on_container_swap::value || __is_nothrow_swappable<allocator_type>::value) |
1256 | __is_nothrow_swappable<allocator_type>::value)noexcept(!__alloc_traits::propagate_on_container_swap::value || __is_nothrow_swappable<allocator_type>::value); |
1257 | #endif |
1258 | |
1259 | _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__ )) |
1260 | const value_type* c_str() const _NOEXCEPTnoexcept {return data();} |
1261 | _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__ )) |
1262 | const value_type* data() const _NOEXCEPTnoexcept {return _VSTDstd::__1::__to_address(__get_pointer());} |
1263 | #if _LIBCPP_STD_VER14 > 14 || defined(_LIBCPP_BUILDING_LIBRARY) |
1264 | _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__ )) |
1265 | value_type* data() _NOEXCEPTnoexcept {return _VSTDstd::__1::__to_address(__get_pointer());} |
1266 | #endif |
1267 | |
1268 | _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__ )) |
1269 | allocator_type get_allocator() const _NOEXCEPTnoexcept {return __alloc();} |
1270 | |
1271 | _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__ )) |
1272 | size_type find(const basic_string& __str, size_type __pos = 0) const _NOEXCEPTnoexcept; |
1273 | |
1274 | template <class _Tp> |
1275 | _LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VISinline __attribute__ ((__visibility__("hidden"))) |
1276 | _EnableIf |
1277 | < |
1278 | __can_be_converted_to_string_view<_CharT, _Traits, _Tp>::value, |
1279 | size_type |
1280 | > |
1281 | find(const _Tp& __t, size_type __pos = 0) const _NOEXCEPTnoexcept; |
1282 | size_type find(const value_type* __s, size_type __pos, size_type __n) const _NOEXCEPTnoexcept; |
1283 | _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__ )) |
1284 | size_type find(const value_type* __s, size_type __pos = 0) const _NOEXCEPTnoexcept; |
1285 | size_type find(value_type __c, size_type __pos = 0) const _NOEXCEPTnoexcept; |
1286 | |
1287 | _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__ )) |
1288 | size_type rfind(const basic_string& __str, size_type __pos = npos) const _NOEXCEPTnoexcept; |
1289 | |
1290 | template <class _Tp> |
1291 | _LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VISinline __attribute__ ((__visibility__("hidden"))) |
1292 | _EnableIf |
1293 | < |
1294 | __can_be_converted_to_string_view<_CharT, _Traits, _Tp>::value, |
1295 | size_type |
1296 | > |
1297 | rfind(const _Tp& __t, size_type __pos = npos) const _NOEXCEPTnoexcept; |
1298 | size_type rfind(const value_type* __s, size_type __pos, size_type __n) const _NOEXCEPTnoexcept; |
1299 | _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__ )) |
1300 | size_type rfind(const value_type* __s, size_type __pos = npos) const _NOEXCEPTnoexcept; |
1301 | size_type rfind(value_type __c, size_type __pos = npos) const _NOEXCEPTnoexcept; |
1302 | |
1303 | _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__ )) |
1304 | size_type find_first_of(const basic_string& __str, size_type __pos = 0) const _NOEXCEPTnoexcept; |
1305 | |
1306 | template <class _Tp> |
1307 | _LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VISinline __attribute__ ((__visibility__("hidden"))) |
1308 | _EnableIf |
1309 | < |
1310 | __can_be_converted_to_string_view<_CharT, _Traits, _Tp>::value, |
1311 | size_type |
1312 | > |
1313 | find_first_of(const _Tp& __t, size_type __pos = 0) const _NOEXCEPTnoexcept; |
1314 | size_type find_first_of(const value_type* __s, size_type __pos, size_type __n) const _NOEXCEPTnoexcept; |
1315 | _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__ )) |
1316 | size_type find_first_of(const value_type* __s, size_type __pos = 0) const _NOEXCEPTnoexcept; |
1317 | _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__ )) |
1318 | size_type find_first_of(value_type __c, size_type __pos = 0) const _NOEXCEPTnoexcept; |
1319 | |
1320 | _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__ )) |
1321 | size_type find_last_of(const basic_string& __str, size_type __pos = npos) const _NOEXCEPTnoexcept; |
1322 | |
1323 | template <class _Tp> |
1324 | _LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VISinline __attribute__ ((__visibility__("hidden"))) |
1325 | _EnableIf |
1326 | < |
1327 | __can_be_converted_to_string_view<_CharT, _Traits, _Tp>::value, |
1328 | size_type |
1329 | > |
1330 | find_last_of(const _Tp& __t, size_type __pos = npos) const _NOEXCEPTnoexcept; |
1331 | size_type find_last_of(const value_type* __s, size_type __pos, size_type __n) const _NOEXCEPTnoexcept; |
1332 | _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__ )) |
1333 | size_type find_last_of(const value_type* __s, size_type __pos = npos) const _NOEXCEPTnoexcept; |
1334 | _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__ )) |
1335 | size_type find_last_of(value_type __c, size_type __pos = npos) const _NOEXCEPTnoexcept; |
1336 | |
1337 | _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__ )) |
1338 | size_type find_first_not_of(const basic_string& __str, size_type __pos = 0) const _NOEXCEPTnoexcept; |
1339 | |
1340 | template <class _Tp> |
1341 | _LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VISinline __attribute__ ((__visibility__("hidden"))) |
1342 | _EnableIf |
1343 | < |
1344 | __can_be_converted_to_string_view<_CharT, _Traits, _Tp>::value, |
1345 | size_type |
1346 | > |
1347 | find_first_not_of(const _Tp &__t, size_type __pos = 0) const _NOEXCEPTnoexcept; |
1348 | size_type find_first_not_of(const value_type* __s, size_type __pos, size_type __n) const _NOEXCEPTnoexcept; |
1349 | _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__ )) |
1350 | size_type find_first_not_of(const value_type* __s, size_type __pos = 0) const _NOEXCEPTnoexcept; |
1351 | _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__ )) |
1352 | size_type find_first_not_of(value_type __c, size_type __pos = 0) const _NOEXCEPTnoexcept; |
1353 | |
1354 | _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__ )) |
1355 | size_type find_last_not_of(const basic_string& __str, size_type __pos = npos) const _NOEXCEPTnoexcept; |
1356 | |
1357 | template <class _Tp> |
1358 | _LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VISinline __attribute__ ((__visibility__("hidden"))) |
1359 | _EnableIf |
1360 | < |
1361 | __can_be_converted_to_string_view<_CharT, _Traits, _Tp>::value, |
1362 | size_type |
1363 | > |
1364 | find_last_not_of(const _Tp& __t, size_type __pos = npos) const _NOEXCEPTnoexcept; |
1365 | size_type find_last_not_of(const value_type* __s, size_type __pos, size_type __n) const _NOEXCEPTnoexcept; |
1366 | _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__ )) |
1367 | size_type find_last_not_of(const value_type* __s, size_type __pos = npos) const _NOEXCEPTnoexcept; |
1368 | _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__ )) |
1369 | size_type find_last_not_of(value_type __c, size_type __pos = npos) const _NOEXCEPTnoexcept; |
1370 | |
1371 | _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__ )) |
1372 | int compare(const basic_string& __str) const _NOEXCEPTnoexcept; |
1373 | |
1374 | template <class _Tp> |
1375 | _LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VISinline __attribute__ ((__visibility__("hidden"))) |
1376 | _EnableIf |
1377 | < |
1378 | __can_be_converted_to_string_view<_CharT, _Traits, _Tp>::value, |
1379 | int |
1380 | > |
1381 | compare(const _Tp &__t) const _NOEXCEPTnoexcept; |
1382 | |
1383 | template <class _Tp> |
1384 | _LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VISinline __attribute__ ((__visibility__("hidden"))) |
1385 | _EnableIf |
1386 | < |
1387 | __can_be_converted_to_string_view<_CharT, _Traits, _Tp>::value, |
1388 | int |
1389 | > |
1390 | compare(size_type __pos1, size_type __n1, const _Tp& __t) const; |
1391 | |
1392 | _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__ )) |
1393 | int compare(size_type __pos1, size_type __n1, const basic_string& __str) const; |
1394 | int compare(size_type __pos1, size_type __n1, const basic_string& __str, size_type __pos2, size_type __n2=npos) const; |
1395 | |
1396 | template <class _Tp> |
1397 | inline _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__ )) |
1398 | _EnableIf |
1399 | < |
1400 | __can_be_converted_to_string_view<_CharT, _Traits, _Tp>::value && !__is_same_uncvref<_Tp, basic_string>::value, |
1401 | int |
1402 | > |
1403 | compare(size_type __pos1, size_type __n1, const _Tp& __t, size_type __pos2, size_type __n2=npos) const; |
1404 | int compare(const value_type* __s) const _NOEXCEPTnoexcept; |
1405 | int compare(size_type __pos1, size_type __n1, const value_type* __s) const; |
1406 | int compare(size_type __pos1, size_type __n1, const value_type* __s, size_type __n2) const; |
1407 | |
1408 | #if _LIBCPP_STD_VER14 > 17 |
1409 | _LIBCPP_CONSTEXPR_AFTER_CXX11constexpr _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__ )) |
1410 | bool starts_with(__self_view __sv) const _NOEXCEPTnoexcept |
1411 | { return __self_view(data(), size()).starts_with(__sv); } |
1412 | |
1413 | _LIBCPP_CONSTEXPR_AFTER_CXX11constexpr _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__ )) |
1414 | bool starts_with(value_type __c) const _NOEXCEPTnoexcept |
1415 | { return !empty() && _Traits::eq(front(), __c); } |
1416 | |
1417 | _LIBCPP_CONSTEXPR_AFTER_CXX11constexpr _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__ )) |
1418 | bool starts_with(const value_type* __s) const _NOEXCEPTnoexcept |
1419 | { return starts_with(__self_view(__s)); } |
1420 | |
1421 | _LIBCPP_CONSTEXPR_AFTER_CXX11constexpr _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__ )) |
1422 | bool ends_with(__self_view __sv) const _NOEXCEPTnoexcept |
1423 | { return __self_view(data(), size()).ends_with( __sv); } |
1424 | |
1425 | _LIBCPP_CONSTEXPR_AFTER_CXX11constexpr _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__ )) |
1426 | bool ends_with(value_type __c) const _NOEXCEPTnoexcept |
1427 | { return !empty() && _Traits::eq(back(), __c); } |
1428 | |
1429 | _LIBCPP_CONSTEXPR_AFTER_CXX11constexpr _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__ )) |
1430 | bool ends_with(const value_type* __s) const _NOEXCEPTnoexcept |
1431 | { return ends_with(__self_view(__s)); } |
1432 | #endif |
1433 | |
1434 | #if _LIBCPP_STD_VER14 > 20 |
1435 | constexpr _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__ )) |
1436 | bool contains(__self_view __sv) const noexcept |
1437 | { return __self_view(data(), size()).contains(__sv); } |
1438 | |
1439 | constexpr _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__ )) |
1440 | bool contains(value_type __c) const noexcept |
1441 | { return __self_view(data(), size()).contains(__c); } |
1442 | |
1443 | constexpr _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__ )) |
1444 | bool contains(const value_type* __s) const |
1445 | { return __self_view(data(), size()).contains(__s); } |
1446 | #endif |
1447 | |
1448 | _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__ )) bool __invariants() const; |
1449 | |
1450 | _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__ )) void __clear_and_shrink() _NOEXCEPTnoexcept; |
1451 | |
1452 | _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__ )) void __shrink_or_extend(size_type __target_capacity); |
1453 | |
1454 | _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__ )) |
1455 | bool __is_long() const _NOEXCEPTnoexcept |
1456 | {return bool(__r_.first().__s.__size_ & __short_mask);} |
1457 | |
1458 | #if _LIBCPP_DEBUG_LEVEL0 == 2 |
1459 | |
1460 | bool __dereferenceable(const const_iterator* __i) const; |
1461 | bool __decrementable(const const_iterator* __i) const; |
1462 | bool __addable(const const_iterator* __i, ptrdiff_t __n) const; |
1463 | bool __subscriptable(const const_iterator* __i, ptrdiff_t __n) const; |
1464 | |
1465 | #endif // _LIBCPP_DEBUG_LEVEL == 2 |
1466 | |
1467 | private: |
1468 | _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__ )) |
1469 | allocator_type& __alloc() _NOEXCEPTnoexcept |
1470 | {return __r_.second();} |
1471 | _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__ )) |
1472 | const allocator_type& __alloc() const _NOEXCEPTnoexcept |
1473 | {return __r_.second();} |
1474 | |
1475 | #ifdef _LIBCPP_ABI_ALTERNATE_STRING_LAYOUT |
1476 | |
1477 | _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__ )) |
1478 | void __set_short_size(size_type __s) _NOEXCEPTnoexcept |
1479 | # ifdef _LIBCPP_BIG_ENDIAN |
1480 | {__r_.first().__s.__size_ = (unsigned char)(__s << 1);} |
1481 | # else |
1482 | {__r_.first().__s.__size_ = (unsigned char)(__s);} |
1483 | # endif |
1484 | |
1485 | _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__ )) |
1486 | size_type __get_short_size() const _NOEXCEPTnoexcept |
1487 | # ifdef _LIBCPP_BIG_ENDIAN |
1488 | {return __r_.first().__s.__size_ >> 1;} |
1489 | # else |
1490 | {return __r_.first().__s.__size_;} |
1491 | # endif |
1492 | |
1493 | #else // _LIBCPP_ABI_ALTERNATE_STRING_LAYOUT |
1494 | |
1495 | _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__ )) |
1496 | void __set_short_size(size_type __s) _NOEXCEPTnoexcept |
1497 | # ifdef _LIBCPP_BIG_ENDIAN |
1498 | {__r_.first().__s.__size_ = (unsigned char)(__s);} |
1499 | # else |
1500 | {__r_.first().__s.__size_ = (unsigned char)(__s << 1);} |
1501 | # endif |
1502 | |
1503 | _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__ )) |
1504 | size_type __get_short_size() const _NOEXCEPTnoexcept |
1505 | # ifdef _LIBCPP_BIG_ENDIAN |
1506 | {return __r_.first().__s.__size_;} |
1507 | # else |
1508 | {return __r_.first().__s.__size_ >> 1;} |
1509 | # endif |
1510 | |
1511 | #endif // _LIBCPP_ABI_ALTERNATE_STRING_LAYOUT |
1512 | |
1513 | _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__ )) |
1514 | void __set_long_size(size_type __s) _NOEXCEPTnoexcept |
1515 | {__r_.first().__l.__size_ = __s;} |
1516 | _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__ )) |
1517 | size_type __get_long_size() const _NOEXCEPTnoexcept |
1518 | {return __r_.first().__l.__size_;} |
1519 | _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__ )) |
1520 | void __set_size(size_type __s) _NOEXCEPTnoexcept |
1521 | {if (__is_long()) __set_long_size(__s); else __set_short_size(__s);} |
1522 | |
1523 | _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__ )) |
1524 | void __set_long_cap(size_type __s) _NOEXCEPTnoexcept |
1525 | {__r_.first().__l.__cap_ = __long_mask | __s;} |
1526 | _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__ )) |
1527 | size_type __get_long_cap() const _NOEXCEPTnoexcept |
1528 | {return __r_.first().__l.__cap_ & size_type(~__long_mask);} |
1529 | |
1530 | _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__ )) |
1531 | void __set_long_pointer(pointer __p) _NOEXCEPTnoexcept |
1532 | {__r_.first().__l.__data_ = __p;} |
1533 | _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__ )) |
1534 | pointer __get_long_pointer() _NOEXCEPTnoexcept |
1535 | {return __r_.first().__l.__data_;} |
1536 | _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__ )) |
1537 | const_pointer __get_long_pointer() const _NOEXCEPTnoexcept |
1538 | {return __r_.first().__l.__data_;} |
1539 | _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__ )) |
1540 | pointer __get_short_pointer() _NOEXCEPTnoexcept |
1541 | {return pointer_traits<pointer>::pointer_to(__r_.first().__s.__data_[0]);} |
1542 | _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__ )) |
1543 | const_pointer __get_short_pointer() const _NOEXCEPTnoexcept |
1544 | {return pointer_traits<const_pointer>::pointer_to(__r_.first().__s.__data_[0]);} |
1545 | _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__ )) |
1546 | pointer __get_pointer() _NOEXCEPTnoexcept |
1547 | {return __is_long() ? __get_long_pointer() : __get_short_pointer();} |
1548 | _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__ )) |
1549 | const_pointer __get_pointer() const _NOEXCEPTnoexcept |
1550 | {return __is_long() ? __get_long_pointer() : __get_short_pointer();} |
1551 | |
1552 | _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__ )) |
1553 | void __zero() _NOEXCEPTnoexcept |
1554 | { |
1555 | size_type (&__a)[__n_words] = __r_.first().__r.__words; |
1556 | for (unsigned __i = 0; __i < __n_words; ++__i) |
1557 | __a[__i] = 0; |
1558 | } |
1559 | |
1560 | template <size_type __a> static |
1561 | _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__ )) |
1562 | size_type __align_it(size_type __s) _NOEXCEPTnoexcept |
1563 | {return (__s + (__a-1)) & ~(__a-1);} |
1564 | enum {__alignment = 16}; |
1565 | static _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__ )) |
1566 | size_type __recommend(size_type __s) _NOEXCEPTnoexcept |
1567 | { |
1568 | if (__s < __min_cap) return static_cast<size_type>(__min_cap) - 1; |
1569 | size_type __guess = __align_it<sizeof(value_type) < __alignment ? |
1570 | __alignment/sizeof(value_type) : 1 > (__s+1) - 1; |
1571 | if (__guess == __min_cap) ++__guess; |
1572 | return __guess; |
1573 | } |
1574 | |
1575 | inline |
1576 | void __init(const value_type* __s, size_type __sz, size_type __reserve); |
1577 | inline |
1578 | void __init(const value_type* __s, size_type __sz); |
1579 | inline |
1580 | void __init(size_type __n, value_type __c); |
1581 | |
1582 | // Slow path for the (inlined) copy constructor for 'long' strings. |
1583 | // Always externally instantiated and not inlined. |
1584 | // Requires that __s is zero terminated. |
1585 | // The main reason for this function to exist is because for unstable, we |
1586 | // want to allow inlining of the copy constructor. However, we don't want |
1587 | // to call the __init() functions as those are marked as inline which may |
1588 | // result in over-aggressive inlining by the compiler, where our aim is |
1589 | // to only inline the fast path code directly in the ctor. |
1590 | void __init_copy_ctor_external(const value_type* __s, size_type __sz); |
1591 | |
1592 | template <class _InputIterator> |
1593 | inline |
1594 | _EnableIf |
1595 | < |
1596 | __is_exactly_cpp17_input_iterator<_InputIterator>::value |
1597 | > |
1598 | __init(_InputIterator __first, _InputIterator __last); |
1599 | |
1600 | template <class _ForwardIterator> |
1601 | inline |
1602 | _EnableIf |
1603 | < |
1604 | __is_cpp17_forward_iterator<_ForwardIterator>::value |
1605 | > |
1606 | __init(_ForwardIterator __first, _ForwardIterator __last); |
1607 | |
1608 | void __grow_by(size_type __old_cap, size_type __delta_cap, size_type __old_sz, |
1609 | size_type __n_copy, size_type __n_del, size_type __n_add = 0); |
1610 | void __grow_by_and_replace(size_type __old_cap, size_type __delta_cap, size_type __old_sz, |
1611 | size_type __n_copy, size_type __n_del, |
1612 | size_type __n_add, const value_type* __p_new_stuff); |
1613 | |
1614 | // __assign_no_alias is invoked for assignment operations where we |
1615 | // have proof that the input does not alias the current instance. |
1616 | // For example, operator=(basic_string) performs a 'self' check. |
1617 | template <bool __is_short> |
1618 | basic_string& __assign_no_alias(const value_type* __s, size_type __n); |
1619 | |
1620 | _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__ )) |
1621 | void __erase_to_end(size_type __pos); |
1622 | |
1623 | // __erase_external_with_move is invoked for erase() invocations where |
1624 | // `n ~= npos`, likely requiring memory moves on the string data. |
1625 | void __erase_external_with_move(size_type __pos, size_type __n); |
1626 | |
1627 | _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__ )) |
1628 | void __copy_assign_alloc(const basic_string& __str) |
1629 | {__copy_assign_alloc(__str, integral_constant<bool, |
1630 | __alloc_traits::propagate_on_container_copy_assignment::value>());} |
1631 | |
1632 | _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__ )) |
1633 | void __copy_assign_alloc(const basic_string& __str, true_type) |
1634 | { |
1635 | if (__alloc() == __str.__alloc()) |
1636 | __alloc() = __str.__alloc(); |
1637 | else |
1638 | { |
1639 | if (!__str.__is_long()) |
1640 | { |
1641 | __clear_and_shrink(); |
1642 | __alloc() = __str.__alloc(); |
1643 | } |
1644 | else |
1645 | { |
1646 | allocator_type __a = __str.__alloc(); |
1647 | pointer __p = __alloc_traits::allocate(__a, __str.__get_long_cap()); |
1648 | __clear_and_shrink(); |
1649 | __alloc() = _VSTDstd::__1::move(__a); |
1650 | __set_long_pointer(__p); |
1651 | __set_long_cap(__str.__get_long_cap()); |
1652 | __set_long_size(__str.size()); |
1653 | } |
1654 | } |
1655 | } |
1656 | |
1657 | _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__ )) |
1658 | void __copy_assign_alloc(const basic_string&, false_type) _NOEXCEPTnoexcept |
1659 | {} |
1660 | |
1661 | #ifndef _LIBCPP_CXX03_LANG |
1662 | _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__ )) |
1663 | void __move_assign(basic_string& __str, false_type) |
1664 | _NOEXCEPT_(__alloc_traits::is_always_equal::value)noexcept(__alloc_traits::is_always_equal::value); |
1665 | _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__ )) |
1666 | void __move_assign(basic_string& __str, true_type) |
1667 | #if _LIBCPP_STD_VER14 > 14 |
1668 | _NOEXCEPTnoexcept; |
1669 | #else |
1670 | _NOEXCEPT_(is_nothrow_move_assignable<allocator_type>::value)noexcept(is_nothrow_move_assignable<allocator_type>::value ); |
1671 | #endif |
1672 | #endif |
1673 | |
1674 | _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__ )) |
1675 | void |
1676 | __move_assign_alloc(basic_string& __str) |
1677 | _NOEXCEPT_(noexcept(!__alloc_traits::propagate_on_container_move_assignment ::value || is_nothrow_move_assignable<allocator_type>:: value) |
1678 | !__alloc_traits::propagate_on_container_move_assignment::value ||noexcept(!__alloc_traits::propagate_on_container_move_assignment ::value || is_nothrow_move_assignable<allocator_type>:: value) |
1679 | is_nothrow_move_assignable<allocator_type>::value)noexcept(!__alloc_traits::propagate_on_container_move_assignment ::value || is_nothrow_move_assignable<allocator_type>:: value) |
1680 | {__move_assign_alloc(__str, integral_constant<bool, |
1681 | __alloc_traits::propagate_on_container_move_assignment::value>());} |
1682 | |
1683 | _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__ )) |
1684 | void __move_assign_alloc(basic_string& __c, true_type) |
1685 | _NOEXCEPT_(is_nothrow_move_assignable<allocator_type>::value)noexcept(is_nothrow_move_assignable<allocator_type>::value ) |
1686 | { |
1687 | __alloc() = _VSTDstd::__1::move(__c.__alloc()); |
1688 | } |
1689 | |
1690 | _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__ )) |
1691 | void __move_assign_alloc(basic_string&, false_type) |
1692 | _NOEXCEPTnoexcept |
1693 | {} |
1694 | |
1695 | basic_string& __assign_external(const value_type* __s); |
1696 | basic_string& __assign_external(const value_type* __s, size_type __n); |
1697 | |
1698 | // Assigns the value in __s, guaranteed to be __n < __min_cap in length. |
1699 | inline basic_string& __assign_short(const value_type* __s, size_type __n) { |
1700 | pointer __p = __is_long() |
1701 | ? (__set_long_size(__n), __get_long_pointer()) |
1702 | : (__set_short_size(__n), __get_short_pointer()); |
1703 | traits_type::move(_VSTDstd::__1::__to_address(__p), __s, __n); |
1704 | traits_type::assign(__p[__n], value_type()); |
1705 | return *this; |
1706 | } |
1707 | |
1708 | _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__ )) void __invalidate_all_iterators(); |
1709 | _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__ )) void __invalidate_iterators_past(size_type); |
1710 | |
1711 | template<class _Tp> |
1712 | _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__ )) |
1713 | bool __addr_in_range(_Tp&& __t) const { |
1714 | const volatile void *__p = _VSTDstd::__1::addressof(__t); |
1715 | return data() <= __p && __p <= data() + size(); |
1716 | } |
1717 | |
1718 | _LIBCPP_NORETURN[[noreturn]] _LIBCPP_HIDE_FROM_ABI__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__ )) |
1719 | void __throw_length_error() const { |
1720 | #ifndef _LIBCPP_NO_EXCEPTIONS |
1721 | __basic_string_common<true>::__throw_length_error(); |
1722 | #else |
1723 | _VSTDstd::__1::abort(); |
1724 | #endif |
1725 | } |
1726 | |
1727 | _LIBCPP_NORETURN[[noreturn]] _LIBCPP_HIDE_FROM_ABI__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__ )) |
1728 | void __throw_out_of_range() const { |
1729 | #ifndef _LIBCPP_NO_EXCEPTIONS |
1730 | __basic_string_common<true>::__throw_out_of_range(); |
1731 | #else |
1732 | _VSTDstd::__1::abort(); |
1733 | #endif |
1734 | } |
1735 | |
1736 | friend basic_string operator+<>(const basic_string&, const basic_string&); |
1737 | friend basic_string operator+<>(const value_type*, const basic_string&); |
1738 | friend basic_string operator+<>(value_type, const basic_string&); |
1739 | friend basic_string operator+<>(const basic_string&, const value_type*); |
1740 | friend basic_string operator+<>(const basic_string&, value_type); |
1741 | }; |
1742 | |
1743 | // These declarations must appear before any functions are implicitly used |
1744 | // so that they have the correct visibility specifier. |
1745 | #ifdef _LIBCPP_ABI_STRING_OPTIMIZED_EXTERNAL_INSTANTIATION |
1746 | _LIBCPP_STRING_UNSTABLE_EXTERN_TEMPLATE_LIST(_LIBCPP_EXTERN_TEMPLATE, char)extern template __attribute__ ((__visibility__("default"))) basic_string <char>& basic_string<char>::replace(size_type , size_type, value_type const*, size_type); extern template __attribute__ ((__visibility__("default"))) basic_string<char>::size_type basic_string<char>::rfind(value_type const*, size_type , size_type) const; extern template __attribute__ ((__visibility__ ("default"))) void basic_string<char>::__init(value_type const*, size_type, size_type); extern template __attribute__ ((__visibility__("default"))) basic_string<char>& basic_string <char>::replace(size_type, size_type, value_type const* ); extern template __attribute__ ((__visibility__("default")) ) basic_string<char>::size_type basic_string<char> ::find_last_not_of(value_type const*, size_type, size_type) const ; extern template __attribute__ ((__visibility__("default"))) basic_string<char>::~basic_string(); extern template __attribute__ ((__visibility__("default"))) basic_string<char>::size_type basic_string<char>::find_first_not_of(value_type const *, size_type, size_type) const; extern template __attribute__ ((__visibility__("default"))) basic_string<char>& basic_string <char>::insert(size_type, size_type, value_type); extern template __attribute__ ((__visibility__("default"))) basic_string <char>& basic_string<char>::operator=(value_type ); extern template __attribute__ ((__visibility__("default")) ) void basic_string<char>::__init(value_type const*, size_type ); extern template __attribute__ ((__visibility__("default")) ) void basic_string<char>::__init_copy_ctor_external(value_type const*, size_type); extern template __attribute__ ((__visibility__ ("default"))) const char& basic_string<char>::at(size_type ) const; extern template __attribute__ ((__visibility__("default" ))) basic_string<char>& basic_string<char>::insert (size_type, value_type const*, size_type); extern template __attribute__ ((__visibility__("default"))) basic_string<char>::size_type basic_string<char>::find_first_of(value_type const*, size_type , size_type) const; extern template __attribute__ ((__visibility__ ("default"))) basic_string<char>& basic_string<char >::replace(size_type, size_type, size_type, value_type); extern template __attribute__ ((__visibility__("default"))) basic_string <char>& basic_string<char>::__assign_external (value_type const*, size_type); extern template __attribute__ ((__visibility__("default"))) basic_string<char>& basic_string <char>::__assign_external(value_type const*); extern template __attribute__ ((__visibility__("default"))) void basic_string <char>::reserve(size_type); extern template __attribute__ ((__visibility__("default"))) basic_string<char>& basic_string <char>::append(value_type const*, size_type); extern template __attribute__ ((__visibility__("default"))) basic_string< char>& basic_string<char>::assign(basic_string const &, size_type, size_type); extern template __attribute__ ( (__visibility__("default"))) basic_string<char>::size_type basic_string<char>::copy(value_type*, size_type, size_type ) const; extern template __attribute__ ((__visibility__("default" ))) basic_string<char>::basic_string(basic_string const &, size_type, size_type, allocator<char> const& ); extern template __attribute__ ((__visibility__("default")) ) basic_string<char>::size_type basic_string<char> ::find(value_type, size_type) const; extern template __attribute__ ((__visibility__("default"))) void basic_string<char>:: __init(size_type, value_type); extern template __attribute__ ( (__visibility__("default"))) basic_string<char>& basic_string <char>::insert(size_type, value_type const*); extern template __attribute__ ((__visibility__("default"))) basic_string< char>::size_type basic_string<char>::find_last_of(value_type const*, size_type, size_type) const; extern template __attribute__ ((__visibility__("default"))) void basic_string<char>:: __grow_by(size_type, size_type, size_type, size_type, size_type , size_type); extern template __attribute__ ((__visibility__( "default"))) void basic_string<char>::__grow_by_and_replace (size_type, size_type, size_type, size_type, size_type, size_type , value_type const*); extern template __attribute__ ((__visibility__ ("default"))) basic_string<char>& basic_string<char >::__assign_no_alias<false>(value_type const*, size_type ); extern template __attribute__ ((__visibility__("default")) ) basic_string<char>& basic_string<char>::__assign_no_alias <true>(value_type const*, size_type); extern template __attribute__ ((__visibility__("default"))) void basic_string<char>:: push_back(value_type); extern template __attribute__ ((__visibility__ ("default"))) basic_string<char>& basic_string<char >::append(size_type, value_type); extern template __attribute__ ((__visibility__("default"))) basic_string<char>::size_type basic_string<char>::rfind(value_type, size_type) const ; extern template __attribute__ ((__visibility__("default"))) const basic_string<char>::size_type basic_string<char >::npos; extern template __attribute__ ((__visibility__("default" ))) basic_string<char>& basic_string<char>::assign (size_type, value_type); extern template __attribute__ ((__visibility__ ("default"))) void basic_string<char>::__erase_external_with_move (size_type, size_type); extern template __attribute__ ((__visibility__ ("default"))) basic_string<char>& basic_string<char >::append(basic_string const&, size_type, size_type); extern template __attribute__ ((__visibility__("default"))) int basic_string <char>::compare(value_type const*) const; extern template __attribute__ ((__visibility__("default"))) int basic_string <char>::compare(size_type, size_type, value_type const* ) const; extern template __attribute__ ((__visibility__("default" ))) char& basic_string<char>::at(size_type); extern template __attribute__ ((__visibility__("default"))) basic_string <char>::size_type basic_string<char>::find(value_type const*, size_type, size_type) const; extern template __attribute__ ((__visibility__("default"))) int basic_string<char>:: compare(size_type, size_type, basic_string const&, size_type , size_type) const; extern template __attribute__ ((__visibility__ ("default"))) int basic_string<char>::compare(size_type , size_type, value_type const*, size_type) const; extern template __attribute__ ((__visibility__("default"))) basic_string< char>& basic_string<char>::append(value_type const *); extern template __attribute__ ((__visibility__("default") )) basic_string<char>& basic_string<char>::replace (size_type, size_type, basic_string const&, size_type, size_type ); extern template __attribute__ ((__visibility__("default")) ) basic_string<char>::iterator basic_string<char> ::insert(basic_string::const_iterator, value_type); extern template __attribute__ ((__visibility__("default"))) void basic_string <char>::resize(size_type, value_type); extern template __attribute__ ((__visibility__("default"))) basic_string<char>& basic_string <char>::insert(size_type, basic_string const&, size_type , size_type); |
1747 | _LIBCPP_STRING_UNSTABLE_EXTERN_TEMPLATE_LIST(_LIBCPP_EXTERN_TEMPLATE, wchar_t)extern template __attribute__ ((__visibility__("default"))) basic_string <wchar_t>& basic_string<wchar_t>::replace(size_type , size_type, value_type const*, size_type); extern template __attribute__ ((__visibility__("default"))) basic_string<wchar_t>::size_type basic_string<wchar_t>::rfind(value_type const*, size_type , size_type) const; extern template __attribute__ ((__visibility__ ("default"))) void basic_string<wchar_t>::__init(value_type const*, size_type, size_type); extern template __attribute__ ((__visibility__("default"))) basic_string<wchar_t>& basic_string<wchar_t>::replace(size_type, size_type, value_type const*); extern template __attribute__ ((__visibility__("default" ))) basic_string<wchar_t>::size_type basic_string<wchar_t >::find_last_not_of(value_type const*, size_type, size_type ) const; extern template __attribute__ ((__visibility__("default" ))) basic_string<wchar_t>::~basic_string(); extern template __attribute__ ((__visibility__("default"))) basic_string< wchar_t>::size_type basic_string<wchar_t>::find_first_not_of (value_type const*, size_type, size_type) const; extern template __attribute__ ((__visibility__("default"))) basic_string< wchar_t>& basic_string<wchar_t>::insert(size_type , size_type, value_type); extern template __attribute__ ((__visibility__ ("default"))) basic_string<wchar_t>& basic_string< wchar_t>::operator=(value_type); extern template __attribute__ ((__visibility__("default"))) void basic_string<wchar_t> ::__init(value_type const*, size_type); extern template __attribute__ ((__visibility__("default"))) void basic_string<wchar_t> ::__init_copy_ctor_external(value_type const*, size_type); extern template __attribute__ ((__visibility__("default"))) const wchar_t & basic_string<wchar_t>::at(size_type) const; extern template __attribute__ ((__visibility__("default"))) basic_string <wchar_t>& basic_string<wchar_t>::insert(size_type , value_type const*, size_type); extern template __attribute__ ((__visibility__("default"))) basic_string<wchar_t>::size_type basic_string<wchar_t>::find_first_of(value_type const* , size_type, size_type) const; extern template __attribute__ ( (__visibility__("default"))) basic_string<wchar_t>& basic_string<wchar_t>::replace(size_type, size_type, size_type , value_type); extern template __attribute__ ((__visibility__ ("default"))) basic_string<wchar_t>& basic_string< wchar_t>::__assign_external(value_type const*, size_type); extern template __attribute__ ((__visibility__("default"))) basic_string <wchar_t>& basic_string<wchar_t>::__assign_external (value_type const*); extern template __attribute__ ((__visibility__ ("default"))) void basic_string<wchar_t>::reserve(size_type ); extern template __attribute__ ((__visibility__("default")) ) basic_string<wchar_t>& basic_string<wchar_t> ::append(value_type const*, size_type); extern template __attribute__ ((__visibility__("default"))) basic_string<wchar_t>& basic_string<wchar_t>::assign(basic_string const&, size_type, size_type); extern template __attribute__ ((__visibility__ ("default"))) basic_string<wchar_t>::size_type basic_string <wchar_t>::copy(value_type*, size_type, size_type) const ; extern template __attribute__ ((__visibility__("default"))) basic_string<wchar_t>::basic_string(basic_string const &, size_type, size_type, allocator<wchar_t> const& ); extern template __attribute__ ((__visibility__("default")) ) basic_string<wchar_t>::size_type basic_string<wchar_t >::find(value_type, size_type) const; extern template __attribute__ ((__visibility__("default"))) void basic_string<wchar_t> ::__init(size_type, value_type); extern template __attribute__ ((__visibility__("default"))) basic_string<wchar_t>& basic_string<wchar_t>::insert(size_type, value_type const *); extern template __attribute__ ((__visibility__("default") )) basic_string<wchar_t>::size_type basic_string<wchar_t >::find_last_of(value_type const*, size_type, size_type) const ; extern template __attribute__ ((__visibility__("default"))) void basic_string<wchar_t>::__grow_by(size_type, size_type , size_type, size_type, size_type, size_type); extern template __attribute__ ((__visibility__("default"))) void basic_string <wchar_t>::__grow_by_and_replace(size_type, size_type, size_type , size_type, size_type, size_type, value_type const*); extern template __attribute__ ((__visibility__("default"))) basic_string <wchar_t>& basic_string<wchar_t>::__assign_no_alias <false>(value_type const*, size_type); extern template __attribute__ ((__visibility__("default"))) basic_string<wchar_t>& basic_string<wchar_t>::__assign_no_alias<true>(value_type const*, size_type); extern template __attribute__ ((__visibility__ ("default"))) void basic_string<wchar_t>::push_back(value_type ); extern template __attribute__ ((__visibility__("default")) ) basic_string<wchar_t>& basic_string<wchar_t> ::append(size_type, value_type); extern template __attribute__ ((__visibility__("default"))) basic_string<wchar_t>::size_type basic_string<wchar_t>::rfind(value_type, size_type) const ; extern template __attribute__ ((__visibility__("default"))) const basic_string<wchar_t>::size_type basic_string< wchar_t>::npos; extern template __attribute__ ((__visibility__ ("default"))) basic_string<wchar_t>& basic_string< wchar_t>::assign(size_type, value_type); extern template __attribute__ ((__visibility__("default"))) void basic_string<wchar_t> ::__erase_external_with_move(size_type, size_type); extern template __attribute__ ((__visibility__("default"))) basic_string< wchar_t>& basic_string<wchar_t>::append(basic_string const&, size_type, size_type); extern template __attribute__ ((__visibility__("default"))) int basic_string<wchar_t> ::compare(value_type const*) const; extern template __attribute__ ((__visibility__("default"))) int basic_string<wchar_t> ::compare(size_type, size_type, value_type const*) const; extern template __attribute__ ((__visibility__("default"))) wchar_t & basic_string<wchar_t>::at(size_type); extern template __attribute__ ((__visibility__("default"))) basic_string< wchar_t>::size_type basic_string<wchar_t>::find(value_type const*, size_type, size_type) const; extern template __attribute__ ((__visibility__("default"))) int basic_string<wchar_t> ::compare(size_type, size_type, basic_string const&, size_type , size_type) const; extern template __attribute__ ((__visibility__ ("default"))) int basic_string<wchar_t>::compare(size_type , size_type, value_type const*, size_type) const; extern template __attribute__ ((__visibility__("default"))) basic_string< wchar_t>& basic_string<wchar_t>::append(value_type const*); extern template __attribute__ ((__visibility__("default" ))) basic_string<wchar_t>& basic_string<wchar_t> ::replace(size_type, size_type, basic_string const&, size_type , size_type); extern template __attribute__ ((__visibility__( "default"))) basic_string<wchar_t>::iterator basic_string <wchar_t>::insert(basic_string::const_iterator, value_type ); extern template __attribute__ ((__visibility__("default")) ) void basic_string<wchar_t>::resize(size_type, value_type ); extern template __attribute__ ((__visibility__("default")) ) basic_string<wchar_t>& basic_string<wchar_t> ::insert(size_type, basic_string const&, size_type, size_type ); |
1748 | #else |
1749 | _LIBCPP_STRING_V1_EXTERN_TEMPLATE_LIST(_LIBCPP_EXTERN_TEMPLATE, char)extern template __attribute__ ((__visibility__("default"))) basic_string <char>& basic_string<char>::replace(size_type , size_type, value_type const*, size_type); extern template __attribute__ ((__visibility__("default"))) basic_string<char>::size_type basic_string<char>::rfind(value_type const*, size_type , size_type) const; extern template __attribute__ ((__visibility__ ("default"))) void basic_string<char>::__init(value_type const*, size_type, size_type); extern template __attribute__ ((__visibility__("default"))) basic_string<char>::basic_string (basic_string const&); extern template __attribute__ ((__visibility__ ("default"))) basic_string<char>& basic_string<char >::replace(size_type, size_type, value_type const*); extern template __attribute__ ((__visibility__("default"))) basic_string <char>::basic_string(basic_string const&, allocator <char> const&); extern template __attribute__ ((__visibility__ ("default"))) basic_string<char>::size_type basic_string <char>::find_last_not_of(value_type const*, size_type, size_type ) const; extern template __attribute__ ((__visibility__("default" ))) basic_string<char>::~basic_string(); extern template __attribute__ ((__visibility__("default"))) basic_string< char>::size_type basic_string<char>::find_first_not_of (value_type const*, size_type, size_type) const; extern template __attribute__ ((__visibility__("default"))) basic_string< char>& basic_string<char>::insert(size_type, size_type , value_type); extern template __attribute__ ((__visibility__ ("default"))) basic_string<char>& basic_string<char >::operator=(value_type); extern template __attribute__ (( __visibility__("default"))) void basic_string<char>::__init (value_type const*, size_type); extern template __attribute__ ((__visibility__("default"))) const char& basic_string< char>::at(size_type) const; extern template __attribute__ ( (__visibility__("default"))) basic_string<char>& basic_string <char>::insert(size_type, value_type const*, size_type) ; extern template __attribute__ ((__visibility__("default"))) basic_string<char>::size_type basic_string<char> ::find_first_of(value_type const*, size_type, size_type) const ; extern template __attribute__ ((__visibility__("default"))) basic_string<char>& basic_string<char>::replace (size_type, size_type, size_type, value_type); extern template __attribute__ ((__visibility__("default"))) basic_string< char>& basic_string<char>::assign(value_type const *, size_type); extern template __attribute__ ((__visibility__ ("default"))) void basic_string<char>::reserve(size_type ); extern template __attribute__ ((__visibility__("default")) ) basic_string<char>& basic_string<char>::append (value_type const*, size_type); extern template __attribute__ ((__visibility__("default"))) basic_string<char>& basic_string <char>::assign(basic_string const&, size_type, size_type ); extern template __attribute__ ((__visibility__("default")) ) basic_string<char>::size_type basic_string<char> ::copy(value_type*, size_type, size_type) const; extern template __attribute__ ((__visibility__("default"))) basic_string< char>::basic_string(basic_string const&, size_type, size_type , allocator<char> const&); extern template __attribute__ ((__visibility__("default"))) basic_string<char>::size_type basic_string<char>::find(value_type, size_type) const; extern template __attribute__ ((__visibility__("default"))) void basic_string<char>::__init(size_type, value_type); extern template __attribute__ ((__visibility__("default"))) basic_string <char>& basic_string<char>::insert(size_type, value_type const*); extern template __attribute__ ((__visibility__ ("default"))) basic_string<char>::size_type basic_string <char>::find_last_of(value_type const*, size_type, size_type ) const; extern template __attribute__ ((__visibility__("default" ))) void basic_string<char>::__grow_by(size_type, size_type , size_type, size_type, size_type, size_type); extern template __attribute__ ((__visibility__("default"))) void basic_string <char>::__grow_by_and_replace(size_type, size_type, size_type , size_type, size_type, size_type, value_type const*); extern template __attribute__ ((__visibility__("default"))) void basic_string <char>::push_back(value_type); extern template __attribute__ ((__visibility__("default"))) basic_string<char>& basic_string <char>::append(size_type, value_type); extern template __attribute__ ((__visibility__("default"))) basic_string<char>::size_type basic_string<char>::rfind(value_type, size_type) const ; extern template __attribute__ ((__visibility__("default"))) const basic_string<char>::size_type basic_string<char >::npos; extern template __attribute__ ((__visibility__("default" ))) basic_string<char>& basic_string<char>::assign (size_type, value_type); extern template __attribute__ ((__visibility__ ("default"))) basic_string<char>& basic_string<char >::erase(size_type, size_type); extern template __attribute__ ((__visibility__("default"))) basic_string<char>& basic_string <char>::append(basic_string const&, size_type, size_type ); extern template __attribute__ ((__visibility__("default")) ) int basic_string<char>::compare(value_type const*) const ; extern template __attribute__ ((__visibility__("default"))) int basic_string<char>::compare(size_type, size_type, value_type const*) const; extern template __attribute__ ((__visibility__ ("default"))) char& basic_string<char>::at(size_type ); extern template __attribute__ ((__visibility__("default")) ) basic_string<char>& basic_string<char>::assign (value_type const*); extern template __attribute__ ((__visibility__ ("default"))) basic_string<char>::size_type basic_string <char>::find(value_type const*, size_type, size_type) const ; extern template __attribute__ ((__visibility__("default"))) int basic_string<char>::compare(size_type, size_type, basic_string const&, size_type, size_type) const; extern template __attribute__ ((__visibility__("default"))) int basic_string<char>:: compare(size_type, size_type, value_type const*, size_type) const ; extern template __attribute__ ((__visibility__("default"))) basic_string<char>& basic_string<char>::operator =(basic_string const&); extern template __attribute__ ((__visibility__ ("default"))) basic_string<char>& basic_string<char >::append(value_type const*); extern template __attribute__ ((__visibility__("default"))) basic_string<char>& basic_string <char>::replace(size_type, size_type, basic_string const &, size_type, size_type); extern template __attribute__ ( (__visibility__("default"))) basic_string<char>::iterator basic_string<char>::insert(basic_string::const_iterator , value_type); extern template __attribute__ ((__visibility__ ("default"))) void basic_string<char>::resize(size_type , value_type); extern template __attribute__ ((__visibility__ ("default"))) basic_string<char>& basic_string<char >::insert(size_type, basic_string const&, size_type, size_type ); |
1750 | _LIBCPP_STRING_V1_EXTERN_TEMPLATE_LIST(_LIBCPP_EXTERN_TEMPLATE, wchar_t)extern template __attribute__ ((__visibility__("default"))) basic_string <wchar_t>& basic_string<wchar_t>::replace(size_type , size_type, value_type const*, size_type); extern template __attribute__ ((__visibility__("default"))) basic_string<wchar_t>::size_type basic_string<wchar_t>::rfind(value_type const*, size_type , size_type) const; extern template __attribute__ ((__visibility__ ("default"))) void basic_string<wchar_t>::__init(value_type const*, size_type, size_type); extern template __attribute__ ((__visibility__("default"))) basic_string<wchar_t>::basic_string (basic_string const&); extern template __attribute__ ((__visibility__ ("default"))) basic_string<wchar_t>& basic_string< wchar_t>::replace(size_type, size_type, value_type const*) ; extern template __attribute__ ((__visibility__("default"))) basic_string<wchar_t>::basic_string(basic_string const &, allocator<wchar_t> const&); extern template __attribute__ ((__visibility__("default"))) basic_string<wchar_t>::size_type basic_string<wchar_t>::find_last_not_of(value_type const *, size_type, size_type) const; extern template __attribute__ ((__visibility__("default"))) basic_string<wchar_t>::~ basic_string(); extern template __attribute__ ((__visibility__ ("default"))) basic_string<wchar_t>::size_type basic_string <wchar_t>::find_first_not_of(value_type const*, size_type , size_type) const; extern template __attribute__ ((__visibility__ ("default"))) basic_string<wchar_t>& basic_string< wchar_t>::insert(size_type, size_type, value_type); extern template __attribute__ ((__visibility__("default"))) basic_string <wchar_t>& basic_string<wchar_t>::operator=(value_type ); extern template __attribute__ ((__visibility__("default")) ) void basic_string<wchar_t>::__init(value_type const*, size_type); extern template __attribute__ ((__visibility__("default" ))) const wchar_t& basic_string<wchar_t>::at(size_type ) const; extern template __attribute__ ((__visibility__("default" ))) basic_string<wchar_t>& basic_string<wchar_t> ::insert(size_type, value_type const*, size_type); extern template __attribute__ ((__visibility__("default"))) basic_string< wchar_t>::size_type basic_string<wchar_t>::find_first_of (value_type const*, size_type, size_type) const; extern template __attribute__ ((__visibility__("default"))) basic_string< wchar_t>& basic_string<wchar_t>::replace(size_type , size_type, size_type, value_type); extern template __attribute__ ((__visibility__("default"))) basic_string<wchar_t>& basic_string<wchar_t>::assign(value_type const*, size_type ); extern template __attribute__ ((__visibility__("default")) ) void basic_string<wchar_t>::reserve(size_type); extern template __attribute__ ((__visibility__("default"))) basic_string <wchar_t>& basic_string<wchar_t>::append(value_type const*, size_type); extern template __attribute__ ((__visibility__ ("default"))) basic_string<wchar_t>& basic_string< wchar_t>::assign(basic_string const&, size_type, size_type ); extern template __attribute__ ((__visibility__("default")) ) basic_string<wchar_t>::size_type basic_string<wchar_t >::copy(value_type*, size_type, size_type) const; extern template __attribute__ ((__visibility__("default"))) basic_string< wchar_t>::basic_string(basic_string const&, size_type, size_type, allocator<wchar_t> const&); extern template __attribute__ ((__visibility__("default"))) basic_string< wchar_t>::size_type basic_string<wchar_t>::find(value_type , size_type) const; extern template __attribute__ ((__visibility__ ("default"))) void basic_string<wchar_t>::__init(size_type , value_type); extern template __attribute__ ((__visibility__ ("default"))) basic_string<wchar_t>& basic_string< wchar_t>::insert(size_type, value_type const*); extern template __attribute__ ((__visibility__("default"))) basic_string< wchar_t>::size_type basic_string<wchar_t>::find_last_of (value_type const*, size_type, size_type) const; extern template __attribute__ ((__visibility__("default"))) void basic_string <wchar_t>::__grow_by(size_type, size_type, size_type, size_type , size_type, size_type); extern template __attribute__ ((__visibility__ ("default"))) void basic_string<wchar_t>::__grow_by_and_replace (size_type, size_type, size_type, size_type, size_type, size_type , value_type const*); extern template __attribute__ ((__visibility__ ("default"))) void basic_string<wchar_t>::push_back(value_type ); extern template __attribute__ ((__visibility__("default")) ) basic_string<wchar_t>& basic_string<wchar_t> ::append(size_type, value_type); extern template __attribute__ ((__visibility__("default"))) basic_string<wchar_t>::size_type basic_string<wchar_t>::rfind(value_type, size_type) const ; extern template __attribute__ ((__visibility__("default"))) const basic_string<wchar_t>::size_type basic_string< wchar_t>::npos; extern template __attribute__ ((__visibility__ ("default"))) basic_string<wchar_t>& basic_string< wchar_t>::assign(size_type, value_type); extern template __attribute__ ((__visibility__("default"))) basic_string<wchar_t>& basic_string<wchar_t>::erase(size_type, size_type); extern template __attribute__ ((__visibility__("default"))) basic_string <wchar_t>& basic_string<wchar_t>::append(basic_string const&, size_type, size_type); extern template __attribute__ ((__visibility__("default"))) int basic_string<wchar_t> ::compare(value_type const*) const; extern template __attribute__ ((__visibility__("default"))) int basic_string<wchar_t> ::compare(size_type, size_type, value_type const*) const; extern template __attribute__ ((__visibility__("default"))) wchar_t & basic_string<wchar_t>::at(size_type); extern template __attribute__ ((__visibility__("default"))) basic_string< wchar_t>& basic_string<wchar_t>::assign(value_type const*); extern template __attribute__ ((__visibility__("default" ))) basic_string<wchar_t>::size_type basic_string<wchar_t >::find(value_type const*, size_type, size_type) const; extern template __attribute__ ((__visibility__("default"))) int basic_string <wchar_t>::compare(size_type, size_type, basic_string const &, size_type, size_type) const; extern template __attribute__ ((__visibility__("default"))) int basic_string<wchar_t> ::compare(size_type, size_type, value_type const*, size_type) const; extern template __attribute__ ((__visibility__("default" ))) basic_string<wchar_t>& basic_string<wchar_t> ::operator=(basic_string const&); extern template __attribute__ ((__visibility__("default"))) basic_string<wchar_t>& basic_string<wchar_t>::append(value_type const*); extern template __attribute__ ((__visibility__("default"))) basic_string <wchar_t>& basic_string<wchar_t>::replace(size_type , size_type, basic_string const&, size_type, size_type); extern template __attribute__ ((__visibility__("default"))) basic_string <wchar_t>::iterator basic_string<wchar_t>::insert (basic_string::const_iterator, value_type); extern template __attribute__ ((__visibility__("default"))) void basic_string<wchar_t> ::resize(size_type, value_type); extern template __attribute__ ((__visibility__("default"))) basic_string<wchar_t>& basic_string<wchar_t>::insert(size_type, basic_string const &, size_type, size_type); |
1751 | #endif |
1752 | |
1753 | |
1754 | #ifndef _LIBCPP_HAS_NO_DEDUCTION_GUIDES |
1755 | template<class _InputIterator, |
1756 | class _CharT = __iter_value_type<_InputIterator>, |
1757 | class _Allocator = allocator<_CharT>, |
1758 | class = _EnableIf<__is_cpp17_input_iterator<_InputIterator>::value>, |
1759 | class = _EnableIf<__is_allocator<_Allocator>::value> |
1760 | > |
1761 | basic_string(_InputIterator, _InputIterator, _Allocator = _Allocator()) |
1762 | -> basic_string<_CharT, char_traits<_CharT>, _Allocator>; |
1763 | |
1764 | template<class _CharT, |
1765 | class _Traits, |
1766 | class _Allocator = allocator<_CharT>, |
1767 | class = _EnableIf<__is_allocator<_Allocator>::value> |
1768 | > |
1769 | explicit basic_string(basic_string_view<_CharT, _Traits>, const _Allocator& = _Allocator()) |
1770 | -> basic_string<_CharT, _Traits, _Allocator>; |
1771 | |
1772 | template<class _CharT, |
1773 | class _Traits, |
1774 | class _Allocator = allocator<_CharT>, |
1775 | class = _EnableIf<__is_allocator<_Allocator>::value>, |
1776 | class _Sz = typename allocator_traits<_Allocator>::size_type |
1777 | > |
1778 | basic_string(basic_string_view<_CharT, _Traits>, _Sz, _Sz, const _Allocator& = _Allocator()) |
1779 | -> basic_string<_CharT, _Traits, _Allocator>; |
1780 | #endif |
1781 | |
1782 | template <class _CharT, class _Traits, class _Allocator> |
1783 | inline |
1784 | void |
1785 | basic_string<_CharT, _Traits, _Allocator>::__invalidate_all_iterators() |
1786 | { |
1787 | #if _LIBCPP_DEBUG_LEVEL0 == 2 |
1788 | __get_db()->__invalidate_all(this); |
1789 | #endif |
1790 | } |
1791 | |
1792 | template <class _CharT, class _Traits, class _Allocator> |
1793 | inline |
1794 | void |
1795 | basic_string<_CharT, _Traits, _Allocator>::__invalidate_iterators_past(size_type __pos) |
1796 | { |
1797 | #if _LIBCPP_DEBUG_LEVEL0 == 2 |
1798 | __c_node* __c = __get_db()->__find_c_and_lock(this); |
1799 | if (__c) |
1800 | { |
1801 | const_pointer __new_last = __get_pointer() + __pos; |
1802 | for (__i_node** __p = __c->end_; __p != __c->beg_; ) |
1803 | { |
1804 | --__p; |
1805 | const_iterator* __i = static_cast<const_iterator*>((*__p)->__i_); |
1806 | if (__i->base() > __new_last) |
1807 | { |
1808 | (*__p)->__c_ = nullptr; |
1809 | if (--__c->end_ != __p) |
1810 | _VSTDstd::__1::memmove(__p, __p+1, (__c->end_ - __p)*sizeof(__i_node*)); |
1811 | } |
1812 | } |
1813 | __get_db()->unlock(); |
1814 | } |
1815 | #else |
1816 | (void)__pos; |
1817 | #endif // _LIBCPP_DEBUG_LEVEL == 2 |
1818 | } |
1819 | |
1820 | template <class _CharT, class _Traits, class _Allocator> |
1821 | inline |
1822 | basic_string<_CharT, _Traits, _Allocator>::basic_string() |
1823 | _NOEXCEPT_(is_nothrow_default_constructible<allocator_type>::value)noexcept(is_nothrow_default_constructible<allocator_type> ::value) |
1824 | : __r_(__default_init_tag(), __default_init_tag()) |
1825 | { |
1826 | #if _LIBCPP_DEBUG_LEVEL0 == 2 |
1827 | __get_db()->__insert_c(this); |
1828 | #endif |
1829 | __zero(); |
1830 | } |
1831 | |
1832 | template <class _CharT, class _Traits, class _Allocator> |
1833 | inline |
1834 | basic_string<_CharT, _Traits, _Allocator>::basic_string(const allocator_type& __a) |
1835 | #if _LIBCPP_STD_VER14 <= 14 |
1836 | _NOEXCEPT_(is_nothrow_copy_constructible<allocator_type>::value)noexcept(is_nothrow_copy_constructible<allocator_type>:: value) |
1837 | #else |
1838 | _NOEXCEPTnoexcept |
1839 | #endif |
1840 | : __r_(__default_init_tag(), __a) |
1841 | { |
1842 | #if _LIBCPP_DEBUG_LEVEL0 == 2 |
1843 | __get_db()->__insert_c(this); |
1844 | #endif |
1845 | __zero(); |
1846 | } |
1847 | |
1848 | template <class _CharT, class _Traits, class _Allocator> |
1849 | void basic_string<_CharT, _Traits, _Allocator>::__init(const value_type* __s, |
1850 | size_type __sz, |
1851 | size_type __reserve) |
1852 | { |
1853 | if (__reserve > max_size()) |
1854 | this->__throw_length_error(); |
1855 | pointer __p; |
1856 | if (__reserve < __min_cap) |
1857 | { |
1858 | __set_short_size(__sz); |
1859 | __p = __get_short_pointer(); |
1860 | } |
1861 | else |
1862 | { |
1863 | size_type __cap = __recommend(__reserve); |
1864 | __p = __alloc_traits::allocate(__alloc(), __cap+1); |
1865 | __set_long_pointer(__p); |
1866 | __set_long_cap(__cap+1); |
1867 | __set_long_size(__sz); |
1868 | } |
1869 | traits_type::copy(_VSTDstd::__1::__to_address(__p), __s, __sz); |
1870 | traits_type::assign(__p[__sz], value_type()); |
1871 | } |
1872 | |
1873 | template <class _CharT, class _Traits, class _Allocator> |
1874 | void |
1875 | basic_string<_CharT, _Traits, _Allocator>::__init(const value_type* __s, size_type __sz) |
1876 | { |
1877 | if (__sz > max_size()) |
1878 | this->__throw_length_error(); |
1879 | pointer __p; |
1880 | if (__sz < __min_cap) |
1881 | { |
1882 | __set_short_size(__sz); |
1883 | __p = __get_short_pointer(); |
1884 | } |
1885 | else |
1886 | { |
1887 | size_type __cap = __recommend(__sz); |
1888 | __p = __alloc_traits::allocate(__alloc(), __cap+1); |
1889 | __set_long_pointer(__p); |
1890 | __set_long_cap(__cap+1); |
1891 | __set_long_size(__sz); |
1892 | } |
1893 | traits_type::copy(_VSTDstd::__1::__to_address(__p), __s, __sz); |
1894 | traits_type::assign(__p[__sz], value_type()); |
1895 | } |
1896 | |
1897 | template <class _CharT, class _Traits, class _Allocator> |
1898 | template <class> |
1899 | basic_string<_CharT, _Traits, _Allocator>::basic_string(const _CharT* __s, const _Allocator& __a) |
1900 | : __r_(__default_init_tag(), __a) |
1901 | { |
1902 | _LIBCPP_ASSERT(__s != nullptr, "basic_string(const char*, allocator) detected nullptr")((void)0); |
1903 | __init(__s, traits_type::length(__s)); |
1904 | #if _LIBCPP_DEBUG_LEVEL0 == 2 |
1905 | __get_db()->__insert_c(this); |
1906 | #endif |
1907 | } |
1908 | |
1909 | template <class _CharT, class _Traits, class _Allocator> |
1910 | inline |
1911 | basic_string<_CharT, _Traits, _Allocator>::basic_string(const _CharT* __s, size_type __n) |
1912 | : __r_(__default_init_tag(), __default_init_tag()) |
1913 | { |
1914 | _LIBCPP_ASSERT(__n == 0 || __s != nullptr, "basic_string(const char*, n) detected nullptr")((void)0); |
1915 | __init(__s, __n); |
1916 | #if _LIBCPP_DEBUG_LEVEL0 == 2 |
1917 | __get_db()->__insert_c(this); |
1918 | #endif |
1919 | } |
1920 | |
1921 | template <class _CharT, class _Traits, class _Allocator> |
1922 | inline |
1923 | basic_string<_CharT, _Traits, _Allocator>::basic_string(const _CharT* __s, size_type __n, const _Allocator& __a) |
1924 | : __r_(__default_init_tag(), __a) |
1925 | { |
1926 | _LIBCPP_ASSERT(__n == 0 || __s != nullptr, "basic_string(const char*, n, allocator) detected nullptr")((void)0); |
1927 | __init(__s, __n); |
1928 | #if _LIBCPP_DEBUG_LEVEL0 == 2 |
1929 | __get_db()->__insert_c(this); |
1930 | #endif |
1931 | } |
1932 | |
1933 | template <class _CharT, class _Traits, class _Allocator> |
1934 | basic_string<_CharT, _Traits, _Allocator>::basic_string(const basic_string& __str) |
1935 | : __r_(__default_init_tag(), __alloc_traits::select_on_container_copy_construction(__str.__alloc())) |
1936 | { |
1937 | if (!__str.__is_long()) |
1938 | __r_.first().__r = __str.__r_.first().__r; |
1939 | else |
1940 | __init_copy_ctor_external(_VSTDstd::__1::__to_address(__str.__get_long_pointer()), |
1941 | __str.__get_long_size()); |
1942 | |
1943 | #if _LIBCPP_DEBUG_LEVEL0 == 2 |
1944 | __get_db()->__insert_c(this); |
1945 | #endif |
1946 | } |
1947 | |
1948 | template <class _CharT, class _Traits, class _Allocator> |
1949 | basic_string<_CharT, _Traits, _Allocator>::basic_string( |
1950 | const basic_string& __str, const allocator_type& __a) |
1951 | : __r_(__default_init_tag(), __a) |
1952 | { |
1953 | if (!__str.__is_long()) |
1954 | __r_.first().__r = __str.__r_.first().__r; |
1955 | else |
1956 | __init_copy_ctor_external(_VSTDstd::__1::__to_address(__str.__get_long_pointer()), |
1957 | __str.__get_long_size()); |
1958 | #if _LIBCPP_DEBUG_LEVEL0 == 2 |
1959 | __get_db()->__insert_c(this); |
1960 | #endif |
1961 | } |
1962 | |
1963 | template <class _CharT, class _Traits, class _Allocator> |
1964 | void basic_string<_CharT, _Traits, _Allocator>::__init_copy_ctor_external( |
1965 | const value_type* __s, size_type __sz) { |
1966 | pointer __p; |
1967 | if (__sz < __min_cap) { |
1968 | __p = __get_short_pointer(); |
1969 | __set_short_size(__sz); |
1970 | } else { |
1971 | if (__sz > max_size()) |
1972 | this->__throw_length_error(); |
1973 | size_t __cap = __recommend(__sz); |
1974 | __p = __alloc_traits::allocate(__alloc(), __cap + 1); |
1975 | __set_long_pointer(__p); |
1976 | __set_long_cap(__cap + 1); |
1977 | __set_long_size(__sz); |
1978 | } |
1979 | traits_type::copy(_VSTDstd::__1::__to_address(__p), __s, __sz + 1); |
1980 | } |
1981 | |
1982 | #ifndef _LIBCPP_CXX03_LANG |
1983 | |
1984 | template <class _CharT, class _Traits, class _Allocator> |
1985 | inline |
1986 | basic_string<_CharT, _Traits, _Allocator>::basic_string(basic_string&& __str) |
1987 | #if _LIBCPP_STD_VER14 <= 14 |
1988 | _NOEXCEPT_(is_nothrow_move_constructible<allocator_type>::value)noexcept(is_nothrow_move_constructible<allocator_type>:: value) |
1989 | #else |
1990 | _NOEXCEPTnoexcept |
1991 | #endif |
1992 | : __r_(_VSTDstd::__1::move(__str.__r_)) |
1993 | { |
1994 | __str.__zero(); |
1995 | #if _LIBCPP_DEBUG_LEVEL0 == 2 |
1996 | __get_db()->__insert_c(this); |
1997 | if (__is_long()) |
1998 | __get_db()->swap(this, &__str); |
1999 | #endif |
2000 | } |
2001 | |
2002 | template <class _CharT, class _Traits, class _Allocator> |
2003 | inline |
2004 | basic_string<_CharT, _Traits, _Allocator>::basic_string(basic_string&& __str, const allocator_type& __a) |
2005 | : __r_(__default_init_tag(), __a) |
2006 | { |
2007 | if (__str.__is_long() && __a != __str.__alloc()) // copy, not move |
2008 | __init(_VSTDstd::__1::__to_address(__str.__get_long_pointer()), __str.__get_long_size()); |
2009 | else |
2010 | { |
2011 | __r_.first().__r = __str.__r_.first().__r; |
2012 | __str.__zero(); |
2013 | } |
2014 | #if _LIBCPP_DEBUG_LEVEL0 == 2 |
2015 | __get_db()->__insert_c(this); |
2016 | if (__is_long()) |
2017 | __get_db()->swap(this, &__str); |
2018 | #endif |
2019 | } |
2020 | |
2021 | #endif // _LIBCPP_CXX03_LANG |
2022 | |
2023 | template <class _CharT, class _Traits, class _Allocator> |
2024 | void |
2025 | basic_string<_CharT, _Traits, _Allocator>::__init(size_type __n, value_type __c) |
2026 | { |
2027 | if (__n > max_size()) |
2028 | this->__throw_length_error(); |
2029 | pointer __p; |
2030 | if (__n < __min_cap) |
2031 | { |
2032 | __set_short_size(__n); |
2033 | __p = __get_short_pointer(); |
2034 | } |
2035 | else |
2036 | { |
2037 | size_type __cap = __recommend(__n); |
2038 | __p = __alloc_traits::allocate(__alloc(), __cap+1); |
2039 | __set_long_pointer(__p); |
2040 | __set_long_cap(__cap+1); |
2041 | __set_long_size(__n); |
2042 | } |
2043 | traits_type::assign(_VSTDstd::__1::__to_address(__p), __n, __c); |
2044 | traits_type::assign(__p[__n], value_type()); |
2045 | } |
2046 | |
2047 | template <class _CharT, class _Traits, class _Allocator> |
2048 | inline |
2049 | basic_string<_CharT, _Traits, _Allocator>::basic_string(size_type __n, _CharT __c) |
2050 | : __r_(__default_init_tag(), __default_init_tag()) |
2051 | { |
2052 | __init(__n, __c); |
2053 | #if _LIBCPP_DEBUG_LEVEL0 == 2 |
2054 | __get_db()->__insert_c(this); |
2055 | #endif |
2056 | } |
2057 | |
2058 | template <class _CharT, class _Traits, class _Allocator> |
2059 | template <class> |
2060 | basic_string<_CharT, _Traits, _Allocator>::basic_string(size_type __n, _CharT __c, const _Allocator& __a) |
2061 | : __r_(__default_init_tag(), __a) |
2062 | { |
2063 | __init(__n, __c); |
2064 | #if _LIBCPP_DEBUG_LEVEL0 == 2 |
2065 | __get_db()->__insert_c(this); |
2066 | #endif |
2067 | } |
2068 | |
2069 | template <class _CharT, class _Traits, class _Allocator> |
2070 | basic_string<_CharT, _Traits, _Allocator>::basic_string(const basic_string& __str, |
2071 | size_type __pos, size_type __n, |
2072 | const _Allocator& __a) |
2073 | : __r_(__default_init_tag(), __a) |
2074 | { |
2075 | size_type __str_sz = __str.size(); |
2076 | if (__pos > __str_sz) |
2077 | this->__throw_out_of_range(); |
2078 | __init(__str.data() + __pos, _VSTDstd::__1::min(__n, __str_sz - __pos)); |
2079 | #if _LIBCPP_DEBUG_LEVEL0 == 2 |
2080 | __get_db()->__insert_c(this); |
2081 | #endif |
2082 | } |
2083 | |
2084 | template <class _CharT, class _Traits, class _Allocator> |
2085 | inline |
2086 | basic_string<_CharT, _Traits, _Allocator>::basic_string(const basic_string& __str, size_type __pos, |
2087 | const _Allocator& __a) |
2088 | : __r_(__default_init_tag(), __a) |
2089 | { |
2090 | size_type __str_sz = __str.size(); |
2091 | if (__pos > __str_sz) |
2092 | this->__throw_out_of_range(); |
2093 | __init(__str.data() + __pos, __str_sz - __pos); |
2094 | #if _LIBCPP_DEBUG_LEVEL0 == 2 |
2095 | __get_db()->__insert_c(this); |
2096 | #endif |
2097 | } |
2098 | |
2099 | template <class _CharT, class _Traits, class _Allocator> |
2100 | template <class _Tp, class> |
2101 | basic_string<_CharT, _Traits, _Allocator>::basic_string( |
2102 | const _Tp& __t, size_type __pos, size_type __n, const allocator_type& __a) |
2103 | : __r_(__default_init_tag(), __a) |
2104 | { |
2105 | __self_view __sv0 = __t; |
2106 | __self_view __sv = __sv0.substr(__pos, __n); |
2107 | __init(__sv.data(), __sv.size()); |
2108 | #if _LIBCPP_DEBUG_LEVEL0 == 2 |
2109 | __get_db()->__insert_c(this); |
2110 | #endif |
2111 | } |
2112 | |
2113 | template <class _CharT, class _Traits, class _Allocator> |
2114 | template <class _Tp, class> |
2115 | basic_string<_CharT, _Traits, _Allocator>::basic_string(const _Tp & __t) |
2116 | : __r_(__default_init_tag(), __default_init_tag()) |
2117 | { |
2118 | __self_view __sv = __t; |
2119 | __init(__sv.data(), __sv.size()); |
2120 | #if _LIBCPP_DEBUG_LEVEL0 == 2 |
2121 | __get_db()->__insert_c(this); |
2122 | #endif |
2123 | } |
2124 | |
2125 | template <class _CharT, class _Traits, class _Allocator> |
2126 | template <class _Tp, class> |
2127 | basic_string<_CharT, _Traits, _Allocator>::basic_string(const _Tp & __t, const _Allocator& __a) |
2128 | : __r_(__default_init_tag(), __a) |
2129 | { |
2130 | __self_view __sv = __t; |
2131 | __init(__sv.data(), __sv.size()); |
2132 | #if _LIBCPP_DEBUG_LEVEL0 == 2 |
2133 | __get_db()->__insert_c(this); |
2134 | #endif |
2135 | } |
2136 | |
2137 | template <class _CharT, class _Traits, class _Allocator> |
2138 | template <class _InputIterator> |
2139 | _EnableIf |
2140 | < |
2141 | __is_exactly_cpp17_input_iterator<_InputIterator>::value |
2142 | > |
2143 | basic_string<_CharT, _Traits, _Allocator>::__init(_InputIterator __first, _InputIterator __last) |
2144 | { |
2145 | __zero(); |
2146 | #ifndef _LIBCPP_NO_EXCEPTIONS |
2147 | try |
2148 | { |
2149 | #endif // _LIBCPP_NO_EXCEPTIONS |
2150 | for (; __first != __last; ++__first) |
2151 | push_back(*__first); |
2152 | #ifndef _LIBCPP_NO_EXCEPTIONS |
2153 | } |
2154 | catch (...) |
2155 | { |
2156 | if (__is_long()) |
2157 | __alloc_traits::deallocate(__alloc(), __get_long_pointer(), __get_long_cap()); |
2158 | throw; |
2159 | } |
2160 | #endif // _LIBCPP_NO_EXCEPTIONS |
2161 | } |
2162 | |
2163 | template <class _CharT, class _Traits, class _Allocator> |
2164 | template <class _ForwardIterator> |
2165 | _EnableIf |
2166 | < |
2167 | __is_cpp17_forward_iterator<_ForwardIterator>::value |
2168 | > |
2169 | basic_string<_CharT, _Traits, _Allocator>::__init(_ForwardIterator __first, _ForwardIterator __last) |
2170 | { |
2171 | size_type __sz = static_cast<size_type>(_VSTDstd::__1::distance(__first, __last)); |
2172 | if (__sz > max_size()) |
2173 | this->__throw_length_error(); |
2174 | pointer __p; |
2175 | if (__sz < __min_cap) |
2176 | { |
2177 | __set_short_size(__sz); |
2178 | __p = __get_short_pointer(); |
2179 | } |
2180 | else |
2181 | { |
2182 | size_type __cap = __recommend(__sz); |
2183 | __p = __alloc_traits::allocate(__alloc(), __cap+1); |
2184 | __set_long_pointer(__p); |
2185 | __set_long_cap(__cap+1); |
2186 | __set_long_size(__sz); |
2187 | } |
2188 | |
2189 | #ifndef _LIBCPP_NO_EXCEPTIONS |
2190 | try |
2191 | { |
2192 | #endif // _LIBCPP_NO_EXCEPTIONS |
2193 | for (; __first != __last; ++__first, (void) ++__p) |
2194 | traits_type::assign(*__p, *__first); |
2195 | traits_type::assign(*__p, value_type()); |
2196 | #ifndef _LIBCPP_NO_EXCEPTIONS |
2197 | } |
2198 | catch (...) |
2199 | { |
2200 | if (__is_long()) |
2201 | __alloc_traits::deallocate(__alloc(), __get_long_pointer(), __get_long_cap()); |
2202 | throw; |
2203 | } |
2204 | #endif // _LIBCPP_NO_EXCEPTIONS |
2205 | } |
2206 | |
2207 | template <class _CharT, class _Traits, class _Allocator> |
2208 | template<class _InputIterator, class> |
2209 | inline |
2210 | basic_string<_CharT, _Traits, _Allocator>::basic_string(_InputIterator __first, _InputIterator __last) |
2211 | : __r_(__default_init_tag(), __default_init_tag()) |
2212 | { |
2213 | __init(__first, __last); |
2214 | #if _LIBCPP_DEBUG_LEVEL0 == 2 |
2215 | __get_db()->__insert_c(this); |
2216 | #endif |
2217 | } |
2218 | |
2219 | template <class _CharT, class _Traits, class _Allocator> |
2220 | template<class _InputIterator, class> |
2221 | inline |
2222 | basic_string<_CharT, _Traits, _Allocator>::basic_string(_InputIterator __first, _InputIterator __last, |
2223 | const allocator_type& __a) |
2224 | : __r_(__default_init_tag(), __a) |
2225 | { |
2226 | __init(__first, __last); |
2227 | #if _LIBCPP_DEBUG_LEVEL0 == 2 |
2228 | __get_db()->__insert_c(this); |
2229 | #endif |
2230 | } |
2231 | |
2232 | #ifndef _LIBCPP_CXX03_LANG |
2233 | |
2234 | template <class _CharT, class _Traits, class _Allocator> |
2235 | inline |
2236 | basic_string<_CharT, _Traits, _Allocator>::basic_string( |
2237 | initializer_list<_CharT> __il) |
2238 | : __r_(__default_init_tag(), __default_init_tag()) |
2239 | { |
2240 | __init(__il.begin(), __il.end()); |
2241 | #if _LIBCPP_DEBUG_LEVEL0 == 2 |
2242 | __get_db()->__insert_c(this); |
2243 | #endif |
2244 | } |
2245 | |
2246 | template <class _CharT, class _Traits, class _Allocator> |
2247 | inline |
2248 | |
2249 | basic_string<_CharT, _Traits, _Allocator>::basic_string( |
2250 | initializer_list<_CharT> __il, const _Allocator& __a) |
2251 | : __r_(__default_init_tag(), __a) |
2252 | { |
2253 | __init(__il.begin(), __il.end()); |
2254 | #if _LIBCPP_DEBUG_LEVEL0 == 2 |
2255 | __get_db()->__insert_c(this); |
2256 | #endif |
2257 | } |
2258 | |
2259 | #endif // _LIBCPP_CXX03_LANG |
2260 | |
2261 | template <class _CharT, class _Traits, class _Allocator> |
2262 | basic_string<_CharT, _Traits, _Allocator>::~basic_string() |
2263 | { |
2264 | #if _LIBCPP_DEBUG_LEVEL0 == 2 |
2265 | __get_db()->__erase_c(this); |
2266 | #endif |
2267 | if (__is_long()) |
2268 | __alloc_traits::deallocate(__alloc(), __get_long_pointer(), __get_long_cap()); |
2269 | } |
2270 | |
2271 | template <class _CharT, class _Traits, class _Allocator> |
2272 | void |
2273 | basic_string<_CharT, _Traits, _Allocator>::__grow_by_and_replace |
2274 | (size_type __old_cap, size_type __delta_cap, size_type __old_sz, |
2275 | size_type __n_copy, size_type __n_del, size_type __n_add, const value_type* __p_new_stuff) |
2276 | { |
2277 | size_type __ms = max_size(); |
2278 | if (__delta_cap > __ms - __old_cap - 1) |
2279 | this->__throw_length_error(); |
2280 | pointer __old_p = __get_pointer(); |
2281 | size_type __cap = __old_cap < __ms / 2 - __alignment ? |
2282 | __recommend(_VSTDstd::__1::max(__old_cap + __delta_cap, 2 * __old_cap)) : |
2283 | __ms - 1; |
2284 | pointer __p = __alloc_traits::allocate(__alloc(), __cap+1); |
2285 | __invalidate_all_iterators(); |
2286 | if (__n_copy != 0) |
2287 | traits_type::copy(_VSTDstd::__1::__to_address(__p), |
2288 | _VSTDstd::__1::__to_address(__old_p), __n_copy); |
2289 | if (__n_add != 0) |
2290 | traits_type::copy(_VSTDstd::__1::__to_address(__p) + __n_copy, __p_new_stuff, __n_add); |
2291 | size_type __sec_cp_sz = __old_sz - __n_del - __n_copy; |
2292 | if (__sec_cp_sz != 0) |
2293 | traits_type::copy(_VSTDstd::__1::__to_address(__p) + __n_copy + __n_add, |
2294 | _VSTDstd::__1::__to_address(__old_p) + __n_copy + __n_del, __sec_cp_sz); |
2295 | if (__old_cap+1 != __min_cap) |
2296 | __alloc_traits::deallocate(__alloc(), __old_p, __old_cap+1); |
2297 | __set_long_pointer(__p); |
2298 | __set_long_cap(__cap+1); |
2299 | __old_sz = __n_copy + __n_add + __sec_cp_sz; |
2300 | __set_long_size(__old_sz); |
2301 | traits_type::assign(__p[__old_sz], value_type()); |
2302 | } |
2303 | |
2304 | template <class _CharT, class _Traits, class _Allocator> |
2305 | void |
2306 | basic_string<_CharT, _Traits, _Allocator>::__grow_by(size_type __old_cap, size_type __delta_cap, size_type __old_sz, |
2307 | size_type __n_copy, size_type __n_del, size_type __n_add) |
2308 | { |
2309 | size_type __ms = max_size(); |
2310 | if (__delta_cap > __ms - __old_cap) |
2311 | this->__throw_length_error(); |
2312 | pointer __old_p = __get_pointer(); |
2313 | size_type __cap = __old_cap < __ms / 2 - __alignment ? |
2314 | __recommend(_VSTDstd::__1::max(__old_cap + __delta_cap, 2 * __old_cap)) : |
2315 | __ms - 1; |
2316 | pointer __p = __alloc_traits::allocate(__alloc(), __cap+1); |
2317 | __invalidate_all_iterators(); |
2318 | if (__n_copy != 0) |
2319 | traits_type::copy(_VSTDstd::__1::__to_address(__p), |
2320 | _VSTDstd::__1::__to_address(__old_p), __n_copy); |
2321 | size_type __sec_cp_sz = __old_sz - __n_del - __n_copy; |
2322 | if (__sec_cp_sz != 0) |
2323 | traits_type::copy(_VSTDstd::__1::__to_address(__p) + __n_copy + __n_add, |
2324 | _VSTDstd::__1::__to_address(__old_p) + __n_copy + __n_del, |
2325 | __sec_cp_sz); |
2326 | if (__old_cap+1 != __min_cap) |
2327 | __alloc_traits::deallocate(__alloc(), __old_p, __old_cap+1); |
2328 | __set_long_pointer(__p); |
2329 | __set_long_cap(__cap+1); |
2330 | } |
2331 | |
2332 | // assign |
2333 | |
2334 | template <class _CharT, class _Traits, class _Allocator> |
2335 | template <bool __is_short> |
2336 | basic_string<_CharT, _Traits, _Allocator>& |
2337 | basic_string<_CharT, _Traits, _Allocator>::__assign_no_alias( |
2338 | const value_type* __s, size_type __n) { |
2339 | size_type __cap = __is_short ? __min_cap : __get_long_cap(); |
2340 | if (__n < __cap) { |
2341 | pointer __p = __is_short ? __get_short_pointer() : __get_long_pointer(); |
2342 | __is_short ? __set_short_size(__n) : __set_long_size(__n); |
2343 | traits_type::copy(_VSTDstd::__1::__to_address(__p), __s, __n); |
2344 | traits_type::assign(__p[__n], value_type()); |
2345 | __invalidate_iterators_past(__n); |
2346 | } else { |
2347 | size_type __sz = __is_short ? __get_short_size() : __get_long_size(); |
2348 | __grow_by_and_replace(__cap - 1, __n - __cap + 1, __sz, 0, __sz, __n, __s); |
2349 | } |
2350 | return *this; |
2351 | } |
2352 | |
2353 | template <class _CharT, class _Traits, class _Allocator> |
2354 | basic_string<_CharT, _Traits, _Allocator>& |
2355 | basic_string<_CharT, _Traits, _Allocator>::__assign_external( |
2356 | const value_type* __s, size_type __n) { |
2357 | size_type __cap = capacity(); |
2358 | if (__cap >= __n) { |
2359 | value_type* __p = _VSTDstd::__1::__to_address(__get_pointer()); |
2360 | traits_type::move(__p, __s, __n); |
2361 | traits_type::assign(__p[__n], value_type()); |
2362 | __set_size(__n); |
2363 | __invalidate_iterators_past(__n); |
2364 | } else { |
2365 | size_type __sz = size(); |
2366 | __grow_by_and_replace(__cap, __n - __cap, __sz, 0, __sz, __n, __s); |
2367 | } |
2368 | return *this; |
2369 | } |
2370 | |
2371 | template <class _CharT, class _Traits, class _Allocator> |
2372 | basic_string<_CharT, _Traits, _Allocator>& |
2373 | basic_string<_CharT, _Traits, _Allocator>::assign(const value_type* __s, size_type __n) |
2374 | { |
2375 | _LIBCPP_ASSERT(__n == 0 || __s != nullptr, "string::assign received nullptr")((void)0); |
2376 | return (_LIBCPP_BUILTIN_CONSTANT_P(__n)__builtin_constant_p(__n) && __n < __min_cap) |
2377 | ? __assign_short(__s, __n) |
2378 | : __assign_external(__s, __n); |
2379 | } |
2380 | |
2381 | template <class _CharT, class _Traits, class _Allocator> |
2382 | basic_string<_CharT, _Traits, _Allocator>& |
2383 | basic_string<_CharT, _Traits, _Allocator>::assign(size_type __n, value_type __c) |
2384 | { |
2385 | size_type __cap = capacity(); |
2386 | if (__cap < __n) |
2387 | { |
2388 | size_type __sz = size(); |
2389 | __grow_by(__cap, __n - __cap, __sz, 0, __sz); |
2390 | } |
2391 | value_type* __p = _VSTDstd::__1::__to_address(__get_pointer()); |
2392 | traits_type::assign(__p, __n, __c); |
2393 | traits_type::assign(__p[__n], value_type()); |
2394 | __set_size(__n); |
2395 | __invalidate_iterators_past(__n); |
2396 | return *this; |
2397 | } |
2398 | |
2399 | template <class _CharT, class _Traits, class _Allocator> |
2400 | basic_string<_CharT, _Traits, _Allocator>& |
2401 | basic_string<_CharT, _Traits, _Allocator>::operator=(value_type __c) |
2402 | { |
2403 | pointer __p; |
2404 | if (__is_long()) |
2405 | { |
2406 | __p = __get_long_pointer(); |
2407 | __set_long_size(1); |
2408 | } |
2409 | else |
2410 | { |
2411 | __p = __get_short_pointer(); |
2412 | __set_short_size(1); |
2413 | } |
2414 | traits_type::assign(*__p, __c); |
2415 | traits_type::assign(*++__p, value_type()); |
2416 | __invalidate_iterators_past(1); |
2417 | return *this; |
2418 | } |
2419 | |
2420 | template <class _CharT, class _Traits, class _Allocator> |
2421 | basic_string<_CharT, _Traits, _Allocator>& |
2422 | basic_string<_CharT, _Traits, _Allocator>::operator=(const basic_string& __str) |
2423 | { |
2424 | if (this != &__str) { |
2425 | __copy_assign_alloc(__str); |
2426 | if (!__is_long()) { |
2427 | if (!__str.__is_long()) { |
2428 | __r_.first().__r = __str.__r_.first().__r; |
2429 | } else { |
2430 | return __assign_no_alias<true>(__str.data(), __str.size()); |
2431 | } |
2432 | } else { |
2433 | return __assign_no_alias<false>(__str.data(), __str.size()); |
2434 | } |
2435 | } |
2436 | return *this; |
2437 | } |
2438 | |
2439 | #ifndef _LIBCPP_CXX03_LANG |
2440 | |
2441 | template <class _CharT, class _Traits, class _Allocator> |
2442 | inline |
2443 | void |
2444 | basic_string<_CharT, _Traits, _Allocator>::__move_assign(basic_string& __str, false_type) |
2445 | _NOEXCEPT_(__alloc_traits::is_always_equal::value)noexcept(__alloc_traits::is_always_equal::value) |
2446 | { |
2447 | if (__alloc() != __str.__alloc()) |
2448 | assign(__str); |
2449 | else |
2450 | __move_assign(__str, true_type()); |
2451 | } |
2452 | |
2453 | template <class _CharT, class _Traits, class _Allocator> |
2454 | inline |
2455 | void |
2456 | basic_string<_CharT, _Traits, _Allocator>::__move_assign(basic_string& __str, true_type) |
2457 | #if _LIBCPP_STD_VER14 > 14 |
2458 | _NOEXCEPTnoexcept |
2459 | #else |
2460 | _NOEXCEPT_(is_nothrow_move_assignable<allocator_type>::value)noexcept(is_nothrow_move_assignable<allocator_type>::value ) |
2461 | #endif |
2462 | { |
2463 | if (__is_long()) { |
2464 | __alloc_traits::deallocate(__alloc(), __get_long_pointer(), |
2465 | __get_long_cap()); |
2466 | #if _LIBCPP_STD_VER14 <= 14 |
2467 | if (!is_nothrow_move_assignable<allocator_type>::value) { |
2468 | __set_short_size(0); |
2469 | traits_type::assign(__get_short_pointer()[0], value_type()); |
2470 | } |
2471 | #endif |
2472 | } |
2473 | __move_assign_alloc(__str); |
2474 | __r_.first() = __str.__r_.first(); |
2475 | __str.__set_short_size(0); |
2476 | traits_type::assign(__str.__get_short_pointer()[0], value_type()); |
2477 | } |
2478 | |
2479 | template <class _CharT, class _Traits, class _Allocator> |
2480 | inline |
2481 | basic_string<_CharT, _Traits, _Allocator>& |
2482 | basic_string<_CharT, _Traits, _Allocator>::operator=(basic_string&& __str) |
2483 | _NOEXCEPT_((__noexcept_move_assign_container<_Allocator, __alloc_traits>::value))noexcept((__noexcept_move_assign_container<_Allocator, __alloc_traits >::value)) |
2484 | { |
2485 | __move_assign(__str, integral_constant<bool, |
2486 | __alloc_traits::propagate_on_container_move_assignment::value>()); |
2487 | return *this; |
2488 | } |
2489 | |
2490 | #endif |
2491 | |
2492 | template <class _CharT, class _Traits, class _Allocator> |
2493 | template<class _InputIterator> |
2494 | _EnableIf |
2495 | < |
2496 | __is_exactly_cpp17_input_iterator<_InputIterator>::value, |
2497 | basic_string<_CharT, _Traits, _Allocator>& |
2498 | > |
2499 | basic_string<_CharT, _Traits, _Allocator>::assign(_InputIterator __first, _InputIterator __last) |
2500 | { |
2501 | const basic_string __temp(__first, __last, __alloc()); |
2502 | assign(__temp.data(), __temp.size()); |
2503 | return *this; |
2504 | } |
2505 | |
2506 | template <class _CharT, class _Traits, class _Allocator> |
2507 | template<class _ForwardIterator> |
2508 | _EnableIf |
2509 | < |
2510 | __is_cpp17_forward_iterator<_ForwardIterator>::value, |
2511 | basic_string<_CharT, _Traits, _Allocator>& |
2512 | > |
2513 | basic_string<_CharT, _Traits, _Allocator>::assign(_ForwardIterator __first, _ForwardIterator __last) |
2514 | { |
2515 | size_type __cap = capacity(); |
2516 | size_type __n = __string_is_trivial_iterator<_ForwardIterator>::value ? |
2517 | static_cast<size_type>(_VSTDstd::__1::distance(__first, __last)) : 0; |
2518 | |
2519 | if (__string_is_trivial_iterator<_ForwardIterator>::value && |
2520 | (__cap >= __n || !__addr_in_range(*__first))) |
2521 | { |
2522 | if (__cap < __n) |
2523 | { |
2524 | size_type __sz = size(); |
2525 | __grow_by(__cap, __n - __cap, __sz, 0, __sz); |
2526 | } |
2527 | pointer __p = __get_pointer(); |
2528 | for (; __first != __last; ++__first, ++__p) |
2529 | traits_type::assign(*__p, *__first); |
2530 | traits_type::assign(*__p, value_type()); |
2531 | __set_size(__n); |
2532 | __invalidate_iterators_past(__n); |
2533 | } |
2534 | else |
2535 | { |
2536 | const basic_string __temp(__first, __last, __alloc()); |
2537 | assign(__temp.data(), __temp.size()); |
2538 | } |
2539 | return *this; |
2540 | } |
2541 | |
2542 | template <class _CharT, class _Traits, class _Allocator> |
2543 | basic_string<_CharT, _Traits, _Allocator>& |
2544 | basic_string<_CharT, _Traits, _Allocator>::assign(const basic_string& __str, size_type __pos, size_type __n) |
2545 | { |
2546 | size_type __sz = __str.size(); |
2547 | if (__pos > __sz) |
2548 | this->__throw_out_of_range(); |
2549 | return assign(__str.data() + __pos, _VSTDstd::__1::min(__n, __sz - __pos)); |
2550 | } |
2551 | |
2552 | template <class _CharT, class _Traits, class _Allocator> |
2553 | template <class _Tp> |
2554 | _EnableIf |
2555 | < |
2556 | __can_be_converted_to_string_view<_CharT, _Traits, _Tp>::value |
2557 | && !__is_same_uncvref<_Tp, basic_string<_CharT, _Traits, _Allocator> >::value, |
2558 | basic_string<_CharT, _Traits, _Allocator>& |
2559 | > |
2560 | basic_string<_CharT, _Traits, _Allocator>::assign(const _Tp & __t, size_type __pos, size_type __n) |
2561 | { |
2562 | __self_view __sv = __t; |
2563 | size_type __sz = __sv.size(); |
2564 | if (__pos > __sz) |
2565 | this->__throw_out_of_range(); |
2566 | return assign(__sv.data() + __pos, _VSTDstd::__1::min(__n, __sz - __pos)); |
2567 | } |
2568 | |
2569 | |
2570 | template <class _CharT, class _Traits, class _Allocator> |
2571 | basic_string<_CharT, _Traits, _Allocator>& |
2572 | basic_string<_CharT, _Traits, _Allocator>::__assign_external(const value_type* __s) { |
2573 | return __assign_external(__s, traits_type::length(__s)); |
2574 | } |
2575 | |
2576 | template <class _CharT, class _Traits, class _Allocator> |
2577 | basic_string<_CharT, _Traits, _Allocator>& |
2578 | basic_string<_CharT, _Traits, _Allocator>::assign(const value_type* __s) |
2579 | { |
2580 | _LIBCPP_ASSERT(__s != nullptr, "string::assign received nullptr")((void)0); |
2581 | return _LIBCPP_BUILTIN_CONSTANT_P(*__s)__builtin_constant_p(*__s) |
2582 | ? (traits_type::length(__s) < __min_cap |
2583 | ? __assign_short(__s, traits_type::length(__s)) |
2584 | : __assign_external(__s, traits_type::length(__s))) |
2585 | : __assign_external(__s); |
2586 | } |
2587 | // append |
2588 | |
2589 | template <class _CharT, class _Traits, class _Allocator> |
2590 | basic_string<_CharT, _Traits, _Allocator>& |
2591 | basic_string<_CharT, _Traits, _Allocator>::append(const value_type* __s, size_type __n) |
2592 | { |
2593 | _LIBCPP_ASSERT(__n == 0 || __s != nullptr, "string::append received nullptr")((void)0); |
2594 | size_type __cap = capacity(); |
2595 | size_type __sz = size(); |
2596 | if (__cap - __sz >= __n) |
2597 | { |
2598 | if (__n) |
2599 | { |
2600 | value_type* __p = _VSTDstd::__1::__to_address(__get_pointer()); |
2601 | traits_type::copy(__p + __sz, __s, __n); |
2602 | __sz += __n; |
2603 | __set_size(__sz); |
2604 | traits_type::assign(__p[__sz], value_type()); |
2605 | } |
2606 | } |
2607 | else |
2608 | __grow_by_and_replace(__cap, __sz + __n - __cap, __sz, __sz, 0, __n, __s); |
2609 | return *this; |
2610 | } |
2611 | |
2612 | template <class _CharT, class _Traits, class _Allocator> |
2613 | basic_string<_CharT, _Traits, _Allocator>& |
2614 | basic_string<_CharT, _Traits, _Allocator>::append(size_type __n, value_type __c) |
2615 | { |
2616 | if (__n) |
2617 | { |
2618 | size_type __cap = capacity(); |
2619 | size_type __sz = size(); |
2620 | if (__cap - __sz < __n) |
2621 | __grow_by(__cap, __sz + __n - __cap, __sz, __sz, 0); |
2622 | pointer __p = __get_pointer(); |
2623 | traits_type::assign(_VSTDstd::__1::__to_address(__p) + __sz, __n, __c); |
2624 | __sz += __n; |
2625 | __set_size(__sz); |
2626 | traits_type::assign(__p[__sz], value_type()); |
2627 | } |
2628 | return *this; |
2629 | } |
2630 | |
2631 | template <class _CharT, class _Traits, class _Allocator> |
2632 | inline void |
2633 | basic_string<_CharT, _Traits, _Allocator>::__append_default_init(size_type __n) |
2634 | { |
2635 | if (__n) |
2636 | { |
2637 | size_type __cap = capacity(); |
2638 | size_type __sz = size(); |
2639 | if (__cap - __sz < __n) |
2640 | __grow_by(__cap, __sz + __n - __cap, __sz, __sz, 0); |
2641 | pointer __p = __get_pointer(); |
2642 | __sz += __n; |
2643 | __set_size(__sz); |
2644 | traits_type::assign(__p[__sz], value_type()); |
2645 | } |
2646 | } |
2647 | |
2648 | template <class _CharT, class _Traits, class _Allocator> |
2649 | void |
2650 | basic_string<_CharT, _Traits, _Allocator>::push_back(value_type __c) |
2651 | { |
2652 | bool __is_short = !__is_long(); |
2653 | size_type __cap; |
2654 | size_type __sz; |
2655 | if (__is_short) |
2656 | { |
2657 | __cap = __min_cap - 1; |
2658 | __sz = __get_short_size(); |
2659 | } |
2660 | else |
2661 | { |
2662 | __cap = __get_long_cap() - 1; |
2663 | __sz = __get_long_size(); |
2664 | } |
2665 | if (__sz == __cap) |
2666 | { |
2667 | __grow_by(__cap, 1, __sz, __sz, 0); |
2668 | __is_short = !__is_long(); |
2669 | } |
2670 | pointer __p; |
2671 | if (__is_short) |
2672 | { |
2673 | __p = __get_short_pointer() + __sz; |
2674 | __set_short_size(__sz+1); |
2675 | } |
2676 | else |
2677 | { |
2678 | __p = __get_long_pointer() + __sz; |
2679 | __set_long_size(__sz+1); |
2680 | } |
2681 | traits_type::assign(*__p, __c); |
2682 | traits_type::assign(*++__p, value_type()); |
2683 | } |
2684 | |
2685 | template <class _CharT, class _Traits, class _Allocator> |
2686 | template<class _ForwardIterator> |
2687 | _EnableIf |
2688 | < |
2689 | __is_cpp17_forward_iterator<_ForwardIterator>::value, |
2690 | basic_string<_CharT, _Traits, _Allocator>& |
2691 | > |
2692 | basic_string<_CharT, _Traits, _Allocator>::append( |
2693 | _ForwardIterator __first, _ForwardIterator __last) |
2694 | { |
2695 | size_type __sz = size(); |
2696 | size_type __cap = capacity(); |
2697 | size_type __n = static_cast<size_type>(_VSTDstd::__1::distance(__first, __last)); |
2698 | if (__n) |
2699 | { |
2700 | if (__string_is_trivial_iterator<_ForwardIterator>::value && |
2701 | !__addr_in_range(*__first)) |
2702 | { |
2703 | if (__cap - __sz < __n) |
2704 | __grow_by(__cap, __sz + __n - __cap, __sz, __sz, 0); |
2705 | pointer __p = __get_pointer() + __sz; |
2706 | for (; __first != __last; ++__p, ++__first) |
2707 | traits_type::assign(*__p, *__first); |
2708 | traits_type::assign(*__p, value_type()); |
2709 | __set_size(__sz + __n); |
2710 | } |
2711 | else |
2712 | { |
2713 | const basic_string __temp(__first, __last, __alloc()); |
2714 | append(__temp.data(), __temp.size()); |
2715 | } |
2716 | } |
2717 | return *this; |
2718 | } |
2719 | |
2720 | template <class _CharT, class _Traits, class _Allocator> |
2721 | inline |
2722 | basic_string<_CharT, _Traits, _Allocator>& |
2723 | basic_string<_CharT, _Traits, _Allocator>::append(const basic_string& __str) |
2724 | { |
2725 | return append(__str.data(), __str.size()); |
2726 | } |
2727 | |
2728 | template <class _CharT, class _Traits, class _Allocator> |
2729 | basic_string<_CharT, _Traits, _Allocator>& |
2730 | basic_string<_CharT, _Traits, _Allocator>::append(const basic_string& __str, size_type __pos, size_type __n) |
2731 | { |
2732 | size_type __sz = __str.size(); |
2733 | if (__pos > __sz) |
2734 | this->__throw_out_of_range(); |
2735 | return append(__str.data() + __pos, _VSTDstd::__1::min(__n, __sz - __pos)); |
2736 | } |
2737 | |
2738 | template <class _CharT, class _Traits, class _Allocator> |
2739 | template <class _Tp> |
2740 | _EnableIf |
2741 | < |
2742 | __can_be_converted_to_string_view<_CharT, _Traits, _Tp>::value && !__is_same_uncvref<_Tp, basic_string<_CharT, _Traits, _Allocator> >::value, |
2743 | basic_string<_CharT, _Traits, _Allocator>& |
2744 | > |
2745 | basic_string<_CharT, _Traits, _Allocator>::append(const _Tp & __t, size_type __pos, size_type __n) |
2746 | { |
2747 | __self_view __sv = __t; |
2748 | size_type __sz = __sv.size(); |
2749 | if (__pos > __sz) |
2750 | this->__throw_out_of_range(); |
2751 | return append(__sv.data() + __pos, _VSTDstd::__1::min(__n, __sz - __pos)); |
2752 | } |
2753 | |
2754 | template <class _CharT, class _Traits, class _Allocator> |
2755 | basic_string<_CharT, _Traits, _Allocator>& |
2756 | basic_string<_CharT, _Traits, _Allocator>::append(const value_type* __s) |
2757 | { |
2758 | _LIBCPP_ASSERT(__s != nullptr, "string::append received nullptr")((void)0); |
2759 | return append(__s, traits_type::length(__s)); |
2760 | } |
2761 | |
2762 | // insert |
2763 | |
2764 | template <class _CharT, class _Traits, class _Allocator> |
2765 | basic_string<_CharT, _Traits, _Allocator>& |
2766 | basic_string<_CharT, _Traits, _Allocator>::insert(size_type __pos, const value_type* __s, size_type __n) |
2767 | { |
2768 | _LIBCPP_ASSERT(__n == 0 || __s != nullptr, "string::insert received nullptr")((void)0); |
2769 | size_type __sz = size(); |
2770 | if (__pos > __sz) |
2771 | this->__throw_out_of_range(); |
2772 | size_type __cap = capacity(); |
2773 | if (__cap - __sz >= __n) |
2774 | { |
2775 | if (__n) |
2776 | { |
2777 | value_type* __p = _VSTDstd::__1::__to_address(__get_pointer()); |
2778 | size_type __n_move = __sz - __pos; |
2779 | if (__n_move != 0) |
2780 | { |
2781 | if (__p + __pos <= __s && __s < __p + __sz) |
2782 | __s += __n; |
2783 | traits_type::move(__p + __pos + __n, __p + __pos, __n_move); |
2784 | } |
2785 | traits_type::move(__p + __pos, __s, __n); |
2786 | __sz += __n; |
2787 | __set_size(__sz); |
2788 | traits_type::assign(__p[__sz], value_type()); |
2789 | } |
2790 | } |
2791 | else |
2792 | __grow_by_and_replace(__cap, __sz + __n - __cap, __sz, __pos, 0, __n, __s); |
2793 | return *this; |
2794 | } |
2795 | |
2796 | template <class _CharT, class _Traits, class _Allocator> |
2797 | basic_string<_CharT, _Traits, _Allocator>& |
2798 | basic_string<_CharT, _Traits, _Allocator>::insert(size_type __pos, size_type __n, value_type __c) |
2799 | { |
2800 | size_type __sz = size(); |
2801 | if (__pos > __sz) |
2802 | this->__throw_out_of_range(); |
2803 | if (__n) |
2804 | { |
2805 | size_type __cap = capacity(); |
2806 | value_type* __p; |
2807 | if (__cap - __sz >= __n) |
2808 | { |
2809 | __p = _VSTDstd::__1::__to_address(__get_pointer()); |
2810 | size_type __n_move = __sz - __pos; |
2811 | if (__n_move != 0) |
2812 | traits_type::move(__p + __pos + __n, __p + __pos, __n_move); |
2813 | } |
2814 | else |
2815 | { |
2816 | __grow_by(__cap, __sz + __n - __cap, __sz, __pos, 0, __n); |
2817 | __p = _VSTDstd::__1::__to_address(__get_long_pointer()); |
2818 | } |
2819 | traits_type::assign(__p + __pos, __n, __c); |
2820 | __sz += __n; |
2821 | __set_size(__sz); |
2822 | traits_type::assign(__p[__sz], value_type()); |
2823 | } |
2824 | return *this; |
2825 | } |
2826 | |
2827 | template <class _CharT, class _Traits, class _Allocator> |
2828 | template<class _InputIterator> |
2829 | _EnableIf |
2830 | < |
2831 | __is_exactly_cpp17_input_iterator<_InputIterator>::value, |
2832 | typename basic_string<_CharT, _Traits, _Allocator>::iterator |
2833 | > |
2834 | basic_string<_CharT, _Traits, _Allocator>::insert(const_iterator __pos, _InputIterator __first, _InputIterator __last) |
2835 | { |
2836 | #if _LIBCPP_DEBUG_LEVEL0 == 2 |
2837 | _LIBCPP_ASSERT(__get_const_db()->__find_c_from_i(&__pos) == this,((void)0) |
2838 | "string::insert(iterator, range) called with an iterator not"((void)0) |
2839 | " referring to this string")((void)0); |
2840 | #endif |
2841 | const basic_string __temp(__first, __last, __alloc()); |
2842 | return insert(__pos, __temp.data(), __temp.data() + __temp.size()); |
2843 | } |
2844 | |
2845 | template <class _CharT, class _Traits, class _Allocator> |
2846 | template<class _ForwardIterator> |
2847 | _EnableIf |
2848 | < |
2849 | __is_cpp17_forward_iterator<_ForwardIterator>::value, |
2850 | typename basic_string<_CharT, _Traits, _Allocator>::iterator |
2851 | > |
2852 | basic_string<_CharT, _Traits, _Allocator>::insert(const_iterator __pos, _ForwardIterator __first, _ForwardIterator __last) |
2853 | { |
2854 | #if _LIBCPP_DEBUG_LEVEL0 == 2 |
2855 | _LIBCPP_ASSERT(__get_const_db()->__find_c_from_i(&__pos) == this,((void)0) |
2856 | "string::insert(iterator, range) called with an iterator not"((void)0) |
2857 | " referring to this string")((void)0); |
2858 | #endif |
2859 | size_type __ip = static_cast<size_type>(__pos - begin()); |
2860 | size_type __n = static_cast<size_type>(_VSTDstd::__1::distance(__first, __last)); |
2861 | if (__n) |
2862 | { |
2863 | if (__string_is_trivial_iterator<_ForwardIterator>::value && |
2864 | !__addr_in_range(*__first)) |
2865 | { |
2866 | size_type __sz = size(); |
2867 | size_type __cap = capacity(); |
2868 | value_type* __p; |
2869 | if (__cap - __sz >= __n) |
2870 | { |
2871 | __p = _VSTDstd::__1::__to_address(__get_pointer()); |
2872 | size_type __n_move = __sz - __ip; |
2873 | if (__n_move != 0) |
2874 | traits_type::move(__p + __ip + __n, __p + __ip, __n_move); |
2875 | } |
2876 | else |
2877 | { |
2878 | __grow_by(__cap, __sz + __n - __cap, __sz, __ip, 0, __n); |
2879 | __p = _VSTDstd::__1::__to_address(__get_long_pointer()); |
2880 | } |
2881 | __sz += __n; |
2882 | __set_size(__sz); |
2883 | traits_type::assign(__p[__sz], value_type()); |
2884 | for (__p += __ip; __first != __last; ++__p, ++__first) |
2885 | traits_type::assign(*__p, *__first); |
2886 | } |
2887 | else |
2888 | { |
2889 | const basic_string __temp(__first, __last, __alloc()); |
2890 | return insert(__pos, __temp.data(), __temp.data() + __temp.size()); |
2891 | } |
2892 | } |
2893 | return begin() + __ip; |
2894 | } |
2895 | |
2896 | template <class _CharT, class _Traits, class _Allocator> |
2897 | inline |
2898 | basic_string<_CharT, _Traits, _Allocator>& |
2899 | basic_string<_CharT, _Traits, _Allocator>::insert(size_type __pos1, const basic_string& __str) |
2900 | { |
2901 | return insert(__pos1, __str.data(), __str.size()); |
2902 | } |
2903 | |
2904 | template <class _CharT, class _Traits, class _Allocator> |
2905 | basic_string<_CharT, _Traits, _Allocator>& |
2906 | basic_string<_CharT, _Traits, _Allocator>::insert(size_type __pos1, const basic_string& __str, |
2907 | size_type __pos2, size_type __n) |
2908 | { |
2909 | size_type __str_sz = __str.size(); |
2910 | if (__pos2 > __str_sz) |
2911 | this->__throw_out_of_range(); |
2912 | return insert(__pos1, __str.data() + __pos2, _VSTDstd::__1::min(__n, __str_sz - __pos2)); |
2913 | } |
2914 | |
2915 | template <class _CharT, class _Traits, class _Allocator> |
2916 | template <class _Tp> |
2917 | _EnableIf |
2918 | < |
2919 | __can_be_converted_to_string_view<_CharT, _Traits, _Tp>::value && !__is_same_uncvref<_Tp, basic_string<_CharT, _Traits, _Allocator> >::value, |
2920 | basic_string<_CharT, _Traits, _Allocator>& |
2921 | > |
2922 | basic_string<_CharT, _Traits, _Allocator>::insert(size_type __pos1, const _Tp& __t, |
2923 | size_type __pos2, size_type __n) |
2924 | { |
2925 | __self_view __sv = __t; |
2926 | size_type __str_sz = __sv.size(); |
2927 | if (__pos2 > __str_sz) |
2928 | this->__throw_out_of_range(); |
2929 | return insert(__pos1, __sv.data() + __pos2, _VSTDstd::__1::min(__n, __str_sz - __pos2)); |
2930 | } |
2931 | |
2932 | template <class _CharT, class _Traits, class _Allocator> |
2933 | basic_string<_CharT, _Traits, _Allocator>& |
2934 | basic_string<_CharT, _Traits, _Allocator>::insert(size_type __pos, const value_type* __s) |
2935 | { |
2936 | _LIBCPP_ASSERT(__s != nullptr, "string::insert received nullptr")((void)0); |
2937 | return insert(__pos, __s, traits_type::length(__s)); |
2938 | } |
2939 | |
2940 | template <class _CharT, class _Traits, class _Allocator> |
2941 | typename basic_string<_CharT, _Traits, _Allocator>::iterator |
2942 | basic_string<_CharT, _Traits, _Allocator>::insert(const_iterator __pos, value_type __c) |
2943 | { |
2944 | size_type __ip = static_cast<size_type>(__pos - begin()); |
2945 | size_type __sz = size(); |
2946 | size_type __cap = capacity(); |
2947 | value_type* __p; |
2948 | if (__cap == __sz) |
2949 | { |
2950 | __grow_by(__cap, 1, __sz, __ip, 0, 1); |
2951 | __p = _VSTDstd::__1::__to_address(__get_long_pointer()); |
2952 | } |
2953 | else |
2954 | { |
2955 | __p = _VSTDstd::__1::__to_address(__get_pointer()); |
2956 | size_type __n_move = __sz - __ip; |
2957 | if (__n_move != 0) |
2958 | traits_type::move(__p + __ip + 1, __p + __ip, __n_move); |
2959 | } |
2960 | traits_type::assign(__p[__ip], __c); |
2961 | traits_type::assign(__p[++__sz], value_type()); |
2962 | __set_size(__sz); |
2963 | return begin() + static_cast<difference_type>(__ip); |
2964 | } |
2965 | |
2966 | template <class _CharT, class _Traits, class _Allocator> |
2967 | inline |
2968 | typename basic_string<_CharT, _Traits, _Allocator>::iterator |
2969 | basic_string<_CharT, _Traits, _Allocator>::insert(const_iterator __pos, size_type __n, value_type __c) |
2970 | { |
2971 | #if _LIBCPP_DEBUG_LEVEL0 == 2 |
2972 | _LIBCPP_ASSERT(__get_const_db()->__find_c_from_i(&__pos) == this,((void)0) |
2973 | "string::insert(iterator, n, value) called with an iterator not"((void)0) |
2974 | " referring to this string")((void)0); |
2975 | #endif |
2976 | difference_type __p = __pos - begin(); |
2977 | insert(static_cast<size_type>(__p), __n, __c); |
2978 | return begin() + __p; |
2979 | } |
2980 | |
2981 | // replace |
2982 | |
2983 | template <class _CharT, class _Traits, class _Allocator> |
2984 | basic_string<_CharT, _Traits, _Allocator>& |
2985 | basic_string<_CharT, _Traits, _Allocator>::replace(size_type __pos, size_type __n1, const value_type* __s, size_type __n2) |
2986 | _LIBCPP_DISABLE_UBSAN_UNSIGNED_INTEGER_CHECK__attribute__((__no_sanitize__("unsigned-integer-overflow"))) |
2987 | { |
2988 | _LIBCPP_ASSERT(__n2 == 0 || __s != nullptr, "string::replace received nullptr")((void)0); |
2989 | size_type __sz = size(); |
2990 | if (__pos > __sz) |
2991 | this->__throw_out_of_range(); |
2992 | __n1 = _VSTDstd::__1::min(__n1, __sz - __pos); |
2993 | size_type __cap = capacity(); |
2994 | if (__cap - __sz + __n1 >= __n2) |
2995 | { |
2996 | value_type* __p = _VSTDstd::__1::__to_address(__get_pointer()); |
2997 | if (__n1 != __n2) |
2998 | { |
2999 | size_type __n_move = __sz - __pos - __n1; |
3000 | if (__n_move != 0) |
3001 | { |
3002 | if (__n1 > __n2) |
3003 | { |
3004 | traits_type::move(__p + __pos, __s, __n2); |
3005 | traits_type::move(__p + __pos + __n2, __p + __pos + __n1, __n_move); |
3006 | goto __finish; |
3007 | } |
3008 | if (__p + __pos < __s && __s < __p + __sz) |
3009 | { |
3010 | if (__p + __pos + __n1 <= __s) |
3011 | __s += __n2 - __n1; |
3012 | else // __p + __pos < __s < __p + __pos + __n1 |
3013 | { |
3014 | traits_type::move(__p + __pos, __s, __n1); |
3015 | __pos += __n1; |
3016 | __s += __n2; |
3017 | __n2 -= __n1; |
3018 | __n1 = 0; |
3019 | } |
3020 | } |
3021 | traits_type::move(__p + __pos + __n2, __p + __pos + __n1, __n_move); |
3022 | } |
3023 | } |
3024 | traits_type::move(__p + __pos, __s, __n2); |
3025 | __finish: |
3026 | // __sz += __n2 - __n1; in this and the below function below can cause unsigned |
3027 | // integer overflow, but this is a safe operation, so we disable the check. |
3028 | __sz += __n2 - __n1; |
3029 | __set_size(__sz); |
3030 | __invalidate_iterators_past(__sz); |
3031 | traits_type::assign(__p[__sz], value_type()); |
3032 | } |
3033 | else |
3034 | __grow_by_and_replace(__cap, __sz - __n1 + __n2 - __cap, __sz, __pos, __n1, __n2, __s); |
3035 | return *this; |
3036 | } |
3037 | |
3038 | template <class _CharT, class _Traits, class _Allocator> |
3039 | basic_string<_CharT, _Traits, _Allocator>& |
3040 | basic_string<_CharT, _Traits, _Allocator>::replace(size_type __pos, size_type __n1, size_type __n2, value_type __c) |
3041 | _LIBCPP_DISABLE_UBSAN_UNSIGNED_INTEGER_CHECK__attribute__((__no_sanitize__("unsigned-integer-overflow"))) |
3042 | { |
3043 | size_type __sz = size(); |
3044 | if (__pos > __sz) |
3045 | this->__throw_out_of_range(); |
3046 | __n1 = _VSTDstd::__1::min(__n1, __sz - __pos); |
3047 | size_type __cap = capacity(); |
3048 | value_type* __p; |
3049 | if (__cap - __sz + __n1 >= __n2) |
3050 | { |
3051 | __p = _VSTDstd::__1::__to_address(__get_pointer()); |
3052 | if (__n1 != __n2) |
3053 | { |
3054 | size_type __n_move = __sz - __pos - __n1; |
3055 | if (__n_move != 0) |
3056 | traits_type::move(__p + __pos + __n2, __p + __pos + __n1, __n_move); |
3057 | } |
3058 | } |
3059 | else |
3060 | { |
3061 | __grow_by(__cap, __sz - __n1 + __n2 - __cap, __sz, __pos, __n1, __n2); |
3062 | __p = _VSTDstd::__1::__to_address(__get_long_pointer()); |
3063 | } |
3064 | traits_type::assign(__p + __pos, __n2, __c); |
3065 | __sz += __n2 - __n1; |
3066 | __set_size(__sz); |
3067 | __invalidate_iterators_past(__sz); |
3068 | traits_type::assign(__p[__sz], value_type()); |
3069 | return *this; |
3070 | } |
3071 | |
3072 | template <class _CharT, class _Traits, class _Allocator> |
3073 | template<class _InputIterator> |
3074 | _EnableIf |
3075 | < |
3076 | __is_cpp17_input_iterator<_InputIterator>::value, |
3077 | basic_string<_CharT, _Traits, _Allocator>& |
3078 | > |
3079 | basic_string<_CharT, _Traits, _Allocator>::replace(const_iterator __i1, const_iterator __i2, |
3080 | _InputIterator __j1, _InputIterator __j2) |
3081 | { |
3082 | const basic_string __temp(__j1, __j2, __alloc()); |
3083 | return this->replace(__i1, __i2, __temp); |
3084 | } |
3085 | |
3086 | template <class _CharT, class _Traits, class _Allocator> |
3087 | inline |
3088 | basic_string<_CharT, _Traits, _Allocator>& |
3089 | basic_string<_CharT, _Traits, _Allocator>::replace(size_type __pos1, size_type __n1, const basic_string& __str) |
3090 | { |
3091 | return replace(__pos1, __n1, __str.data(), __str.size()); |
3092 | } |
3093 | |
3094 | template <class _CharT, class _Traits, class _Allocator> |
3095 | basic_string<_CharT, _Traits, _Allocator>& |
3096 | basic_string<_CharT, _Traits, _Allocator>::replace(size_type __pos1, size_type __n1, const basic_string& __str, |
3097 | size_type __pos2, size_type __n2) |
3098 | { |
3099 | size_type __str_sz = __str.size(); |
3100 | if (__pos2 > __str_sz) |
3101 | this->__throw_out_of_range(); |
3102 | return replace(__pos1, __n1, __str.data() + __pos2, _VSTDstd::__1::min(__n2, __str_sz - __pos2)); |
3103 | } |
3104 | |
3105 | template <class _CharT, class _Traits, class _Allocator> |
3106 | template <class _Tp> |
3107 | _EnableIf |
3108 | < |
3109 | __can_be_converted_to_string_view<_CharT, _Traits, _Tp>::value && !__is_same_uncvref<_Tp, basic_string<_CharT, _Traits, _Allocator> >::value, |
3110 | basic_string<_CharT, _Traits, _Allocator>& |
3111 | > |
3112 | basic_string<_CharT, _Traits, _Allocator>::replace(size_type __pos1, size_type __n1, const _Tp& __t, |
3113 | size_type __pos2, size_type __n2) |
3114 | { |
3115 | __self_view __sv = __t; |
3116 | size_type __str_sz = __sv.size(); |
3117 | if (__pos2 > __str_sz) |
3118 | this->__throw_out_of_range(); |
3119 | return replace(__pos1, __n1, __sv.data() + __pos2, _VSTDstd::__1::min(__n2, __str_sz - __pos2)); |
3120 | } |
3121 | |
3122 | template <class _CharT, class _Traits, class _Allocator> |
3123 | basic_string<_CharT, _Traits, _Allocator>& |
3124 | basic_string<_CharT, _Traits, _Allocator>::replace(size_type __pos, size_type __n1, const value_type* __s) |
3125 | { |
3126 | _LIBCPP_ASSERT(__s != nullptr, "string::replace received nullptr")((void)0); |
3127 | return replace(__pos, __n1, __s, traits_type::length(__s)); |
3128 | } |
3129 | |
3130 | template <class _CharT, class _Traits, class _Allocator> |
3131 | inline |
3132 | basic_string<_CharT, _Traits, _Allocator>& |
3133 | basic_string<_CharT, _Traits, _Allocator>::replace(const_iterator __i1, const_iterator __i2, const basic_string& __str) |
3134 | { |
3135 | return replace(static_cast<size_type>(__i1 - begin()), static_cast<size_type>(__i2 - __i1), |
3136 | __str.data(), __str.size()); |
3137 | } |
3138 | |
3139 | template <class _CharT, class _Traits, class _Allocator> |
3140 | inline |
3141 | basic_string<_CharT, _Traits, _Allocator>& |
3142 | basic_string<_CharT, _Traits, _Allocator>::replace(const_iterator __i1, const_iterator __i2, const value_type* __s, size_type __n) |
3143 | { |
3144 | return replace(static_cast<size_type>(__i1 - begin()), static_cast<size_type>(__i2 - __i1), __s, __n); |
3145 | } |
3146 | |
3147 | template <class _CharT, class _Traits, class _Allocator> |
3148 | inline |
3149 | basic_string<_CharT, _Traits, _Allocator>& |
3150 | basic_string<_CharT, _Traits, _Allocator>::replace(const_iterator __i1, const_iterator __i2, const value_type* __s) |
3151 | { |
3152 | return replace(static_cast<size_type>(__i1 - begin()), static_cast<size_type>(__i2 - __i1), __s); |
3153 | } |
3154 | |
3155 | template <class _CharT, class _Traits, class _Allocator> |
3156 | inline |
3157 | basic_string<_CharT, _Traits, _Allocator>& |
3158 | basic_string<_CharT, _Traits, _Allocator>::replace(const_iterator __i1, const_iterator __i2, size_type __n, value_type __c) |
3159 | { |
3160 | return replace(static_cast<size_type>(__i1 - begin()), static_cast<size_type>(__i2 - __i1), __n, __c); |
3161 | } |
3162 | |
3163 | // erase |
3164 | |
3165 | // 'externally instantiated' erase() implementation, called when __n != npos. |
3166 | // Does not check __pos against size() |
3167 | template <class _CharT, class _Traits, class _Allocator> |
3168 | void |
3169 | basic_string<_CharT, _Traits, _Allocator>::__erase_external_with_move( |
3170 | size_type __pos, size_type __n) |
3171 | { |
3172 | if (__n) |
3173 | { |
3174 | size_type __sz = size(); |
3175 | value_type* __p = _VSTDstd::__1::__to_address(__get_pointer()); |
3176 | __n = _VSTDstd::__1::min(__n, __sz - __pos); |
3177 | size_type __n_move = __sz - __pos - __n; |
3178 | if (__n_move != 0) |
3179 | traits_type::move(__p + __pos, __p + __pos + __n, __n_move); |
3180 | __sz -= __n; |
3181 | __set_size(__sz); |
3182 | __invalidate_iterators_past(__sz); |
3183 | traits_type::assign(__p[__sz], value_type()); |
3184 | } |
3185 | } |
3186 | |
3187 | template <class _CharT, class _Traits, class _Allocator> |
3188 | basic_string<_CharT, _Traits, _Allocator>& |
3189 | basic_string<_CharT, _Traits, _Allocator>::erase(size_type __pos, |
3190 | size_type __n) { |
3191 | if (__pos > size()) this->__throw_out_of_range(); |
3192 | if (__n == npos) { |
3193 | __erase_to_end(__pos); |
3194 | } else { |
3195 | __erase_external_with_move(__pos, __n); |
3196 | } |
3197 | return *this; |
3198 | } |
3199 | |
3200 | template <class _CharT, class _Traits, class _Allocator> |
3201 | inline |
3202 | typename basic_string<_CharT, _Traits, _Allocator>::iterator |
3203 | basic_string<_CharT, _Traits, _Allocator>::erase(const_iterator __pos) |
3204 | { |
3205 | #if _LIBCPP_DEBUG_LEVEL0 == 2 |
3206 | _LIBCPP_ASSERT(__get_const_db()->__find_c_from_i(&__pos) == this,((void)0) |
3207 | "string::erase(iterator) called with an iterator not"((void)0) |
3208 | " referring to this string")((void)0); |
3209 | #endif |
3210 | _LIBCPP_ASSERT(__pos != end(),((void)0) |
3211 | "string::erase(iterator) called with a non-dereferenceable iterator")((void)0); |
3212 | iterator __b = begin(); |
3213 | size_type __r = static_cast<size_type>(__pos - __b); |
3214 | erase(__r, 1); |
3215 | return __b + static_cast<difference_type>(__r); |
3216 | } |
3217 | |
3218 | template <class _CharT, class _Traits, class _Allocator> |
3219 | inline |
3220 | typename basic_string<_CharT, _Traits, _Allocator>::iterator |
3221 | basic_string<_CharT, _Traits, _Allocator>::erase(const_iterator __first, const_iterator __last) |
3222 | { |
3223 | #if _LIBCPP_DEBUG_LEVEL0 == 2 |
3224 | _LIBCPP_ASSERT(__get_const_db()->__find_c_from_i(&__first) == this,((void)0) |
3225 | "string::erase(iterator, iterator) called with an iterator not"((void)0) |
3226 | " referring to this string")((void)0); |
3227 | #endif |
3228 | _LIBCPP_ASSERT(__first <= __last, "string::erase(first, last) called with invalid range")((void)0); |
3229 | iterator __b = begin(); |
3230 | size_type __r = static_cast<size_type>(__first - __b); |
3231 | erase(__r, static_cast<size_type>(__last - __first)); |
3232 | return __b + static_cast<difference_type>(__r); |
3233 | } |
3234 | |
3235 | template <class _CharT, class _Traits, class _Allocator> |
3236 | inline |
3237 | void |
3238 | basic_string<_CharT, _Traits, _Allocator>::pop_back() |
3239 | { |
3240 | _LIBCPP_ASSERT(!empty(), "string::pop_back(): string is already empty")((void)0); |
3241 | size_type __sz; |
3242 | if (__is_long()) |
3243 | { |
3244 | __sz = __get_long_size() - 1; |
3245 | __set_long_size(__sz); |
3246 | traits_type::assign(*(__get_long_pointer() + __sz), value_type()); |
3247 | } |
3248 | else |
3249 | { |
3250 | __sz = __get_short_size() - 1; |
3251 | __set_short_size(__sz); |
3252 | traits_type::assign(*(__get_short_pointer() + __sz), value_type()); |
3253 | } |
3254 | __invalidate_iterators_past(__sz); |
3255 | } |
3256 | |
3257 | template <class _CharT, class _Traits, class _Allocator> |
3258 | inline |
3259 | void |
3260 | basic_string<_CharT, _Traits, _Allocator>::clear() _NOEXCEPTnoexcept |
3261 | { |
3262 | __invalidate_all_iterators(); |
3263 | if (__is_long()) |
3264 | { |
3265 | traits_type::assign(*__get_long_pointer(), value_type()); |
3266 | __set_long_size(0); |
3267 | } |
3268 | else |
3269 | { |
3270 | traits_type::assign(*__get_short_pointer(), value_type()); |
3271 | __set_short_size(0); |
3272 | } |
3273 | } |
3274 | |
3275 | template <class _CharT, class _Traits, class _Allocator> |
3276 | inline |
3277 | void |
3278 | basic_string<_CharT, _Traits, _Allocator>::__erase_to_end(size_type __pos) |
3279 | { |
3280 | if (__is_long()) |
3281 | { |
3282 | traits_type::assign(*(__get_long_pointer() + __pos), value_type()); |
3283 | __set_long_size(__pos); |
3284 | } |
3285 | else |
3286 | { |
3287 | traits_type::assign(*(__get_short_pointer() + __pos), value_type()); |
3288 | __set_short_size(__pos); |
3289 | } |
3290 | __invalidate_iterators_past(__pos); |
3291 | } |
3292 | |
3293 | template <class _CharT, class _Traits, class _Allocator> |
3294 | void |
3295 | basic_string<_CharT, _Traits, _Allocator>::resize(size_type __n, value_type __c) |
3296 | { |
3297 | size_type __sz = size(); |
3298 | if (__n > __sz) |
3299 | append(__n - __sz, __c); |
3300 | else |
3301 | __erase_to_end(__n); |
3302 | } |
3303 | |
3304 | template <class _CharT, class _Traits, class _Allocator> |
3305 | inline void |
3306 | basic_string<_CharT, _Traits, _Allocator>::__resize_default_init(size_type __n) |
3307 | { |
3308 | size_type __sz = size(); |
3309 | if (__n > __sz) { |
3310 | __append_default_init(__n - __sz); |
3311 | } else |
3312 | __erase_to_end(__n); |
3313 | } |
3314 | |
3315 | template <class _CharT, class _Traits, class _Allocator> |
3316 | inline |
3317 | typename basic_string<_CharT, _Traits, _Allocator>::size_type |
3318 | basic_string<_CharT, _Traits, _Allocator>::max_size() const _NOEXCEPTnoexcept |
3319 | { |
3320 | size_type __m = __alloc_traits::max_size(__alloc()); |
3321 | #ifdef _LIBCPP_BIG_ENDIAN |
3322 | return (__m <= ~__long_mask ? __m : __m/2) - __alignment; |
3323 | #else |
3324 | return __m - __alignment; |
3325 | #endif |
3326 | } |
3327 | |
3328 | template <class _CharT, class _Traits, class _Allocator> |
3329 | void |
3330 | basic_string<_CharT, _Traits, _Allocator>::reserve(size_type __requested_capacity) |
3331 | { |
3332 | if (__requested_capacity > max_size()) |
3333 | this->__throw_length_error(); |
3334 | |
3335 | #if _LIBCPP_STD_VER14 > 17 |
3336 | // Reserve never shrinks as of C++20. |
3337 | if (__requested_capacity <= capacity()) return; |
3338 | #endif |
3339 | |
3340 | size_type __target_capacity = _VSTDstd::__1::max(__requested_capacity, size()); |
3341 | __target_capacity = __recommend(__target_capacity); |
3342 | if (__target_capacity == capacity()) return; |
3343 | |
3344 | __shrink_or_extend(__target_capacity); |
3345 | } |
3346 | |
3347 | template <class _CharT, class _Traits, class _Allocator> |
3348 | void |
3349 | basic_string<_CharT, _Traits, _Allocator>::shrink_to_fit() _NOEXCEPTnoexcept |
3350 | { |
3351 | size_type __target_capacity = __recommend(size()); |
3352 | if (__target_capacity == capacity()) return; |
3353 | |
3354 | __shrink_or_extend(__target_capacity); |
3355 | } |
3356 | |
3357 | template <class _CharT, class _Traits, class _Allocator> |
3358 | void |
3359 | basic_string<_CharT, _Traits, _Allocator>::__shrink_or_extend(size_type __target_capacity) |
3360 | { |
3361 | size_type __cap = capacity(); |
3362 | size_type __sz = size(); |
3363 | |
3364 | pointer __new_data, __p; |
3365 | bool __was_long, __now_long; |
3366 | if (__target_capacity == __min_cap - 1) |
3367 | { |
3368 | __was_long = true; |
3369 | __now_long = false; |
3370 | __new_data = __get_short_pointer(); |
3371 | __p = __get_long_pointer(); |
3372 | } |
3373 | else |
3374 | { |
3375 | if (__target_capacity > __cap) |
3376 | __new_data = __alloc_traits::allocate(__alloc(), __target_capacity+1); |
3377 | else |
3378 | { |
3379 | #ifndef _LIBCPP_NO_EXCEPTIONS |
3380 | try |
3381 | { |
3382 | #endif // _LIBCPP_NO_EXCEPTIONS |
3383 | __new_data = __alloc_traits::allocate(__alloc(), __target_capacity+1); |
3384 | #ifndef _LIBCPP_NO_EXCEPTIONS |
3385 | } |
3386 | catch (...) |
3387 | { |
3388 | return; |
3389 | } |
3390 | #else // _LIBCPP_NO_EXCEPTIONS |
3391 | if (__new_data == nullptr) |
3392 | return; |
3393 | #endif // _LIBCPP_NO_EXCEPTIONS |
3394 | } |
3395 | __now_long = true; |
3396 | __was_long = __is_long(); |
3397 | __p = __get_pointer(); |
3398 | } |
3399 | traits_type::copy(_VSTDstd::__1::__to_address(__new_data), |
3400 | _VSTDstd::__1::__to_address(__p), size()+1); |
3401 | if (__was_long) |
3402 | __alloc_traits::deallocate(__alloc(), __p, __cap+1); |
3403 | if (__now_long) |
3404 | { |
3405 | __set_long_cap(__target_capacity+1); |
3406 | __set_long_size(__sz); |
3407 | __set_long_pointer(__new_data); |
3408 | } |
3409 | else |
3410 | __set_short_size(__sz); |
3411 | __invalidate_all_iterators(); |
3412 | } |
3413 | |
3414 | template <class _CharT, class _Traits, class _Allocator> |
3415 | inline |
3416 | typename basic_string<_CharT, _Traits, _Allocator>::const_reference |
3417 | basic_string<_CharT, _Traits, _Allocator>::operator[](size_type __pos) const _NOEXCEPTnoexcept |
3418 | { |
3419 | _LIBCPP_ASSERT(__pos <= size(), "string index out of bounds")((void)0); |
3420 | return *(data() + __pos); |
3421 | } |
3422 | |
3423 | template <class _CharT, class _Traits, class _Allocator> |
3424 | inline |
3425 | typename basic_string<_CharT, _Traits, _Allocator>::reference |
3426 | basic_string<_CharT, _Traits, _Allocator>::operator[](size_type __pos) _NOEXCEPTnoexcept |
3427 | { |
3428 | _LIBCPP_ASSERT(__pos <= size(), "string index out of bounds")((void)0); |
3429 | return *(__get_pointer() + __pos); |
3430 | } |
3431 | |
3432 | template <class _CharT, class _Traits, class _Allocator> |
3433 | typename basic_string<_CharT, _Traits, _Allocator>::const_reference |
3434 | basic_string<_CharT, _Traits, _Allocator>::at(size_type __n) const |
3435 | { |
3436 | if (__n >= size()) |
3437 | this->__throw_out_of_range(); |
3438 | return (*this)[__n]; |
3439 | } |
3440 | |
3441 | template <class _CharT, class _Traits, class _Allocator> |
3442 | typename basic_string<_CharT, _Traits, _Allocator>::reference |
3443 | basic_string<_CharT, _Traits, _Allocator>::at(size_type __n) |
3444 | { |
3445 | if (__n >= size()) |
3446 | this->__throw_out_of_range(); |
3447 | return (*this)[__n]; |
3448 | } |
3449 | |
3450 | template <class _CharT, class _Traits, class _Allocator> |
3451 | inline |
3452 | typename basic_string<_CharT, _Traits, _Allocator>::reference |
3453 | basic_string<_CharT, _Traits, _Allocator>::front() _NOEXCEPTnoexcept |
3454 | { |
3455 | _LIBCPP_ASSERT(!empty(), "string::front(): string is empty")((void)0); |
3456 | return *__get_pointer(); |
3457 | } |
3458 | |
3459 | template <class _CharT, class _Traits, class _Allocator> |
3460 | inline |
3461 | typename basic_string<_CharT, _Traits, _Allocator>::const_reference |
3462 | basic_string<_CharT, _Traits, _Allocator>::front() const _NOEXCEPTnoexcept |
3463 | { |
3464 | _LIBCPP_ASSERT(!empty(), "string::front(): string is empty")((void)0); |
3465 | return *data(); |
3466 | } |
3467 | |
3468 | template <class _CharT, class _Traits, class _Allocator> |
3469 | inline |
3470 | typename basic_string<_CharT, _Traits, _Allocator>::reference |
3471 | basic_string<_CharT, _Traits, _Allocator>::back() _NOEXCEPTnoexcept |
3472 | { |
3473 | _LIBCPP_ASSERT(!empty(), "string::back(): string is empty")((void)0); |
3474 | return *(__get_pointer() + size() - 1); |
3475 | } |
3476 | |
3477 | template <class _CharT, class _Traits, class _Allocator> |
3478 | inline |
3479 | typename basic_string<_CharT, _Traits, _Allocator>::const_reference |
3480 | basic_string<_CharT, _Traits, _Allocator>::back() const _NOEXCEPTnoexcept |
3481 | { |
3482 | _LIBCPP_ASSERT(!empty(), "string::back(): string is empty")((void)0); |
3483 | return *(data() + size() - 1); |
3484 | } |
3485 | |
3486 | template <class _CharT, class _Traits, class _Allocator> |
3487 | typename basic_string<_CharT, _Traits, _Allocator>::size_type |
3488 | basic_string<_CharT, _Traits, _Allocator>::copy(value_type* __s, size_type __n, size_type __pos) const |
3489 | { |
3490 | size_type __sz = size(); |
3491 | if (__pos > __sz) |
3492 | this->__throw_out_of_range(); |
3493 | size_type __rlen = _VSTDstd::__1::min(__n, __sz - __pos); |
3494 | traits_type::copy(__s, data() + __pos, __rlen); |
3495 | return __rlen; |
3496 | } |
3497 | |
3498 | template <class _CharT, class _Traits, class _Allocator> |
3499 | inline |
3500 | basic_string<_CharT, _Traits, _Allocator> |
3501 | basic_string<_CharT, _Traits, _Allocator>::substr(size_type __pos, size_type __n) const |
3502 | { |
3503 | return basic_string(*this, __pos, __n, __alloc()); |
3504 | } |
3505 | |
3506 | template <class _CharT, class _Traits, class _Allocator> |
3507 | inline |
3508 | void |
3509 | basic_string<_CharT, _Traits, _Allocator>::swap(basic_string& __str) |
3510 | #if _LIBCPP_STD_VER14 >= 14 |
3511 | _NOEXCEPTnoexcept |
3512 | #else |
3513 | _NOEXCEPT_(!__alloc_traits::propagate_on_container_swap::value ||noexcept(!__alloc_traits::propagate_on_container_swap::value || __is_nothrow_swappable<allocator_type>::value) |
3514 | __is_nothrow_swappable<allocator_type>::value)noexcept(!__alloc_traits::propagate_on_container_swap::value || __is_nothrow_swappable<allocator_type>::value) |
3515 | #endif |
3516 | { |
3517 | #if _LIBCPP_DEBUG_LEVEL0 == 2 |
3518 | if (!__is_long()) |
3519 | __get_db()->__invalidate_all(this); |
3520 | if (!__str.__is_long()) |
3521 | __get_db()->__invalidate_all(&__str); |
3522 | __get_db()->swap(this, &__str); |
3523 | #endif |
3524 | _LIBCPP_ASSERT(((void)0) |
3525 | __alloc_traits::propagate_on_container_swap::value ||((void)0) |
3526 | __alloc_traits::is_always_equal::value ||((void)0) |
3527 | __alloc() == __str.__alloc(), "swapping non-equal allocators")((void)0); |
3528 | _VSTDstd::__1::swap(__r_.first(), __str.__r_.first()); |
3529 | _VSTDstd::__1::__swap_allocator(__alloc(), __str.__alloc()); |
3530 | } |
3531 | |
3532 | // find |
3533 | |
3534 | template <class _Traits> |
3535 | struct _LIBCPP_HIDDEN__attribute__ ((__visibility__("hidden"))) __traits_eq |
3536 | { |
3537 | typedef typename _Traits::char_type char_type; |
3538 | _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__ )) |
3539 | bool operator()(const char_type& __x, const char_type& __y) _NOEXCEPTnoexcept |
3540 | {return _Traits::eq(__x, __y);} |
3541 | }; |
3542 | |
3543 | template<class _CharT, class _Traits, class _Allocator> |
3544 | typename basic_string<_CharT, _Traits, _Allocator>::size_type |
3545 | basic_string<_CharT, _Traits, _Allocator>::find(const value_type* __s, |
3546 | size_type __pos, |
3547 | size_type __n) const _NOEXCEPTnoexcept |
3548 | { |
3549 | _LIBCPP_ASSERT(__n == 0 || __s != nullptr, "string::find(): received nullptr")((void)0); |
3550 | return __str_find<value_type, size_type, traits_type, npos> |
3551 | (data(), size(), __s, __pos, __n); |
3552 | } |
3553 | |
3554 | template<class _CharT, class _Traits, class _Allocator> |
3555 | inline |
3556 | typename basic_string<_CharT, _Traits, _Allocator>::size_type |
3557 | basic_string<_CharT, _Traits, _Allocator>::find(const basic_string& __str, |
3558 | size_type __pos) const _NOEXCEPTnoexcept |
3559 | { |
3560 | return __str_find<value_type, size_type, traits_type, npos> |
3561 | (data(), size(), __str.data(), __pos, __str.size()); |
3562 | } |
3563 | |
3564 | template<class _CharT, class _Traits, class _Allocator> |
3565 | template <class _Tp> |
3566 | _EnableIf |
3567 | < |
3568 | __can_be_converted_to_string_view<_CharT, _Traits, _Tp>::value, |
3569 | typename basic_string<_CharT, _Traits, _Allocator>::size_type |
3570 | > |
3571 | basic_string<_CharT, _Traits, _Allocator>::find(const _Tp &__t, |
3572 | size_type __pos) const _NOEXCEPTnoexcept |
3573 | { |
3574 | __self_view __sv = __t; |
3575 | return __str_find<value_type, size_type, traits_type, npos> |
3576 | (data(), size(), __sv.data(), __pos, __sv.size()); |
3577 | } |
3578 | |
3579 | template<class _CharT, class _Traits, class _Allocator> |
3580 | inline |
3581 | typename basic_string<_CharT, _Traits, _Allocator>::size_type |
3582 | basic_string<_CharT, _Traits, _Allocator>::find(const value_type* __s, |
3583 | size_type __pos) const _NOEXCEPTnoexcept |
3584 | { |
3585 | _LIBCPP_ASSERT(__s != nullptr, "string::find(): received nullptr")((void)0); |
3586 | return __str_find<value_type, size_type, traits_type, npos> |
3587 | (data(), size(), __s, __pos, traits_type::length(__s)); |
3588 | } |
3589 | |
3590 | template<class _CharT, class _Traits, class _Allocator> |
3591 | typename basic_string<_CharT, _Traits, _Allocator>::size_type |
3592 | basic_string<_CharT, _Traits, _Allocator>::find(value_type __c, |
3593 | size_type __pos) const _NOEXCEPTnoexcept |
3594 | { |
3595 | return __str_find<value_type, size_type, traits_type, npos> |
3596 | (data(), size(), __c, __pos); |
3597 | } |
3598 | |
3599 | // rfind |
3600 | |
3601 | template<class _CharT, class _Traits, class _Allocator> |
3602 | typename basic_string<_CharT, _Traits, _Allocator>::size_type |
3603 | basic_string<_CharT, _Traits, _Allocator>::rfind(const value_type* __s, |
3604 | size_type __pos, |
3605 | size_type __n) const _NOEXCEPTnoexcept |
3606 | { |
3607 | _LIBCPP_ASSERT(__n == 0 || __s != nullptr, "string::rfind(): received nullptr")((void)0); |
3608 | return __str_rfind<value_type, size_type, traits_type, npos> |
3609 | (data(), size(), __s, __pos, __n); |
3610 | } |
3611 | |
3612 | template<class _CharT, class _Traits, class _Allocator> |
3613 | inline |
3614 | typename basic_string<_CharT, _Traits, _Allocator>::size_type |
3615 | basic_string<_CharT, _Traits, _Allocator>::rfind(const basic_string& __str, |
3616 | size_type __pos) const _NOEXCEPTnoexcept |
3617 | { |
3618 | return __str_rfind<value_type, size_type, traits_type, npos> |
3619 | (data(), size(), __str.data(), __pos, __str.size()); |
3620 | } |
3621 | |
3622 | template<class _CharT, class _Traits, class _Allocator> |
3623 | template <class _Tp> |
3624 | _EnableIf |
3625 | < |
3626 | __can_be_converted_to_string_view<_CharT, _Traits, _Tp>::value, |
3627 | typename basic_string<_CharT, _Traits, _Allocator>::size_type |
3628 | > |
3629 | basic_string<_CharT, _Traits, _Allocator>::rfind(const _Tp& __t, |
3630 | size_type __pos) const _NOEXCEPTnoexcept |
3631 | { |
3632 | __self_view __sv = __t; |
3633 | return __str_rfind<value_type, size_type, traits_type, npos> |
3634 | (data(), size(), __sv.data(), __pos, __sv.size()); |
3635 | } |
3636 | |
3637 | template<class _CharT, class _Traits, class _Allocator> |
3638 | inline |
3639 | typename basic_string<_CharT, _Traits, _Allocator>::size_type |
3640 | basic_string<_CharT, _Traits, _Allocator>::rfind(const value_type* __s, |
3641 | size_type __pos) const _NOEXCEPTnoexcept |
3642 | { |
3643 | _LIBCPP_ASSERT(__s != nullptr, "string::rfind(): received nullptr")((void)0); |
3644 | return __str_rfind<value_type, size_type, traits_type, npos> |
3645 | (data(), size(), __s, __pos, traits_type::length(__s)); |
3646 | } |
3647 | |
3648 | template<class _CharT, class _Traits, class _Allocator> |
3649 | typename basic_string<_CharT, _Traits, _Allocator>::size_type |
3650 | basic_string<_CharT, _Traits, _Allocator>::rfind(value_type __c, |
3651 | size_type __pos) const _NOEXCEPTnoexcept |
3652 | { |
3653 | return __str_rfind<value_type, size_type, traits_type, npos> |
3654 | (data(), size(), __c, __pos); |
3655 | } |
3656 | |
3657 | // find_first_of |
3658 | |
3659 | template<class _CharT, class _Traits, class _Allocator> |
3660 | typename basic_string<_CharT, _Traits, _Allocator>::size_type |
3661 | basic_string<_CharT, _Traits, _Allocator>::find_first_of(const value_type* __s, |
3662 | size_type __pos, |
3663 | size_type __n) const _NOEXCEPTnoexcept |
3664 | { |
3665 | _LIBCPP_ASSERT(__n == 0 || __s != nullptr, "string::find_first_of(): received nullptr")((void)0); |
3666 | return __str_find_first_of<value_type, size_type, traits_type, npos> |
3667 | (data(), size(), __s, __pos, __n); |
3668 | } |
3669 | |
3670 | template<class _CharT, class _Traits, class _Allocator> |
3671 | inline |
3672 | typename basic_string<_CharT, _Traits, _Allocator>::size_type |
3673 | basic_string<_CharT, _Traits, _Allocator>::find_first_of(const basic_string& __str, |
3674 | size_type __pos) const _NOEXCEPTnoexcept |
3675 | { |
3676 | return __str_find_first_of<value_type, size_type, traits_type, npos> |
3677 | (data(), size(), __str.data(), __pos, __str.size()); |
3678 | } |
3679 | |
3680 | template<class _CharT, class _Traits, class _Allocator> |
3681 | template <class _Tp> |
3682 | _EnableIf |
3683 | < |
3684 | __can_be_converted_to_string_view<_CharT, _Traits, _Tp>::value, |
3685 | typename basic_string<_CharT, _Traits, _Allocator>::size_type |
3686 | > |
3687 | basic_string<_CharT, _Traits, _Allocator>::find_first_of(const _Tp& __t, |
3688 | size_type __pos) const _NOEXCEPTnoexcept |
3689 | { |
3690 | __self_view __sv = __t; |
3691 | return __str_find_first_of<value_type, size_type, traits_type, npos> |
3692 | (data(), size(), __sv.data(), __pos, __sv.size()); |
3693 | } |
3694 | |
3695 | template<class _CharT, class _Traits, class _Allocator> |
3696 | inline |
3697 | typename basic_string<_CharT, _Traits, _Allocator>::size_type |
3698 | basic_string<_CharT, _Traits, _Allocator>::find_first_of(const value_type* __s, |
3699 | size_type __pos) const _NOEXCEPTnoexcept |
3700 | { |
3701 | _LIBCPP_ASSERT(__s != nullptr, "string::find_first_of(): received nullptr")((void)0); |
3702 | return __str_find_first_of<value_type, size_type, traits_type, npos> |
3703 | (data(), size(), __s, __pos, traits_type::length(__s)); |
3704 | } |
3705 | |
3706 | template<class _CharT, class _Traits, class _Allocator> |
3707 | inline |
3708 | typename basic_string<_CharT, _Traits, _Allocator>::size_type |
3709 | basic_string<_CharT, _Traits, _Allocator>::find_first_of(value_type __c, |
3710 | size_type __pos) const _NOEXCEPTnoexcept |
3711 | { |
3712 | return find(__c, __pos); |
3713 | } |
3714 | |
3715 | // find_last_of |
3716 | |
3717 | template<class _CharT, class _Traits, class _Allocator> |
3718 | typename basic_string<_CharT, _Traits, _Allocator>::size_type |
3719 | basic_string<_CharT, _Traits, _Allocator>::find_last_of(const value_type* __s, |
3720 | size_type __pos, |
3721 | size_type __n) const _NOEXCEPTnoexcept |
3722 | { |
3723 | _LIBCPP_ASSERT(__n == 0 || __s != nullptr, "string::find_last_of(): received nullptr")((void)0); |
3724 | return __str_find_last_of<value_type, size_type, traits_type, npos> |
3725 | (data(), size(), __s, __pos, __n); |
3726 | } |
3727 | |
3728 | template<class _CharT, class _Traits, class _Allocator> |
3729 | inline |
3730 | typename basic_string<_CharT, _Traits, _Allocator>::size_type |
3731 | basic_string<_CharT, _Traits, _Allocator>::find_last_of(const basic_string& __str, |
3732 | size_type __pos) const _NOEXCEPTnoexcept |
3733 | { |
3734 | return __str_find_last_of<value_type, size_type, traits_type, npos> |
3735 | (data(), size(), __str.data(), __pos, __str.size()); |
3736 | } |
3737 | |
3738 | template<class _CharT, class _Traits, class _Allocator> |
3739 | template <class _Tp> |
3740 | _EnableIf |
3741 | < |
3742 | __can_be_converted_to_string_view<_CharT, _Traits, _Tp>::value, |
3743 | typename basic_string<_CharT, _Traits, _Allocator>::size_type |
3744 | > |
3745 | basic_string<_CharT, _Traits, _Allocator>::find_last_of(const _Tp& __t, |
3746 | size_type __pos) const _NOEXCEPTnoexcept |
3747 | { |
3748 | __self_view __sv = __t; |
3749 | return __str_find_last_of<value_type, size_type, traits_type, npos> |
3750 | (data(), size(), __sv.data(), __pos, __sv.size()); |
3751 | } |
3752 | |
3753 | template<class _CharT, class _Traits, class _Allocator> |
3754 | inline |
3755 | typename basic_string<_CharT, _Traits, _Allocator>::size_type |
3756 | basic_string<_CharT, _Traits, _Allocator>::find_last_of(const value_type* __s, |
3757 | size_type __pos) const _NOEXCEPTnoexcept |
3758 | { |
3759 | _LIBCPP_ASSERT(__s != nullptr, "string::find_last_of(): received nullptr")((void)0); |
3760 | return __str_find_last_of<value_type, size_type, traits_type, npos> |
3761 | (data(), size(), __s, __pos, traits_type::length(__s)); |
3762 | } |
3763 | |
3764 | template<class _CharT, class _Traits, class _Allocator> |
3765 | inline |
3766 | typename basic_string<_CharT, _Traits, _Allocator>::size_type |
3767 | basic_string<_CharT, _Traits, _Allocator>::find_last_of(value_type __c, |
3768 | size_type __pos) const _NOEXCEPTnoexcept |
3769 | { |
3770 | return rfind(__c, __pos); |
3771 | } |
3772 | |
3773 | // find_first_not_of |
3774 | |
3775 | template<class _CharT, class _Traits, class _Allocator> |
3776 | typename basic_string<_CharT, _Traits, _Allocator>::size_type |
3777 | basic_string<_CharT, _Traits, _Allocator>::find_first_not_of(const value_type* __s, |
3778 | size_type __pos, |
3779 | size_type __n) const _NOEXCEPTnoexcept |
3780 | { |
3781 | _LIBCPP_ASSERT(__n == 0 || __s != nullptr, "string::find_first_not_of(): received nullptr")((void)0); |
3782 | return __str_find_first_not_of<value_type, size_type, traits_type, npos> |
3783 | (data(), size(), __s, __pos, __n); |
3784 | } |
3785 | |
3786 | template<class _CharT, class _Traits, class _Allocator> |
3787 | inline |
3788 | typename basic_string<_CharT, _Traits, _Allocator>::size_type |
3789 | basic_string<_CharT, _Traits, _Allocator>::find_first_not_of(const basic_string& __str, |
3790 | size_type __pos) const _NOEXCEPTnoexcept |
3791 | { |
3792 | return __str_find_first_not_of<value_type, size_type, traits_type, npos> |
3793 | (data(), size(), __str.data(), __pos, __str.size()); |
3794 | } |
3795 | |
3796 | template<class _CharT, class _Traits, class _Allocator> |
3797 | template <class _Tp> |
3798 | _EnableIf |
3799 | < |
3800 | __can_be_converted_to_string_view<_CharT, _Traits, _Tp>::value, |
3801 | typename basic_string<_CharT, _Traits, _Allocator>::size_type |
3802 | > |
3803 | basic_string<_CharT, _Traits, _Allocator>::find_first_not_of(const _Tp& __t, |
3804 | size_type __pos) const _NOEXCEPTnoexcept |
3805 | { |
3806 | __self_view __sv = __t; |
3807 | return __str_find_first_not_of<value_type, size_type, traits_type, npos> |
3808 | (data(), size(), __sv.data(), __pos, __sv.size()); |
3809 | } |
3810 | |
3811 | template<class _CharT, class _Traits, class _Allocator> |
3812 | inline |
3813 | typename basic_string<_CharT, _Traits, _Allocator>::size_type |
3814 | basic_string<_CharT, _Traits, _Allocator>::find_first_not_of(const value_type* __s, |
3815 | size_type __pos) const _NOEXCEPTnoexcept |
3816 | { |
3817 | _LIBCPP_ASSERT(__s != nullptr, "string::find_first_not_of(): received nullptr")((void)0); |
3818 | return __str_find_first_not_of<value_type, size_type, traits_type, npos> |
3819 | (data(), size(), __s, __pos, traits_type::length(__s)); |
3820 | } |
3821 | |
3822 | template<class _CharT, class _Traits, class _Allocator> |
3823 | inline |
3824 | typename basic_string<_CharT, _Traits, _Allocator>::size_type |
3825 | basic_string<_CharT, _Traits, _Allocator>::find_first_not_of(value_type __c, |
3826 | size_type __pos) const _NOEXCEPTnoexcept |
3827 | { |
3828 | return __str_find_first_not_of<value_type, size_type, traits_type, npos> |
3829 | (data(), size(), __c, __pos); |
3830 | } |
3831 | |
3832 | // find_last_not_of |
3833 | |
3834 | template<class _CharT, class _Traits, class _Allocator> |
3835 | typename basic_string<_CharT, _Traits, _Allocator>::size_type |
3836 | basic_string<_CharT, _Traits, _Allocator>::find_last_not_of(const value_type* __s, |
3837 | size_type __pos, |
3838 | size_type __n) const _NOEXCEPTnoexcept |
3839 | { |
3840 | _LIBCPP_ASSERT(__n == 0 || __s != nullptr, "string::find_last_not_of(): received nullptr")((void)0); |
3841 | return __str_find_last_not_of<value_type, size_type, traits_type, npos> |
3842 | (data(), size(), __s, __pos, __n); |
3843 | } |
3844 | |
3845 | template<class _CharT, class _Traits, class _Allocator> |
3846 | inline |
3847 | typename basic_string<_CharT, _Traits, _Allocator>::size_type |
3848 | basic_string<_CharT, _Traits, _Allocator>::find_last_not_of(const basic_string& __str, |
3849 | size_type __pos) const _NOEXCEPTnoexcept |
3850 | { |
3851 | return __str_find_last_not_of<value_type, size_type, traits_type, npos> |
3852 | (data(), size(), __str.data(), __pos, __str.size()); |
3853 | } |
3854 | |
3855 | template<class _CharT, class _Traits, class _Allocator> |
3856 | template <class _Tp> |
3857 | _EnableIf |
3858 | < |
3859 | __can_be_converted_to_string_view<_CharT, _Traits, _Tp>::value, |
3860 | typename basic_string<_CharT, _Traits, _Allocator>::size_type |
3861 | > |
3862 | basic_string<_CharT, _Traits, _Allocator>::find_last_not_of(const _Tp& __t, |
3863 | size_type __pos) const _NOEXCEPTnoexcept |
3864 | { |
3865 | __self_view __sv = __t; |
3866 | return __str_find_last_not_of<value_type, size_type, traits_type, npos> |
3867 | (data(), size(), __sv.data(), __pos, __sv.size()); |
3868 | } |
3869 | |
3870 | template<class _CharT, class _Traits, class _Allocator> |
3871 | inline |
3872 | typename basic_string<_CharT, _Traits, _Allocator>::size_type |
3873 | basic_string<_CharT, _Traits, _Allocator>::find_last_not_of(const value_type* __s, |
3874 | size_type __pos) const _NOEXCEPTnoexcept |
3875 | { |
3876 | _LIBCPP_ASSERT(__s != nullptr, "string::find_last_not_of(): received nullptr")((void)0); |
3877 | return __str_find_last_not_of<value_type, size_type, traits_type, npos> |
3878 | (data(), size(), __s, __pos, traits_type::length(__s)); |
3879 | } |
3880 | |
3881 | template<class _CharT, class _Traits, class _Allocator> |
3882 | inline |
3883 | typename basic_string<_CharT, _Traits, _Allocator>::size_type |
3884 | basic_string<_CharT, _Traits, _Allocator>::find_last_not_of(value_type __c, |
3885 | size_type __pos) const _NOEXCEPTnoexcept |
3886 | { |
3887 | return __str_find_last_not_of<value_type, size_type, traits_type, npos> |
3888 | (data(), size(), __c, __pos); |
3889 | } |
3890 | |
3891 | // compare |
3892 | |
3893 | template <class _CharT, class _Traits, class _Allocator> |
3894 | template <class _Tp> |
3895 | _EnableIf |
3896 | < |
3897 | __can_be_converted_to_string_view<_CharT, _Traits, _Tp>::value, |
3898 | int |
3899 | > |
3900 | basic_string<_CharT, _Traits, _Allocator>::compare(const _Tp& __t) const _NOEXCEPTnoexcept |
3901 | { |
3902 | __self_view __sv = __t; |
3903 | size_t __lhs_sz = size(); |
3904 | size_t __rhs_sz = __sv.size(); |
3905 | int __result = traits_type::compare(data(), __sv.data(), |
3906 | _VSTDstd::__1::min(__lhs_sz, __rhs_sz)); |
3907 | if (__result != 0) |
3908 | return __result; |
3909 | if (__lhs_sz < __rhs_sz) |
3910 | return -1; |
3911 | if (__lhs_sz > __rhs_sz) |
3912 | return 1; |
3913 | return 0; |
3914 | } |
3915 | |
3916 | template <class _CharT, class _Traits, class _Allocator> |
3917 | inline |
3918 | int |
3919 | basic_string<_CharT, _Traits, _Allocator>::compare(const basic_string& __str) const _NOEXCEPTnoexcept |
3920 | { |
3921 | return compare(__self_view(__str)); |
3922 | } |
3923 | |
3924 | template <class _CharT, class _Traits, class _Allocator> |
3925 | int |
3926 | basic_string<_CharT, _Traits, _Allocator>::compare(size_type __pos1, |
3927 | size_type __n1, |
3928 | const value_type* __s, |
3929 | size_type __n2) const |
3930 | { |
3931 | _LIBCPP_ASSERT(__n2 == 0 || __s != nullptr, "string::compare(): received nullptr")((void)0); |
3932 | size_type __sz = size(); |
3933 | if (__pos1 > __sz || __n2 == npos) |
3934 | this->__throw_out_of_range(); |
3935 | size_type __rlen = _VSTDstd::__1::min(__n1, __sz - __pos1); |
3936 | int __r = traits_type::compare(data() + __pos1, __s, _VSTDstd::__1::min(__rlen, __n2)); |
3937 | if (__r == 0) |
3938 | { |
3939 | if (__rlen < __n2) |
3940 | __r = -1; |
3941 | else if (__rlen > __n2) |
3942 | __r = 1; |
3943 | } |
3944 | return __r; |
3945 | } |
3946 | |
3947 | template <class _CharT, class _Traits, class _Allocator> |
3948 | template <class _Tp> |
3949 | _EnableIf |
3950 | < |
3951 | __can_be_converted_to_string_view<_CharT, _Traits, _Tp>::value, |
3952 | int |
3953 | > |
3954 | basic_string<_CharT, _Traits, _Allocator>::compare(size_type __pos1, |
3955 | size_type __n1, |
3956 | const _Tp& __t) const |
3957 | { |
3958 | __self_view __sv = __t; |
3959 | return compare(__pos1, __n1, __sv.data(), __sv.size()); |
3960 | } |
3961 | |
3962 | template <class _CharT, class _Traits, class _Allocator> |
3963 | inline |
3964 | int |
3965 | basic_string<_CharT, _Traits, _Allocator>::compare(size_type __pos1, |
3966 | size_type __n1, |
3967 | const basic_string& __str) const |
3968 | { |
3969 | return compare(__pos1, __n1, __str.data(), __str.size()); |
3970 | } |
3971 | |
3972 | template <class _CharT, class _Traits, class _Allocator> |
3973 | template <class _Tp> |
3974 | _EnableIf |
3975 | < |
3976 | __can_be_converted_to_string_view<_CharT, _Traits, _Tp>::value |
3977 | && !__is_same_uncvref<_Tp, basic_string<_CharT, _Traits, _Allocator> >::value, |
3978 | int |
3979 | > |
3980 | basic_string<_CharT, _Traits, _Allocator>::compare(size_type __pos1, |
3981 | size_type __n1, |
3982 | const _Tp& __t, |
3983 | size_type __pos2, |
3984 | size_type __n2) const |
3985 | { |
3986 | __self_view __sv = __t; |
3987 | return __self_view(*this).substr(__pos1, __n1).compare(__sv.substr(__pos2, __n2)); |
3988 | } |
3989 | |
3990 | template <class _CharT, class _Traits, class _Allocator> |
3991 | int |
3992 | basic_string<_CharT, _Traits, _Allocator>::compare(size_type __pos1, |
3993 | size_type __n1, |
3994 | const basic_string& __str, |
3995 | size_type __pos2, |
3996 | size_type __n2) const |
3997 | { |
3998 | return compare(__pos1, __n1, __self_view(__str), __pos2, __n2); |
3999 | } |
4000 | |
4001 | template <class _CharT, class _Traits, class _Allocator> |
4002 | int |
4003 | basic_string<_CharT, _Traits, _Allocator>::compare(const value_type* __s) const _NOEXCEPTnoexcept |
4004 | { |
4005 | _LIBCPP_ASSERT(__s != nullptr, "string::compare(): received nullptr")((void)0); |
4006 | return compare(0, npos, __s, traits_type::length(__s)); |
4007 | } |
4008 | |
4009 | template <class _CharT, class _Traits, class _Allocator> |
4010 | int |
4011 | basic_string<_CharT, _Traits, _Allocator>::compare(size_type __pos1, |
4012 | size_type __n1, |
4013 | const value_type* __s) const |
4014 | { |
4015 | _LIBCPP_ASSERT(__s != nullptr, "string::compare(): received nullptr")((void)0); |
4016 | return compare(__pos1, __n1, __s, traits_type::length(__s)); |
4017 | } |
4018 | |
4019 | // __invariants |
4020 | |
4021 | template<class _CharT, class _Traits, class _Allocator> |
4022 | inline |
4023 | bool |
4024 | basic_string<_CharT, _Traits, _Allocator>::__invariants() const |
4025 | { |
4026 | if (size() > capacity()) |
4027 | return false; |
4028 | if (capacity() < __min_cap - 1) |
4029 | return false; |
4030 | if (data() == nullptr) |
4031 | return false; |
4032 | if (data()[size()] != value_type()) |
4033 | return false; |
4034 | return true; |
4035 | } |
4036 | |
4037 | // __clear_and_shrink |
4038 | |
4039 | template<class _CharT, class _Traits, class _Allocator> |
4040 | inline |
4041 | void |
4042 | basic_string<_CharT, _Traits, _Allocator>::__clear_and_shrink() _NOEXCEPTnoexcept |
4043 | { |
4044 | clear(); |
4045 | if(__is_long()) |
4046 | { |
4047 | __alloc_traits::deallocate(__alloc(), __get_long_pointer(), capacity() + 1); |
4048 | __set_long_cap(0); |
4049 | __set_short_size(0); |
4050 | traits_type::assign(*__get_short_pointer(), value_type()); |
4051 | } |
4052 | } |
4053 | |
4054 | // operator== |
4055 | |
4056 | template<class _CharT, class _Traits, class _Allocator> |
4057 | inline _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__ )) |
4058 | bool |
4059 | operator==(const basic_string<_CharT, _Traits, _Allocator>& __lhs, |
4060 | const basic_string<_CharT, _Traits, _Allocator>& __rhs) _NOEXCEPTnoexcept |
4061 | { |
4062 | size_t __lhs_sz = __lhs.size(); |
4063 | return __lhs_sz == __rhs.size() && _Traits::compare(__lhs.data(), |
4064 | __rhs.data(), |
4065 | __lhs_sz) == 0; |
4066 | } |
4067 | |
4068 | template<class _Allocator> |
4069 | inline _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__ )) |
4070 | bool |
4071 | operator==(const basic_string<char, char_traits<char>, _Allocator>& __lhs, |
4072 | const basic_string<char, char_traits<char>, _Allocator>& __rhs) _NOEXCEPTnoexcept |
4073 | { |
4074 | size_t __lhs_sz = __lhs.size(); |
4075 | if (__lhs_sz != __rhs.size()) |
4076 | return false; |
4077 | const char* __lp = __lhs.data(); |
4078 | const char* __rp = __rhs.data(); |
4079 | if (__lhs.__is_long()) |
4080 | return char_traits<char>::compare(__lp, __rp, __lhs_sz) == 0; |
4081 | for (; __lhs_sz != 0; --__lhs_sz, ++__lp, ++__rp) |
4082 | if (*__lp != *__rp) |
4083 | return false; |
4084 | return true; |
4085 | } |
4086 | |
4087 | template<class _CharT, class _Traits, class _Allocator> |
4088 | inline _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__ )) |
4089 | bool |
4090 | operator==(const _CharT* __lhs, |
4091 | const basic_string<_CharT, _Traits, _Allocator>& __rhs) _NOEXCEPTnoexcept |
4092 | { |
4093 | typedef basic_string<_CharT, _Traits, _Allocator> _String; |
4094 | _LIBCPP_ASSERT(__lhs != nullptr, "operator==(char*, basic_string): received nullptr")((void)0); |
4095 | size_t __lhs_len = _Traits::length(__lhs); |
4096 | if (__lhs_len != __rhs.size()) return false; |
4097 | return __rhs.compare(0, _String::npos, __lhs, __lhs_len) == 0; |
4098 | } |
4099 | |
4100 | template<class _CharT, class _Traits, class _Allocator> |
4101 | inline _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__ )) |
4102 | bool |
4103 | operator==(const basic_string<_CharT,_Traits,_Allocator>& __lhs, |
4104 | const _CharT* __rhs) _NOEXCEPTnoexcept |
4105 | { |
4106 | typedef basic_string<_CharT, _Traits, _Allocator> _String; |
4107 | _LIBCPP_ASSERT(__rhs != nullptr, "operator==(basic_string, char*): received nullptr")((void)0); |
4108 | size_t __rhs_len = _Traits::length(__rhs); |
4109 | if (__rhs_len != __lhs.size()) return false; |
4110 | return __lhs.compare(0, _String::npos, __rhs, __rhs_len) == 0; |
4111 | } |
4112 | |
4113 | template<class _CharT, class _Traits, class _Allocator> |
4114 | inline _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__ )) |
4115 | bool |
4116 | operator!=(const basic_string<_CharT,_Traits,_Allocator>& __lhs, |
4117 | const basic_string<_CharT, _Traits, _Allocator>& __rhs) _NOEXCEPTnoexcept |
4118 | { |
4119 | return !(__lhs == __rhs); |
4120 | } |
4121 | |
4122 | template<class _CharT, class _Traits, class _Allocator> |
4123 | inline _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__ )) |
4124 | bool |
4125 | operator!=(const _CharT* __lhs, |
4126 | const basic_string<_CharT, _Traits, _Allocator>& __rhs) _NOEXCEPTnoexcept |
4127 | { |
4128 | return !(__lhs == __rhs); |
4129 | } |
4130 | |
4131 | template<class _CharT, class _Traits, class _Allocator> |
4132 | inline _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__ )) |
4133 | bool |
4134 | operator!=(const basic_string<_CharT, _Traits, _Allocator>& __lhs, |
4135 | const _CharT* __rhs) _NOEXCEPTnoexcept |
4136 | { |
4137 | return !(__lhs == __rhs); |
4138 | } |
4139 | |
4140 | // operator< |
4141 | |
4142 | template<class _CharT, class _Traits, class _Allocator> |
4143 | inline _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__ )) |
4144 | bool |
4145 | operator< (const basic_string<_CharT, _Traits, _Allocator>& __lhs, |
4146 | const basic_string<_CharT, _Traits, _Allocator>& __rhs) _NOEXCEPTnoexcept |
4147 | { |
4148 | return __lhs.compare(__rhs) < 0; |
4149 | } |
4150 | |
4151 | template<class _CharT, class _Traits, class _Allocator> |
4152 | inline _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__ )) |
4153 | bool |
4154 | operator< (const basic_string<_CharT, _Traits, _Allocator>& __lhs, |
4155 | const _CharT* __rhs) _NOEXCEPTnoexcept |
4156 | { |
4157 | return __lhs.compare(__rhs) < 0; |
4158 | } |
4159 | |
4160 | template<class _CharT, class _Traits, class _Allocator> |
4161 | inline _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__ )) |
4162 | bool |
4163 | operator< (const _CharT* __lhs, |
4164 | const basic_string<_CharT, _Traits, _Allocator>& __rhs) _NOEXCEPTnoexcept |
4165 | { |
4166 | return __rhs.compare(__lhs) > 0; |
4167 | } |
4168 | |
4169 | // operator> |
4170 | |
4171 | template<class _CharT, class _Traits, class _Allocator> |
4172 | inline _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__ )) |
4173 | bool |
4174 | operator> (const basic_string<_CharT, _Traits, _Allocator>& __lhs, |
4175 | const basic_string<_CharT, _Traits, _Allocator>& __rhs) _NOEXCEPTnoexcept |
4176 | { |
4177 | return __rhs < __lhs; |
4178 | } |
4179 | |
4180 | template<class _CharT, class _Traits, class _Allocator> |
4181 | inline _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__ )) |
4182 | bool |
4183 | operator> (const basic_string<_CharT, _Traits, _Allocator>& __lhs, |
4184 | const _CharT* __rhs) _NOEXCEPTnoexcept |
4185 | { |
4186 | return __rhs < __lhs; |
4187 | } |
4188 | |
4189 | template<class _CharT, class _Traits, class _Allocator> |
4190 | inline _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__ )) |
4191 | bool |
4192 | operator> (const _CharT* __lhs, |
4193 | const basic_string<_CharT, _Traits, _Allocator>& __rhs) _NOEXCEPTnoexcept |
4194 | { |
4195 | return __rhs < __lhs; |
4196 | } |
4197 | |
4198 | // operator<= |
4199 | |
4200 | template<class _CharT, class _Traits, class _Allocator> |
4201 | inline _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__ )) |
4202 | bool |
4203 | operator<=(const basic_string<_CharT, _Traits, _Allocator>& __lhs, |
4204 | const basic_string<_CharT, _Traits, _Allocator>& __rhs) _NOEXCEPTnoexcept |
4205 | { |
4206 | return !(__rhs < __lhs); |
4207 | } |
4208 | |
4209 | template<class _CharT, class _Traits, class _Allocator> |
4210 | inline _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__ )) |
4211 | bool |
4212 | operator<=(const basic_string<_CharT, _Traits, _Allocator>& __lhs, |
4213 | const _CharT* __rhs) _NOEXCEPTnoexcept |
4214 | { |
4215 | return !(__rhs < __lhs); |
4216 | } |
4217 | |
4218 | template<class _CharT, class _Traits, class _Allocator> |
4219 | inline _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__ )) |
4220 | bool |
4221 | operator<=(const _CharT* __lhs, |
4222 | const basic_string<_CharT, _Traits, _Allocator>& __rhs) _NOEXCEPTnoexcept |
4223 | { |
4224 | return !(__rhs < __lhs); |
4225 | } |
4226 | |
4227 | // operator>= |
4228 | |
4229 | template<class _CharT, class _Traits, class _Allocator> |
4230 | inline _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__ )) |
4231 | bool |
4232 | operator>=(const basic_string<_CharT, _Traits, _Allocator>& __lhs, |
4233 | const basic_string<_CharT, _Traits, _Allocator>& __rhs) _NOEXCEPTnoexcept |
4234 | { |
4235 | return !(__lhs < __rhs); |
4236 | } |
4237 | |
4238 | template<class _CharT, class _Traits, class _Allocator> |
4239 | inline _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__ )) |
4240 | bool |
4241 | operator>=(const basic_string<_CharT, _Traits, _Allocator>& __lhs, |
4242 | const _CharT* __rhs) _NOEXCEPTnoexcept |
4243 | { |
4244 | return !(__lhs < __rhs); |
4245 | } |
4246 | |
4247 | template<class _CharT, class _Traits, class _Allocator> |
4248 | inline _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__ )) |
4249 | bool |
4250 | operator>=(const _CharT* __lhs, |
4251 | const basic_string<_CharT, _Traits, _Allocator>& __rhs) _NOEXCEPTnoexcept |
4252 | { |
4253 | return !(__lhs < __rhs); |
4254 | } |
4255 | |
4256 | // operator + |
4257 | |
4258 | template<class _CharT, class _Traits, class _Allocator> |
4259 | basic_string<_CharT, _Traits, _Allocator> |
4260 | operator+(const basic_string<_CharT, _Traits, _Allocator>& __lhs, |
4261 | const basic_string<_CharT, _Traits, _Allocator>& __rhs) |
4262 | { |
4263 | basic_string<_CharT, _Traits, _Allocator> __r(__lhs.get_allocator()); |
4264 | typename basic_string<_CharT, _Traits, _Allocator>::size_type __lhs_sz = __lhs.size(); |
4265 | typename basic_string<_CharT, _Traits, _Allocator>::size_type __rhs_sz = __rhs.size(); |
4266 | __r.__init(__lhs.data(), __lhs_sz, __lhs_sz + __rhs_sz); |
4267 | __r.append(__rhs.data(), __rhs_sz); |
4268 | return __r; |
4269 | } |
4270 | |
4271 | template<class _CharT, class _Traits, class _Allocator> |
4272 | basic_string<_CharT, _Traits, _Allocator> |
4273 | operator+(const _CharT* __lhs , const basic_string<_CharT,_Traits,_Allocator>& __rhs) |
4274 | { |
4275 | basic_string<_CharT, _Traits, _Allocator> __r(__rhs.get_allocator()); |
4276 | typename basic_string<_CharT, _Traits, _Allocator>::size_type __lhs_sz = _Traits::length(__lhs); |
4277 | typename basic_string<_CharT, _Traits, _Allocator>::size_type __rhs_sz = __rhs.size(); |
4278 | __r.__init(__lhs, __lhs_sz, __lhs_sz + __rhs_sz); |
4279 | __r.append(__rhs.data(), __rhs_sz); |
4280 | return __r; |
4281 | } |
4282 | |
4283 | template<class _CharT, class _Traits, class _Allocator> |
4284 | basic_string<_CharT, _Traits, _Allocator> |
4285 | operator+(_CharT __lhs, const basic_string<_CharT,_Traits,_Allocator>& __rhs) |
4286 | { |
4287 | basic_string<_CharT, _Traits, _Allocator> __r(__rhs.get_allocator()); |
4288 | typename basic_string<_CharT, _Traits, _Allocator>::size_type __rhs_sz = __rhs.size(); |
4289 | __r.__init(&__lhs, 1, 1 + __rhs_sz); |
4290 | __r.append(__rhs.data(), __rhs_sz); |
4291 | return __r; |
4292 | } |
4293 | |
4294 | template<class _CharT, class _Traits, class _Allocator> |
4295 | inline |
4296 | basic_string<_CharT, _Traits, _Allocator> |
4297 | operator+(const basic_string<_CharT, _Traits, _Allocator>& __lhs, const _CharT* __rhs) |
4298 | { |
4299 | basic_string<_CharT, _Traits, _Allocator> __r(__lhs.get_allocator()); |
4300 | typename basic_string<_CharT, _Traits, _Allocator>::size_type __lhs_sz = __lhs.size(); |
4301 | typename basic_string<_CharT, _Traits, _Allocator>::size_type __rhs_sz = _Traits::length(__rhs); |
4302 | __r.__init(__lhs.data(), __lhs_sz, __lhs_sz + __rhs_sz); |
4303 | __r.append(__rhs, __rhs_sz); |
4304 | return __r; |
4305 | } |
4306 | |
4307 | template<class _CharT, class _Traits, class _Allocator> |
4308 | basic_string<_CharT, _Traits, _Allocator> |
4309 | operator+(const basic_string<_CharT, _Traits, _Allocator>& __lhs, _CharT __rhs) |
4310 | { |
4311 | basic_string<_CharT, _Traits, _Allocator> __r(__lhs.get_allocator()); |
4312 | typename basic_string<_CharT, _Traits, _Allocator>::size_type __lhs_sz = __lhs.size(); |
4313 | __r.__init(__lhs.data(), __lhs_sz, __lhs_sz + 1); |
4314 | __r.push_back(__rhs); |
4315 | return __r; |
4316 | } |
4317 | |
4318 | #ifndef _LIBCPP_CXX03_LANG |
4319 | |
4320 | template<class _CharT, class _Traits, class _Allocator> |
4321 | inline _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__ )) |
4322 | basic_string<_CharT, _Traits, _Allocator> |
4323 | operator+(basic_string<_CharT, _Traits, _Allocator>&& __lhs, const basic_string<_CharT, _Traits, _Allocator>& __rhs) |
4324 | { |
4325 | return _VSTDstd::__1::move(__lhs.append(__rhs)); |
4326 | } |
4327 | |
4328 | template<class _CharT, class _Traits, class _Allocator> |
4329 | inline _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__ )) |
4330 | basic_string<_CharT, _Traits, _Allocator> |
4331 | operator+(const basic_string<_CharT, _Traits, _Allocator>& __lhs, basic_string<_CharT, _Traits, _Allocator>&& __rhs) |
4332 | { |
4333 | return _VSTDstd::__1::move(__rhs.insert(0, __lhs)); |
4334 | } |
4335 | |
4336 | template<class _CharT, class _Traits, class _Allocator> |
4337 | inline _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__ )) |
4338 | basic_string<_CharT, _Traits, _Allocator> |
4339 | operator+(basic_string<_CharT, _Traits, _Allocator>&& __lhs, basic_string<_CharT, _Traits, _Allocator>&& __rhs) |
4340 | { |
4341 | return _VSTDstd::__1::move(__lhs.append(__rhs)); |
4342 | } |
4343 | |
4344 | template<class _CharT, class _Traits, class _Allocator> |
4345 | inline _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__ )) |
4346 | basic_string<_CharT, _Traits, _Allocator> |
4347 | operator+(const _CharT* __lhs , basic_string<_CharT,_Traits,_Allocator>&& __rhs) |
4348 | { |
4349 | return _VSTDstd::__1::move(__rhs.insert(0, __lhs)); |
4350 | } |
4351 | |
4352 | template<class _CharT, class _Traits, class _Allocator> |
4353 | inline _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__ )) |
4354 | basic_string<_CharT, _Traits, _Allocator> |
4355 | operator+(_CharT __lhs, basic_string<_CharT,_Traits,_Allocator>&& __rhs) |
4356 | { |
4357 | __rhs.insert(__rhs.begin(), __lhs); |
4358 | return _VSTDstd::__1::move(__rhs); |
4359 | } |
4360 | |
4361 | template<class _CharT, class _Traits, class _Allocator> |
4362 | inline _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__ )) |
4363 | basic_string<_CharT, _Traits, _Allocator> |
4364 | operator+(basic_string<_CharT, _Traits, _Allocator>&& __lhs, const _CharT* __rhs) |
4365 | { |
4366 | return _VSTDstd::__1::move(__lhs.append(__rhs)); |
4367 | } |
4368 | |
4369 | template<class _CharT, class _Traits, class _Allocator> |
4370 | inline _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__ )) |
4371 | basic_string<_CharT, _Traits, _Allocator> |
4372 | operator+(basic_string<_CharT, _Traits, _Allocator>&& __lhs, _CharT __rhs) |
4373 | { |
4374 | __lhs.push_back(__rhs); |
4375 | return _VSTDstd::__1::move(__lhs); |
4376 | } |
4377 | |
4378 | #endif // _LIBCPP_CXX03_LANG |
4379 | |
4380 | // swap |
4381 | |
4382 | template<class _CharT, class _Traits, class _Allocator> |
4383 | inline _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__ )) |
4384 | void |
4385 | swap(basic_string<_CharT, _Traits, _Allocator>& __lhs, |
4386 | basic_string<_CharT, _Traits, _Allocator>& __rhs) |
4387 | _NOEXCEPT_(_NOEXCEPT_(__lhs.swap(__rhs)))noexcept(noexcept(__lhs.swap(__rhs))) |
4388 | { |
4389 | __lhs.swap(__rhs); |
4390 | } |
4391 | |
4392 | _LIBCPP_FUNC_VIS__attribute__ ((__visibility__("default"))) int stoi (const string& __str, size_t* __idx = nullptr, int __base = 10); |
4393 | _LIBCPP_FUNC_VIS__attribute__ ((__visibility__("default"))) long stol (const string& __str, size_t* __idx = nullptr, int __base = 10); |
4394 | _LIBCPP_FUNC_VIS__attribute__ ((__visibility__("default"))) unsigned long stoul (const string& __str, size_t* __idx = nullptr, int __base = 10); |
4395 | _LIBCPP_FUNC_VIS__attribute__ ((__visibility__("default"))) long long stoll (const string& __str, size_t* __idx = nullptr, int __base = 10); |
4396 | _LIBCPP_FUNC_VIS__attribute__ ((__visibility__("default"))) unsigned long long stoull(const string& __str, size_t* __idx = nullptr, int __base = 10); |
4397 | |
4398 | _LIBCPP_FUNC_VIS__attribute__ ((__visibility__("default"))) float stof (const string& __str, size_t* __idx = nullptr); |
4399 | _LIBCPP_FUNC_VIS__attribute__ ((__visibility__("default"))) double stod (const string& __str, size_t* __idx = nullptr); |
4400 | _LIBCPP_FUNC_VIS__attribute__ ((__visibility__("default"))) long double stold(const string& __str, size_t* __idx = nullptr); |
4401 | |
4402 | _LIBCPP_FUNC_VIS__attribute__ ((__visibility__("default"))) string to_string(int __val); |
4403 | _LIBCPP_FUNC_VIS__attribute__ ((__visibility__("default"))) string to_string(unsigned __val); |
4404 | _LIBCPP_FUNC_VIS__attribute__ ((__visibility__("default"))) string to_string(long __val); |
4405 | _LIBCPP_FUNC_VIS__attribute__ ((__visibility__("default"))) string to_string(unsigned long __val); |
4406 | _LIBCPP_FUNC_VIS__attribute__ ((__visibility__("default"))) string to_string(long long __val); |
4407 | _LIBCPP_FUNC_VIS__attribute__ ((__visibility__("default"))) string to_string(unsigned long long __val); |
4408 | _LIBCPP_FUNC_VIS__attribute__ ((__visibility__("default"))) string to_string(float __val); |
4409 | _LIBCPP_FUNC_VIS__attribute__ ((__visibility__("default"))) string to_string(double __val); |
4410 | _LIBCPP_FUNC_VIS__attribute__ ((__visibility__("default"))) string to_string(long double __val); |
4411 | |
4412 | _LIBCPP_FUNC_VIS__attribute__ ((__visibility__("default"))) int stoi (const wstring& __str, size_t* __idx = nullptr, int __base = 10); |
4413 | _LIBCPP_FUNC_VIS__attribute__ ((__visibility__("default"))) long stol (const wstring& __str, size_t* __idx = nullptr, int __base = 10); |
4414 | _LIBCPP_FUNC_VIS__attribute__ ((__visibility__("default"))) unsigned long stoul (const wstring& __str, size_t* __idx = nullptr, int __base = 10); |
4415 | _LIBCPP_FUNC_VIS__attribute__ ((__visibility__("default"))) long long stoll (const wstring& __str, size_t* __idx = nullptr, int __base = 10); |
4416 | _LIBCPP_FUNC_VIS__attribute__ ((__visibility__("default"))) unsigned long long stoull(const wstring& __str, size_t* __idx = nullptr, int __base = 10); |
4417 | |
4418 | _LIBCPP_FUNC_VIS__attribute__ ((__visibility__("default"))) float stof (const wstring& __str, size_t* __idx = nullptr); |
4419 | _LIBCPP_FUNC_VIS__attribute__ ((__visibility__("default"))) double stod (const wstring& __str, size_t* __idx = nullptr); |
4420 | _LIBCPP_FUNC_VIS__attribute__ ((__visibility__("default"))) long double stold(const wstring& __str, size_t* __idx = nullptr); |
4421 | |
4422 | _LIBCPP_FUNC_VIS__attribute__ ((__visibility__("default"))) wstring to_wstring(int __val); |
4423 | _LIBCPP_FUNC_VIS__attribute__ ((__visibility__("default"))) wstring to_wstring(unsigned __val); |
4424 | _LIBCPP_FUNC_VIS__attribute__ ((__visibility__("default"))) wstring to_wstring(long __val); |
4425 | _LIBCPP_FUNC_VIS__attribute__ ((__visibility__("default"))) wstring to_wstring(unsigned long __val); |
4426 | _LIBCPP_FUNC_VIS__attribute__ ((__visibility__("default"))) wstring to_wstring(long long __val); |
4427 | _LIBCPP_FUNC_VIS__attribute__ ((__visibility__("default"))) wstring to_wstring(unsigned long long __val); |
4428 | _LIBCPP_FUNC_VIS__attribute__ ((__visibility__("default"))) wstring to_wstring(float __val); |
4429 | _LIBCPP_FUNC_VIS__attribute__ ((__visibility__("default"))) wstring to_wstring(double __val); |
4430 | _LIBCPP_FUNC_VIS__attribute__ ((__visibility__("default"))) wstring to_wstring(long double __val); |
4431 | |
4432 | template<class _CharT, class _Traits, class _Allocator> |
4433 | _LIBCPP_TEMPLATE_DATA_VIS__attribute__ ((__visibility__("default"))) |
4434 | const typename basic_string<_CharT, _Traits, _Allocator>::size_type |
4435 | basic_string<_CharT, _Traits, _Allocator>::npos; |
4436 | |
4437 | template <class _CharT, class _Allocator> |
4438 | struct _LIBCPP_TEMPLATE_VIS__attribute__ ((__type_visibility__("default"))) |
4439 | hash<basic_string<_CharT, char_traits<_CharT>, _Allocator> > |
4440 | : public unary_function< |
4441 | basic_string<_CharT, char_traits<_CharT>, _Allocator>, size_t> |
4442 | { |
4443 | size_t |
4444 | operator()(const basic_string<_CharT, char_traits<_CharT>, _Allocator>& __val) const _NOEXCEPTnoexcept |
4445 | { return __do_string_hash(__val.data(), __val.data() + __val.size()); } |
4446 | }; |
4447 | |
4448 | |
4449 | template<class _CharT, class _Traits, class _Allocator> |
4450 | basic_ostream<_CharT, _Traits>& |
4451 | operator<<(basic_ostream<_CharT, _Traits>& __os, |
4452 | const basic_string<_CharT, _Traits, _Allocator>& __str); |
4453 | |
4454 | template<class _CharT, class _Traits, class _Allocator> |
4455 | basic_istream<_CharT, _Traits>& |
4456 | operator>>(basic_istream<_CharT, _Traits>& __is, |
4457 | basic_string<_CharT, _Traits, _Allocator>& __str); |
4458 | |
4459 | template<class _CharT, class _Traits, class _Allocator> |
4460 | basic_istream<_CharT, _Traits>& |
4461 | getline(basic_istream<_CharT, _Traits>& __is, |
4462 | basic_string<_CharT, _Traits, _Allocator>& __str, _CharT __dlm); |
4463 | |
4464 | template<class _CharT, class _Traits, class _Allocator> |
4465 | inline _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__ )) |
4466 | basic_istream<_CharT, _Traits>& |
4467 | getline(basic_istream<_CharT, _Traits>& __is, |
4468 | basic_string<_CharT, _Traits, _Allocator>& __str); |
4469 | |
4470 | template<class _CharT, class _Traits, class _Allocator> |
4471 | inline _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__ )) |
4472 | basic_istream<_CharT, _Traits>& |
4473 | getline(basic_istream<_CharT, _Traits>&& __is, |
4474 | basic_string<_CharT, _Traits, _Allocator>& __str, _CharT __dlm); |
4475 | |
4476 | template<class _CharT, class _Traits, class _Allocator> |
4477 | inline _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__ )) |
4478 | basic_istream<_CharT, _Traits>& |
4479 | getline(basic_istream<_CharT, _Traits>&& __is, |
4480 | basic_string<_CharT, _Traits, _Allocator>& __str); |
4481 | |
4482 | #if _LIBCPP_STD_VER14 > 17 |
4483 | template <class _CharT, class _Traits, class _Allocator, class _Up> |
4484 | inline _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__ )) |
4485 | typename basic_string<_CharT, _Traits, _Allocator>::size_type |
4486 | erase(basic_string<_CharT, _Traits, _Allocator>& __str, const _Up& __v) { |
4487 | auto __old_size = __str.size(); |
4488 | __str.erase(_VSTDstd::__1::remove(__str.begin(), __str.end(), __v), __str.end()); |
4489 | return __old_size - __str.size(); |
4490 | } |
4491 | |
4492 | template <class _CharT, class _Traits, class _Allocator, class _Predicate> |
4493 | inline _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__ )) |
4494 | typename basic_string<_CharT, _Traits, _Allocator>::size_type |
4495 | erase_if(basic_string<_CharT, _Traits, _Allocator>& __str, |
4496 | _Predicate __pred) { |
4497 | auto __old_size = __str.size(); |
4498 | __str.erase(_VSTDstd::__1::remove_if(__str.begin(), __str.end(), __pred), |
4499 | __str.end()); |
4500 | return __old_size - __str.size(); |
4501 | } |
4502 | #endif |
4503 | |
4504 | #if _LIBCPP_DEBUG_LEVEL0 == 2 |
4505 | |
4506 | template<class _CharT, class _Traits, class _Allocator> |
4507 | bool |
4508 | basic_string<_CharT, _Traits, _Allocator>::__dereferenceable(const const_iterator* __i) const |
4509 | { |
4510 | return this->data() <= _VSTDstd::__1::__to_address(__i->base()) && |
4511 | _VSTDstd::__1::__to_address(__i->base()) < this->data() + this->size(); |
4512 | } |
4513 | |
4514 | template<class _CharT, class _Traits, class _Allocator> |
4515 | bool |
4516 | basic_string<_CharT, _Traits, _Allocator>::__decrementable(const const_iterator* __i) const |
4517 | { |
4518 | return this->data() < _VSTDstd::__1::__to_address(__i->base()) && |
4519 | _VSTDstd::__1::__to_address(__i->base()) <= this->data() + this->size(); |
4520 | } |
4521 | |
4522 | template<class _CharT, class _Traits, class _Allocator> |
4523 | bool |
4524 | basic_string<_CharT, _Traits, _Allocator>::__addable(const const_iterator* __i, ptrdiff_t __n) const |
4525 | { |
4526 | const value_type* __p = _VSTDstd::__1::__to_address(__i->base()) + __n; |
4527 | return this->data() <= __p && __p <= this->data() + this->size(); |
4528 | } |
4529 | |
4530 | template<class _CharT, class _Traits, class _Allocator> |
4531 | bool |
4532 | basic_string<_CharT, _Traits, _Allocator>::__subscriptable(const const_iterator* __i, ptrdiff_t __n) const |
4533 | { |
4534 | const value_type* __p = _VSTDstd::__1::__to_address(__i->base()) + __n; |
4535 | return this->data() <= __p && __p < this->data() + this->size(); |
4536 | } |
4537 | |
4538 | #endif // _LIBCPP_DEBUG_LEVEL == 2 |
4539 | |
4540 | #if _LIBCPP_STD_VER14 > 11 |
4541 | // Literal suffixes for basic_string [basic.string.literals] |
4542 | inline namespace literals |
4543 | { |
4544 | inline namespace string_literals |
4545 | { |
4546 | inline _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__ )) |
4547 | basic_string<char> operator "" s( const char *__str, size_t __len ) |
4548 | { |
4549 | return basic_string<char> (__str, __len); |
4550 | } |
4551 | |
4552 | inline _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__ )) |
4553 | basic_string<wchar_t> operator "" s( const wchar_t *__str, size_t __len ) |
4554 | { |
4555 | return basic_string<wchar_t> (__str, __len); |
4556 | } |
4557 | |
4558 | #ifndef _LIBCPP_HAS_NO_CHAR8_T |
4559 | inline _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__ )) |
4560 | basic_string<char8_t> operator "" s(const char8_t *__str, size_t __len) _NOEXCEPTnoexcept |
4561 | { |
4562 | return basic_string<char8_t> (__str, __len); |
4563 | } |
4564 | #endif |
4565 | |
4566 | inline _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__ )) |
4567 | basic_string<char16_t> operator "" s( const char16_t *__str, size_t __len ) |
4568 | { |
4569 | return basic_string<char16_t> (__str, __len); |
4570 | } |
4571 | |
4572 | inline _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__ )) |
4573 | basic_string<char32_t> operator "" s( const char32_t *__str, size_t __len ) |
4574 | { |
4575 | return basic_string<char32_t> (__str, __len); |
4576 | } |
4577 | } |
4578 | } |
4579 | #endif |
4580 | |
4581 | _LIBCPP_END_NAMESPACE_STD} } |
4582 | |
4583 | _LIBCPP_POP_MACROSpop_macro("min") pop_macro("max") |
4584 | |
4585 | #endif // _LIBCPP_STRING |