annotate libcxx/include/fstream @ 150:1d019706d866

LLVM10
author anatofuz
date Thu, 13 Feb 2020 15:10:13 +0900 (2020-02-13)
parents
children 2e18cbf3894f
Ignore whitespace changes - Everywhere: Within whitespace: At end of lines:
rev   line source
150
anatofuz
parents:
diff changeset
1 // -*- C++ -*-
anatofuz
parents:
diff changeset
2 //===------------------------- fstream ------------------------------------===//
anatofuz
parents:
diff changeset
3 //
anatofuz
parents:
diff changeset
4 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
anatofuz
parents:
diff changeset
5 // See https://llvm.org/LICENSE.txt for license information.
anatofuz
parents:
diff changeset
6 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
anatofuz
parents:
diff changeset
7 //
anatofuz
parents:
diff changeset
8 //===----------------------------------------------------------------------===//
anatofuz
parents:
diff changeset
9
anatofuz
parents:
diff changeset
10 #ifndef _LIBCPP_FSTREAM
anatofuz
parents:
diff changeset
11 #define _LIBCPP_FSTREAM
anatofuz
parents:
diff changeset
12
anatofuz
parents:
diff changeset
13 /*
anatofuz
parents:
diff changeset
14 fstream synopsis
anatofuz
parents:
diff changeset
15
anatofuz
parents:
diff changeset
16 template <class charT, class traits = char_traits<charT> >
anatofuz
parents:
diff changeset
17 class basic_filebuf
anatofuz
parents:
diff changeset
18 : public basic_streambuf<charT, traits>
anatofuz
parents:
diff changeset
19 {
anatofuz
parents:
diff changeset
20 public:
anatofuz
parents:
diff changeset
21 typedef charT char_type;
anatofuz
parents:
diff changeset
22 typedef traits traits_type;
anatofuz
parents:
diff changeset
23 typedef typename traits_type::int_type int_type;
anatofuz
parents:
diff changeset
24 typedef typename traits_type::pos_type pos_type;
anatofuz
parents:
diff changeset
25 typedef typename traits_type::off_type off_type;
anatofuz
parents:
diff changeset
26
anatofuz
parents:
diff changeset
27 // 27.9.1.2 Constructors/destructor:
anatofuz
parents:
diff changeset
28 basic_filebuf();
anatofuz
parents:
diff changeset
29 basic_filebuf(basic_filebuf&& rhs);
anatofuz
parents:
diff changeset
30 virtual ~basic_filebuf();
anatofuz
parents:
diff changeset
31
anatofuz
parents:
diff changeset
32 // 27.9.1.3 Assign/swap:
anatofuz
parents:
diff changeset
33 basic_filebuf& operator=(basic_filebuf&& rhs);
anatofuz
parents:
diff changeset
34 void swap(basic_filebuf& rhs);
anatofuz
parents:
diff changeset
35
anatofuz
parents:
diff changeset
36 // 27.9.1.4 Members:
anatofuz
parents:
diff changeset
37 bool is_open() const;
anatofuz
parents:
diff changeset
38 basic_filebuf* open(const char* s, ios_base::openmode mode);
anatofuz
parents:
diff changeset
39 basic_filebuf* open(const string& s, ios_base::openmode mode);
anatofuz
parents:
diff changeset
40 basic_filebuf* open(const filesystem::path& p, ios_base::openmode mode); // C++17
anatofuz
parents:
diff changeset
41 basic_filebuf* close();
anatofuz
parents:
diff changeset
42
anatofuz
parents:
diff changeset
43 protected:
anatofuz
parents:
diff changeset
44 // 27.9.1.5 Overridden virtual functions:
anatofuz
parents:
diff changeset
45 virtual streamsize showmanyc();
anatofuz
parents:
diff changeset
46 virtual int_type underflow();
anatofuz
parents:
diff changeset
47 virtual int_type uflow();
anatofuz
parents:
diff changeset
48 virtual int_type pbackfail(int_type c = traits_type::eof());
anatofuz
parents:
diff changeset
49 virtual int_type overflow (int_type c = traits_type::eof());
anatofuz
parents:
diff changeset
50 virtual basic_streambuf<char_type, traits_type>* setbuf(char_type* s, streamsize n);
anatofuz
parents:
diff changeset
51 virtual pos_type seekoff(off_type off, ios_base::seekdir way,
anatofuz
parents:
diff changeset
52 ios_base::openmode which = ios_base::in | ios_base::out);
anatofuz
parents:
diff changeset
53 virtual pos_type seekpos(pos_type sp,
anatofuz
parents:
diff changeset
54 ios_base::openmode which = ios_base::in | ios_base::out);
anatofuz
parents:
diff changeset
55 virtual int sync();
anatofuz
parents:
diff changeset
56 virtual void imbue(const locale& loc);
anatofuz
parents:
diff changeset
57 };
anatofuz
parents:
diff changeset
58
anatofuz
parents:
diff changeset
59 template <class charT, class traits>
anatofuz
parents:
diff changeset
60 void
anatofuz
parents:
diff changeset
61 swap(basic_filebuf<charT, traits>& x, basic_filebuf<charT, traits>& y);
anatofuz
parents:
diff changeset
62
anatofuz
parents:
diff changeset
63 typedef basic_filebuf<char> filebuf;
anatofuz
parents:
diff changeset
64 typedef basic_filebuf<wchar_t> wfilebuf;
anatofuz
parents:
diff changeset
65
anatofuz
parents:
diff changeset
66 template <class charT, class traits = char_traits<charT> >
anatofuz
parents:
diff changeset
67 class basic_ifstream
anatofuz
parents:
diff changeset
68 : public basic_istream<charT,traits>
anatofuz
parents:
diff changeset
69 {
anatofuz
parents:
diff changeset
70 public:
anatofuz
parents:
diff changeset
71 typedef charT char_type;
anatofuz
parents:
diff changeset
72 typedef traits traits_type;
anatofuz
parents:
diff changeset
73 typedef typename traits_type::int_type int_type;
anatofuz
parents:
diff changeset
74 typedef typename traits_type::pos_type pos_type;
anatofuz
parents:
diff changeset
75 typedef typename traits_type::off_type off_type;
anatofuz
parents:
diff changeset
76
anatofuz
parents:
diff changeset
77 basic_ifstream();
anatofuz
parents:
diff changeset
78 explicit basic_ifstream(const char* s, ios_base::openmode mode = ios_base::in);
anatofuz
parents:
diff changeset
79 explicit basic_ifstream(const string& s, ios_base::openmode mode = ios_base::in);
anatofuz
parents:
diff changeset
80 explicit basic_ifstream(const filesystem::path& p,
anatofuz
parents:
diff changeset
81 ios_base::openmode mode = ios_base::in); // C++17
anatofuz
parents:
diff changeset
82 basic_ifstream(basic_ifstream&& rhs);
anatofuz
parents:
diff changeset
83
anatofuz
parents:
diff changeset
84 basic_ifstream& operator=(basic_ifstream&& rhs);
anatofuz
parents:
diff changeset
85 void swap(basic_ifstream& rhs);
anatofuz
parents:
diff changeset
86
anatofuz
parents:
diff changeset
87 basic_filebuf<char_type, traits_type>* rdbuf() const;
anatofuz
parents:
diff changeset
88 bool is_open() const;
anatofuz
parents:
diff changeset
89 void open(const char* s, ios_base::openmode mode = ios_base::in);
anatofuz
parents:
diff changeset
90 void open(const string& s, ios_base::openmode mode = ios_base::in);
anatofuz
parents:
diff changeset
91 void open(const filesystem::path& s, ios_base::openmode mode = ios_base::in); // C++17
anatofuz
parents:
diff changeset
92
anatofuz
parents:
diff changeset
93 void close();
anatofuz
parents:
diff changeset
94 };
anatofuz
parents:
diff changeset
95
anatofuz
parents:
diff changeset
96 template <class charT, class traits>
anatofuz
parents:
diff changeset
97 void
anatofuz
parents:
diff changeset
98 swap(basic_ifstream<charT, traits>& x, basic_ifstream<charT, traits>& y);
anatofuz
parents:
diff changeset
99
anatofuz
parents:
diff changeset
100 typedef basic_ifstream<char> ifstream;
anatofuz
parents:
diff changeset
101 typedef basic_ifstream<wchar_t> wifstream;
anatofuz
parents:
diff changeset
102
anatofuz
parents:
diff changeset
103 template <class charT, class traits = char_traits<charT> >
anatofuz
parents:
diff changeset
104 class basic_ofstream
anatofuz
parents:
diff changeset
105 : public basic_ostream<charT,traits>
anatofuz
parents:
diff changeset
106 {
anatofuz
parents:
diff changeset
107 public:
anatofuz
parents:
diff changeset
108 typedef charT char_type;
anatofuz
parents:
diff changeset
109 typedef traits traits_type;
anatofuz
parents:
diff changeset
110 typedef typename traits_type::int_type int_type;
anatofuz
parents:
diff changeset
111 typedef typename traits_type::pos_type pos_type;
anatofuz
parents:
diff changeset
112 typedef typename traits_type::off_type off_type;
anatofuz
parents:
diff changeset
113
anatofuz
parents:
diff changeset
114 basic_ofstream();
anatofuz
parents:
diff changeset
115 explicit basic_ofstream(const char* s, ios_base::openmode mode = ios_base::out);
anatofuz
parents:
diff changeset
116 explicit basic_ofstream(const string& s, ios_base::openmode mode = ios_base::out);
anatofuz
parents:
diff changeset
117 explicit basic_ofstream(const filesystem::path& p,
anatofuz
parents:
diff changeset
118 ios_base::openmode mode = ios_base::out); // C++17
anatofuz
parents:
diff changeset
119 basic_ofstream(basic_ofstream&& rhs);
anatofuz
parents:
diff changeset
120
anatofuz
parents:
diff changeset
121 basic_ofstream& operator=(basic_ofstream&& rhs);
anatofuz
parents:
diff changeset
122 void swap(basic_ofstream& rhs);
anatofuz
parents:
diff changeset
123
anatofuz
parents:
diff changeset
124 basic_filebuf<char_type, traits_type>* rdbuf() const;
anatofuz
parents:
diff changeset
125 bool is_open() const;
anatofuz
parents:
diff changeset
126 void open(const char* s, ios_base::openmode mode = ios_base::out);
anatofuz
parents:
diff changeset
127 void open(const string& s, ios_base::openmode mode = ios_base::out);
anatofuz
parents:
diff changeset
128 void open(const filesystem::path& p,
anatofuz
parents:
diff changeset
129 ios_base::openmode mode = ios_base::out); // C++17
anatofuz
parents:
diff changeset
130
anatofuz
parents:
diff changeset
131 void close();
anatofuz
parents:
diff changeset
132 };
anatofuz
parents:
diff changeset
133
anatofuz
parents:
diff changeset
134 template <class charT, class traits>
anatofuz
parents:
diff changeset
135 void
anatofuz
parents:
diff changeset
136 swap(basic_ofstream<charT, traits>& x, basic_ofstream<charT, traits>& y);
anatofuz
parents:
diff changeset
137
anatofuz
parents:
diff changeset
138 typedef basic_ofstream<char> ofstream;
anatofuz
parents:
diff changeset
139 typedef basic_ofstream<wchar_t> wofstream;
anatofuz
parents:
diff changeset
140
anatofuz
parents:
diff changeset
141 template <class charT, class traits=char_traits<charT> >
anatofuz
parents:
diff changeset
142 class basic_fstream
anatofuz
parents:
diff changeset
143 : public basic_iostream<charT,traits>
anatofuz
parents:
diff changeset
144 {
anatofuz
parents:
diff changeset
145 public:
anatofuz
parents:
diff changeset
146 typedef charT char_type;
anatofuz
parents:
diff changeset
147 typedef traits traits_type;
anatofuz
parents:
diff changeset
148 typedef typename traits_type::int_type int_type;
anatofuz
parents:
diff changeset
149 typedef typename traits_type::pos_type pos_type;
anatofuz
parents:
diff changeset
150 typedef typename traits_type::off_type off_type;
anatofuz
parents:
diff changeset
151
anatofuz
parents:
diff changeset
152 basic_fstream();
anatofuz
parents:
diff changeset
153 explicit basic_fstream(const char* s, ios_base::openmode mode = ios_base::in|ios_base::out);
anatofuz
parents:
diff changeset
154 explicit basic_fstream(const string& s, ios_base::openmode mode = ios_base::in|ios_base::out);
anatofuz
parents:
diff changeset
155 explicit basic_fstream(const filesystem::path& p,
anatofuz
parents:
diff changeset
156 ios_base::openmode mode = ios_base::in|ios_base::out); C++17
anatofuz
parents:
diff changeset
157 basic_fstream(basic_fstream&& rhs);
anatofuz
parents:
diff changeset
158
anatofuz
parents:
diff changeset
159 basic_fstream& operator=(basic_fstream&& rhs);
anatofuz
parents:
diff changeset
160 void swap(basic_fstream& rhs);
anatofuz
parents:
diff changeset
161
anatofuz
parents:
diff changeset
162 basic_filebuf<char_type, traits_type>* rdbuf() const;
anatofuz
parents:
diff changeset
163 bool is_open() const;
anatofuz
parents:
diff changeset
164 void open(const char* s, ios_base::openmode mode = ios_base::in|ios_base::out);
anatofuz
parents:
diff changeset
165 void open(const string& s, ios_base::openmode mode = ios_base::in|ios_base::out);
anatofuz
parents:
diff changeset
166 void open(const filesystem::path& s,
anatofuz
parents:
diff changeset
167 ios_base::openmode mode = ios_base::in|ios_base::out); // C++17
anatofuz
parents:
diff changeset
168
anatofuz
parents:
diff changeset
169 void close();
anatofuz
parents:
diff changeset
170 };
anatofuz
parents:
diff changeset
171
anatofuz
parents:
diff changeset
172 template <class charT, class traits>
anatofuz
parents:
diff changeset
173 void swap(basic_fstream<charT, traits>& x, basic_fstream<charT, traits>& y);
anatofuz
parents:
diff changeset
174
anatofuz
parents:
diff changeset
175 typedef basic_fstream<char> fstream;
anatofuz
parents:
diff changeset
176 typedef basic_fstream<wchar_t> wfstream;
anatofuz
parents:
diff changeset
177
anatofuz
parents:
diff changeset
178 } // std
anatofuz
parents:
diff changeset
179
anatofuz
parents:
diff changeset
180 */
anatofuz
parents:
diff changeset
181
anatofuz
parents:
diff changeset
182 #include <__config>
anatofuz
parents:
diff changeset
183 #include <ostream>
anatofuz
parents:
diff changeset
184 #include <istream>
anatofuz
parents:
diff changeset
185 #include <__locale>
anatofuz
parents:
diff changeset
186 #include <cstdio>
anatofuz
parents:
diff changeset
187 #include <cstdlib>
anatofuz
parents:
diff changeset
188 #include <filesystem>
anatofuz
parents:
diff changeset
189
anatofuz
parents:
diff changeset
190 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
anatofuz
parents:
diff changeset
191 #pragma GCC system_header
anatofuz
parents:
diff changeset
192 #endif
anatofuz
parents:
diff changeset
193
anatofuz
parents:
diff changeset
194 _LIBCPP_PUSH_MACROS
anatofuz
parents:
diff changeset
195 #include <__undef_macros>
anatofuz
parents:
diff changeset
196
anatofuz
parents:
diff changeset
197
anatofuz
parents:
diff changeset
198 _LIBCPP_BEGIN_NAMESPACE_STD
anatofuz
parents:
diff changeset
199
anatofuz
parents:
diff changeset
200 template <class _CharT, class _Traits>
anatofuz
parents:
diff changeset
201 class _LIBCPP_TEMPLATE_VIS basic_filebuf
anatofuz
parents:
diff changeset
202 : public basic_streambuf<_CharT, _Traits>
anatofuz
parents:
diff changeset
203 {
anatofuz
parents:
diff changeset
204 public:
anatofuz
parents:
diff changeset
205 typedef _CharT char_type;
anatofuz
parents:
diff changeset
206 typedef _Traits traits_type;
anatofuz
parents:
diff changeset
207 typedef typename traits_type::int_type int_type;
anatofuz
parents:
diff changeset
208 typedef typename traits_type::pos_type pos_type;
anatofuz
parents:
diff changeset
209 typedef typename traits_type::off_type off_type;
anatofuz
parents:
diff changeset
210 typedef typename traits_type::state_type state_type;
anatofuz
parents:
diff changeset
211
anatofuz
parents:
diff changeset
212 // 27.9.1.2 Constructors/destructor:
anatofuz
parents:
diff changeset
213 basic_filebuf();
anatofuz
parents:
diff changeset
214 #ifndef _LIBCPP_CXX03_LANG
anatofuz
parents:
diff changeset
215 basic_filebuf(basic_filebuf&& __rhs);
anatofuz
parents:
diff changeset
216 #endif
anatofuz
parents:
diff changeset
217 virtual ~basic_filebuf();
anatofuz
parents:
diff changeset
218
anatofuz
parents:
diff changeset
219 // 27.9.1.3 Assign/swap:
anatofuz
parents:
diff changeset
220 #ifndef _LIBCPP_CXX03_LANG
anatofuz
parents:
diff changeset
221 _LIBCPP_INLINE_VISIBILITY
anatofuz
parents:
diff changeset
222 basic_filebuf& operator=(basic_filebuf&& __rhs);
anatofuz
parents:
diff changeset
223 #endif
anatofuz
parents:
diff changeset
224 void swap(basic_filebuf& __rhs);
anatofuz
parents:
diff changeset
225
anatofuz
parents:
diff changeset
226 // 27.9.1.4 Members:
anatofuz
parents:
diff changeset
227 _LIBCPP_INLINE_VISIBILITY
anatofuz
parents:
diff changeset
228 bool is_open() const;
anatofuz
parents:
diff changeset
229 #ifndef _LIBCPP_HAS_NO_GLOBAL_FILESYSTEM_NAMESPACE
anatofuz
parents:
diff changeset
230 basic_filebuf* open(const char* __s, ios_base::openmode __mode);
anatofuz
parents:
diff changeset
231 #ifdef _LIBCPP_HAS_OPEN_WITH_WCHAR
anatofuz
parents:
diff changeset
232 basic_filebuf* open(const wchar_t* __s, ios_base::openmode __mode);
anatofuz
parents:
diff changeset
233 #endif
anatofuz
parents:
diff changeset
234 _LIBCPP_INLINE_VISIBILITY
anatofuz
parents:
diff changeset
235 basic_filebuf* open(const string& __s, ios_base::openmode __mode);
anatofuz
parents:
diff changeset
236
anatofuz
parents:
diff changeset
237 #if _LIBCPP_STD_VER >= 17
anatofuz
parents:
diff changeset
238 _LIBCPP_AVAILABILITY_FILESYSTEM _LIBCPP_INLINE_VISIBILITY
anatofuz
parents:
diff changeset
239 basic_filebuf* open(const _VSTD_FS::path& __p, ios_base::openmode __mode) {
anatofuz
parents:
diff changeset
240 return open(__p.c_str(), __mode);
anatofuz
parents:
diff changeset
241 }
anatofuz
parents:
diff changeset
242 #endif
anatofuz
parents:
diff changeset
243 _LIBCPP_INLINE_VISIBILITY
anatofuz
parents:
diff changeset
244 basic_filebuf* __open(int __fd, ios_base::openmode __mode);
anatofuz
parents:
diff changeset
245 #endif
anatofuz
parents:
diff changeset
246 basic_filebuf* close();
anatofuz
parents:
diff changeset
247
anatofuz
parents:
diff changeset
248 _LIBCPP_INLINE_VISIBILITY
anatofuz
parents:
diff changeset
249 inline static const char*
anatofuz
parents:
diff changeset
250 __make_mdstring(ios_base::openmode __mode) _NOEXCEPT;
anatofuz
parents:
diff changeset
251
anatofuz
parents:
diff changeset
252 protected:
anatofuz
parents:
diff changeset
253 // 27.9.1.5 Overridden virtual functions:
anatofuz
parents:
diff changeset
254 virtual int_type underflow();
anatofuz
parents:
diff changeset
255 virtual int_type pbackfail(int_type __c = traits_type::eof());
anatofuz
parents:
diff changeset
256 virtual int_type overflow (int_type __c = traits_type::eof());
anatofuz
parents:
diff changeset
257 virtual basic_streambuf<char_type, traits_type>* setbuf(char_type* __s, streamsize __n);
anatofuz
parents:
diff changeset
258 virtual pos_type seekoff(off_type __off, ios_base::seekdir __way,
anatofuz
parents:
diff changeset
259 ios_base::openmode __wch = ios_base::in | ios_base::out);
anatofuz
parents:
diff changeset
260 virtual pos_type seekpos(pos_type __sp,
anatofuz
parents:
diff changeset
261 ios_base::openmode __wch = ios_base::in | ios_base::out);
anatofuz
parents:
diff changeset
262 virtual int sync();
anatofuz
parents:
diff changeset
263 virtual void imbue(const locale& __loc);
anatofuz
parents:
diff changeset
264
anatofuz
parents:
diff changeset
265 private:
anatofuz
parents:
diff changeset
266 char* __extbuf_;
anatofuz
parents:
diff changeset
267 const char* __extbufnext_;
anatofuz
parents:
diff changeset
268 const char* __extbufend_;
anatofuz
parents:
diff changeset
269 char __extbuf_min_[8];
anatofuz
parents:
diff changeset
270 size_t __ebs_;
anatofuz
parents:
diff changeset
271 char_type* __intbuf_;
anatofuz
parents:
diff changeset
272 size_t __ibs_;
anatofuz
parents:
diff changeset
273 FILE* __file_;
anatofuz
parents:
diff changeset
274 const codecvt<char_type, char, state_type>* __cv_;
anatofuz
parents:
diff changeset
275 state_type __st_;
anatofuz
parents:
diff changeset
276 state_type __st_last_;
anatofuz
parents:
diff changeset
277 ios_base::openmode __om_;
anatofuz
parents:
diff changeset
278 ios_base::openmode __cm_;
anatofuz
parents:
diff changeset
279 bool __owns_eb_;
anatofuz
parents:
diff changeset
280 bool __owns_ib_;
anatofuz
parents:
diff changeset
281 bool __always_noconv_;
anatofuz
parents:
diff changeset
282
anatofuz
parents:
diff changeset
283 bool __read_mode();
anatofuz
parents:
diff changeset
284 void __write_mode();
anatofuz
parents:
diff changeset
285 };
anatofuz
parents:
diff changeset
286
anatofuz
parents:
diff changeset
287 template <class _CharT, class _Traits>
anatofuz
parents:
diff changeset
288 basic_filebuf<_CharT, _Traits>::basic_filebuf()
anatofuz
parents:
diff changeset
289 : __extbuf_(0),
anatofuz
parents:
diff changeset
290 __extbufnext_(0),
anatofuz
parents:
diff changeset
291 __extbufend_(0),
anatofuz
parents:
diff changeset
292 __ebs_(0),
anatofuz
parents:
diff changeset
293 __intbuf_(0),
anatofuz
parents:
diff changeset
294 __ibs_(0),
anatofuz
parents:
diff changeset
295 __file_(0),
anatofuz
parents:
diff changeset
296 __cv_(nullptr),
anatofuz
parents:
diff changeset
297 __st_(),
anatofuz
parents:
diff changeset
298 __st_last_(),
anatofuz
parents:
diff changeset
299 __om_(0),
anatofuz
parents:
diff changeset
300 __cm_(0),
anatofuz
parents:
diff changeset
301 __owns_eb_(false),
anatofuz
parents:
diff changeset
302 __owns_ib_(false),
anatofuz
parents:
diff changeset
303 __always_noconv_(false)
anatofuz
parents:
diff changeset
304 {
anatofuz
parents:
diff changeset
305 if (has_facet<codecvt<char_type, char, state_type> >(this->getloc()))
anatofuz
parents:
diff changeset
306 {
anatofuz
parents:
diff changeset
307 __cv_ = &use_facet<codecvt<char_type, char, state_type> >(this->getloc());
anatofuz
parents:
diff changeset
308 __always_noconv_ = __cv_->always_noconv();
anatofuz
parents:
diff changeset
309 }
anatofuz
parents:
diff changeset
310 setbuf(0, 4096);
anatofuz
parents:
diff changeset
311 }
anatofuz
parents:
diff changeset
312
anatofuz
parents:
diff changeset
313 #ifndef _LIBCPP_CXX03_LANG
anatofuz
parents:
diff changeset
314
anatofuz
parents:
diff changeset
315 template <class _CharT, class _Traits>
anatofuz
parents:
diff changeset
316 basic_filebuf<_CharT, _Traits>::basic_filebuf(basic_filebuf&& __rhs)
anatofuz
parents:
diff changeset
317 : basic_streambuf<_CharT, _Traits>(__rhs)
anatofuz
parents:
diff changeset
318 {
anatofuz
parents:
diff changeset
319 if (__rhs.__extbuf_ == __rhs.__extbuf_min_)
anatofuz
parents:
diff changeset
320 {
anatofuz
parents:
diff changeset
321 __extbuf_ = __extbuf_min_;
anatofuz
parents:
diff changeset
322 __extbufnext_ = __extbuf_ + (__rhs.__extbufnext_ - __rhs.__extbuf_);
anatofuz
parents:
diff changeset
323 __extbufend_ = __extbuf_ + (__rhs.__extbufend_ - __rhs.__extbuf_);
anatofuz
parents:
diff changeset
324 }
anatofuz
parents:
diff changeset
325 else
anatofuz
parents:
diff changeset
326 {
anatofuz
parents:
diff changeset
327 __extbuf_ = __rhs.__extbuf_;
anatofuz
parents:
diff changeset
328 __extbufnext_ = __rhs.__extbufnext_;
anatofuz
parents:
diff changeset
329 __extbufend_ = __rhs.__extbufend_;
anatofuz
parents:
diff changeset
330 }
anatofuz
parents:
diff changeset
331 __ebs_ = __rhs.__ebs_;
anatofuz
parents:
diff changeset
332 __intbuf_ = __rhs.__intbuf_;
anatofuz
parents:
diff changeset
333 __ibs_ = __rhs.__ibs_;
anatofuz
parents:
diff changeset
334 __file_ = __rhs.__file_;
anatofuz
parents:
diff changeset
335 __cv_ = __rhs.__cv_;
anatofuz
parents:
diff changeset
336 __st_ = __rhs.__st_;
anatofuz
parents:
diff changeset
337 __st_last_ = __rhs.__st_last_;
anatofuz
parents:
diff changeset
338 __om_ = __rhs.__om_;
anatofuz
parents:
diff changeset
339 __cm_ = __rhs.__cm_;
anatofuz
parents:
diff changeset
340 __owns_eb_ = __rhs.__owns_eb_;
anatofuz
parents:
diff changeset
341 __owns_ib_ = __rhs.__owns_ib_;
anatofuz
parents:
diff changeset
342 __always_noconv_ = __rhs.__always_noconv_;
anatofuz
parents:
diff changeset
343 if (__rhs.pbase())
anatofuz
parents:
diff changeset
344 {
anatofuz
parents:
diff changeset
345 if (__rhs.pbase() == __rhs.__intbuf_)
anatofuz
parents:
diff changeset
346 this->setp(__intbuf_, __intbuf_ + (__rhs. epptr() - __rhs.pbase()));
anatofuz
parents:
diff changeset
347 else
anatofuz
parents:
diff changeset
348 this->setp((char_type*)__extbuf_,
anatofuz
parents:
diff changeset
349 (char_type*)__extbuf_ + (__rhs. epptr() - __rhs.pbase()));
anatofuz
parents:
diff changeset
350 this->__pbump(__rhs. pptr() - __rhs.pbase());
anatofuz
parents:
diff changeset
351 }
anatofuz
parents:
diff changeset
352 else if (__rhs.eback())
anatofuz
parents:
diff changeset
353 {
anatofuz
parents:
diff changeset
354 if (__rhs.eback() == __rhs.__intbuf_)
anatofuz
parents:
diff changeset
355 this->setg(__intbuf_, __intbuf_ + (__rhs.gptr() - __rhs.eback()),
anatofuz
parents:
diff changeset
356 __intbuf_ + (__rhs.egptr() - __rhs.eback()));
anatofuz
parents:
diff changeset
357 else
anatofuz
parents:
diff changeset
358 this->setg((char_type*)__extbuf_,
anatofuz
parents:
diff changeset
359 (char_type*)__extbuf_ + (__rhs.gptr() - __rhs.eback()),
anatofuz
parents:
diff changeset
360 (char_type*)__extbuf_ + (__rhs.egptr() - __rhs.eback()));
anatofuz
parents:
diff changeset
361 }
anatofuz
parents:
diff changeset
362 __rhs.__extbuf_ = 0;
anatofuz
parents:
diff changeset
363 __rhs.__extbufnext_ = 0;
anatofuz
parents:
diff changeset
364 __rhs.__extbufend_ = 0;
anatofuz
parents:
diff changeset
365 __rhs.__ebs_ = 0;
anatofuz
parents:
diff changeset
366 __rhs.__intbuf_ = 0;
anatofuz
parents:
diff changeset
367 __rhs.__ibs_ = 0;
anatofuz
parents:
diff changeset
368 __rhs.__file_ = 0;
anatofuz
parents:
diff changeset
369 __rhs.__st_ = state_type();
anatofuz
parents:
diff changeset
370 __rhs.__st_last_ = state_type();
anatofuz
parents:
diff changeset
371 __rhs.__om_ = 0;
anatofuz
parents:
diff changeset
372 __rhs.__cm_ = 0;
anatofuz
parents:
diff changeset
373 __rhs.__owns_eb_ = false;
anatofuz
parents:
diff changeset
374 __rhs.__owns_ib_ = false;
anatofuz
parents:
diff changeset
375 __rhs.setg(0, 0, 0);
anatofuz
parents:
diff changeset
376 __rhs.setp(0, 0);
anatofuz
parents:
diff changeset
377 }
anatofuz
parents:
diff changeset
378
anatofuz
parents:
diff changeset
379 template <class _CharT, class _Traits>
anatofuz
parents:
diff changeset
380 inline
anatofuz
parents:
diff changeset
381 basic_filebuf<_CharT, _Traits>&
anatofuz
parents:
diff changeset
382 basic_filebuf<_CharT, _Traits>::operator=(basic_filebuf&& __rhs)
anatofuz
parents:
diff changeset
383 {
anatofuz
parents:
diff changeset
384 close();
anatofuz
parents:
diff changeset
385 swap(__rhs);
anatofuz
parents:
diff changeset
386 return *this;
anatofuz
parents:
diff changeset
387 }
anatofuz
parents:
diff changeset
388
anatofuz
parents:
diff changeset
389 #endif // _LIBCPP_CXX03_LANG
anatofuz
parents:
diff changeset
390
anatofuz
parents:
diff changeset
391 template <class _CharT, class _Traits>
anatofuz
parents:
diff changeset
392 basic_filebuf<_CharT, _Traits>::~basic_filebuf()
anatofuz
parents:
diff changeset
393 {
anatofuz
parents:
diff changeset
394 #ifndef _LIBCPP_NO_EXCEPTIONS
anatofuz
parents:
diff changeset
395 try
anatofuz
parents:
diff changeset
396 {
anatofuz
parents:
diff changeset
397 #endif // _LIBCPP_NO_EXCEPTIONS
anatofuz
parents:
diff changeset
398 close();
anatofuz
parents:
diff changeset
399 #ifndef _LIBCPP_NO_EXCEPTIONS
anatofuz
parents:
diff changeset
400 }
anatofuz
parents:
diff changeset
401 catch (...)
anatofuz
parents:
diff changeset
402 {
anatofuz
parents:
diff changeset
403 }
anatofuz
parents:
diff changeset
404 #endif // _LIBCPP_NO_EXCEPTIONS
anatofuz
parents:
diff changeset
405 if (__owns_eb_)
anatofuz
parents:
diff changeset
406 delete [] __extbuf_;
anatofuz
parents:
diff changeset
407 if (__owns_ib_)
anatofuz
parents:
diff changeset
408 delete [] __intbuf_;
anatofuz
parents:
diff changeset
409 }
anatofuz
parents:
diff changeset
410
anatofuz
parents:
diff changeset
411 template <class _CharT, class _Traits>
anatofuz
parents:
diff changeset
412 void
anatofuz
parents:
diff changeset
413 basic_filebuf<_CharT, _Traits>::swap(basic_filebuf& __rhs)
anatofuz
parents:
diff changeset
414 {
anatofuz
parents:
diff changeset
415 basic_streambuf<char_type, traits_type>::swap(__rhs);
anatofuz
parents:
diff changeset
416 if (__extbuf_ != __extbuf_min_ && __rhs.__extbuf_ != __rhs.__extbuf_min_)
anatofuz
parents:
diff changeset
417 {
anatofuz
parents:
diff changeset
418 _VSTD::swap(__extbuf_, __rhs.__extbuf_);
anatofuz
parents:
diff changeset
419 _VSTD::swap(__extbufnext_, __rhs.__extbufnext_);
anatofuz
parents:
diff changeset
420 _VSTD::swap(__extbufend_, __rhs.__extbufend_);
anatofuz
parents:
diff changeset
421 }
anatofuz
parents:
diff changeset
422 else
anatofuz
parents:
diff changeset
423 {
anatofuz
parents:
diff changeset
424 ptrdiff_t __ln = __extbufnext_ - __extbuf_;
anatofuz
parents:
diff changeset
425 ptrdiff_t __le = __extbufend_ - __extbuf_;
anatofuz
parents:
diff changeset
426 ptrdiff_t __rn = __rhs.__extbufnext_ - __rhs.__extbuf_;
anatofuz
parents:
diff changeset
427 ptrdiff_t __re = __rhs.__extbufend_ - __rhs.__extbuf_;
anatofuz
parents:
diff changeset
428 if (__extbuf_ == __extbuf_min_ && __rhs.__extbuf_ != __rhs.__extbuf_min_)
anatofuz
parents:
diff changeset
429 {
anatofuz
parents:
diff changeset
430 __extbuf_ = __rhs.__extbuf_;
anatofuz
parents:
diff changeset
431 __rhs.__extbuf_ = __rhs.__extbuf_min_;
anatofuz
parents:
diff changeset
432 }
anatofuz
parents:
diff changeset
433 else if (__extbuf_ != __extbuf_min_ && __rhs.__extbuf_ == __rhs.__extbuf_min_)
anatofuz
parents:
diff changeset
434 {
anatofuz
parents:
diff changeset
435 __rhs.__extbuf_ = __extbuf_;
anatofuz
parents:
diff changeset
436 __extbuf_ = __extbuf_min_;
anatofuz
parents:
diff changeset
437 }
anatofuz
parents:
diff changeset
438 __extbufnext_ = __extbuf_ + __rn;
anatofuz
parents:
diff changeset
439 __extbufend_ = __extbuf_ + __re;
anatofuz
parents:
diff changeset
440 __rhs.__extbufnext_ = __rhs.__extbuf_ + __ln;
anatofuz
parents:
diff changeset
441 __rhs.__extbufend_ = __rhs.__extbuf_ + __le;
anatofuz
parents:
diff changeset
442 }
anatofuz
parents:
diff changeset
443 _VSTD::swap(__ebs_, __rhs.__ebs_);
anatofuz
parents:
diff changeset
444 _VSTD::swap(__intbuf_, __rhs.__intbuf_);
anatofuz
parents:
diff changeset
445 _VSTD::swap(__ibs_, __rhs.__ibs_);
anatofuz
parents:
diff changeset
446 _VSTD::swap(__file_, __rhs.__file_);
anatofuz
parents:
diff changeset
447 _VSTD::swap(__cv_, __rhs.__cv_);
anatofuz
parents:
diff changeset
448 _VSTD::swap(__st_, __rhs.__st_);
anatofuz
parents:
diff changeset
449 _VSTD::swap(__st_last_, __rhs.__st_last_);
anatofuz
parents:
diff changeset
450 _VSTD::swap(__om_, __rhs.__om_);
anatofuz
parents:
diff changeset
451 _VSTD::swap(__cm_, __rhs.__cm_);
anatofuz
parents:
diff changeset
452 _VSTD::swap(__owns_eb_, __rhs.__owns_eb_);
anatofuz
parents:
diff changeset
453 _VSTD::swap(__owns_ib_, __rhs.__owns_ib_);
anatofuz
parents:
diff changeset
454 _VSTD::swap(__always_noconv_, __rhs.__always_noconv_);
anatofuz
parents:
diff changeset
455 if (this->eback() == (char_type*)__rhs.__extbuf_min_)
anatofuz
parents:
diff changeset
456 {
anatofuz
parents:
diff changeset
457 ptrdiff_t __n = this->gptr() - this->eback();
anatofuz
parents:
diff changeset
458 ptrdiff_t __e = this->egptr() - this->eback();
anatofuz
parents:
diff changeset
459 this->setg((char_type*)__extbuf_min_,
anatofuz
parents:
diff changeset
460 (char_type*)__extbuf_min_ + __n,
anatofuz
parents:
diff changeset
461 (char_type*)__extbuf_min_ + __e);
anatofuz
parents:
diff changeset
462 }
anatofuz
parents:
diff changeset
463 else if (this->pbase() == (char_type*)__rhs.__extbuf_min_)
anatofuz
parents:
diff changeset
464 {
anatofuz
parents:
diff changeset
465 ptrdiff_t __n = this->pptr() - this->pbase();
anatofuz
parents:
diff changeset
466 ptrdiff_t __e = this->epptr() - this->pbase();
anatofuz
parents:
diff changeset
467 this->setp((char_type*)__extbuf_min_,
anatofuz
parents:
diff changeset
468 (char_type*)__extbuf_min_ + __e);
anatofuz
parents:
diff changeset
469 this->__pbump(__n);
anatofuz
parents:
diff changeset
470 }
anatofuz
parents:
diff changeset
471 if (__rhs.eback() == (char_type*)__extbuf_min_)
anatofuz
parents:
diff changeset
472 {
anatofuz
parents:
diff changeset
473 ptrdiff_t __n = __rhs.gptr() - __rhs.eback();
anatofuz
parents:
diff changeset
474 ptrdiff_t __e = __rhs.egptr() - __rhs.eback();
anatofuz
parents:
diff changeset
475 __rhs.setg((char_type*)__rhs.__extbuf_min_,
anatofuz
parents:
diff changeset
476 (char_type*)__rhs.__extbuf_min_ + __n,
anatofuz
parents:
diff changeset
477 (char_type*)__rhs.__extbuf_min_ + __e);
anatofuz
parents:
diff changeset
478 }
anatofuz
parents:
diff changeset
479 else if (__rhs.pbase() == (char_type*)__extbuf_min_)
anatofuz
parents:
diff changeset
480 {
anatofuz
parents:
diff changeset
481 ptrdiff_t __n = __rhs.pptr() - __rhs.pbase();
anatofuz
parents:
diff changeset
482 ptrdiff_t __e = __rhs.epptr() - __rhs.pbase();
anatofuz
parents:
diff changeset
483 __rhs.setp((char_type*)__rhs.__extbuf_min_,
anatofuz
parents:
diff changeset
484 (char_type*)__rhs.__extbuf_min_ + __e);
anatofuz
parents:
diff changeset
485 __rhs.__pbump(__n);
anatofuz
parents:
diff changeset
486 }
anatofuz
parents:
diff changeset
487 }
anatofuz
parents:
diff changeset
488
anatofuz
parents:
diff changeset
489 template <class _CharT, class _Traits>
anatofuz
parents:
diff changeset
490 inline _LIBCPP_INLINE_VISIBILITY
anatofuz
parents:
diff changeset
491 void
anatofuz
parents:
diff changeset
492 swap(basic_filebuf<_CharT, _Traits>& __x, basic_filebuf<_CharT, _Traits>& __y)
anatofuz
parents:
diff changeset
493 {
anatofuz
parents:
diff changeset
494 __x.swap(__y);
anatofuz
parents:
diff changeset
495 }
anatofuz
parents:
diff changeset
496
anatofuz
parents:
diff changeset
497 template <class _CharT, class _Traits>
anatofuz
parents:
diff changeset
498 inline
anatofuz
parents:
diff changeset
499 bool
anatofuz
parents:
diff changeset
500 basic_filebuf<_CharT, _Traits>::is_open() const
anatofuz
parents:
diff changeset
501 {
anatofuz
parents:
diff changeset
502 return __file_ != 0;
anatofuz
parents:
diff changeset
503 }
anatofuz
parents:
diff changeset
504
anatofuz
parents:
diff changeset
505 template <class _CharT, class _Traits>
anatofuz
parents:
diff changeset
506 const char* basic_filebuf<_CharT, _Traits>::__make_mdstring(
anatofuz
parents:
diff changeset
507 ios_base::openmode __mode) _NOEXCEPT {
anatofuz
parents:
diff changeset
508 switch (__mode & ~ios_base::ate) {
anatofuz
parents:
diff changeset
509 case ios_base::out:
anatofuz
parents:
diff changeset
510 case ios_base::out | ios_base::trunc:
anatofuz
parents:
diff changeset
511 return "w" _LIBCPP_FOPEN_CLOEXEC_MODE;
anatofuz
parents:
diff changeset
512 case ios_base::out | ios_base::app:
anatofuz
parents:
diff changeset
513 case ios_base::app:
anatofuz
parents:
diff changeset
514 return "a" _LIBCPP_FOPEN_CLOEXEC_MODE;
anatofuz
parents:
diff changeset
515 case ios_base::in:
anatofuz
parents:
diff changeset
516 return "r" _LIBCPP_FOPEN_CLOEXEC_MODE;
anatofuz
parents:
diff changeset
517 case ios_base::in | ios_base::out:
anatofuz
parents:
diff changeset
518 return "r+" _LIBCPP_FOPEN_CLOEXEC_MODE;
anatofuz
parents:
diff changeset
519 case ios_base::in | ios_base::out | ios_base::trunc:
anatofuz
parents:
diff changeset
520 return "w+" _LIBCPP_FOPEN_CLOEXEC_MODE;
anatofuz
parents:
diff changeset
521 case ios_base::in | ios_base::out | ios_base::app:
anatofuz
parents:
diff changeset
522 case ios_base::in | ios_base::app:
anatofuz
parents:
diff changeset
523 return "a+" _LIBCPP_FOPEN_CLOEXEC_MODE;
anatofuz
parents:
diff changeset
524 case ios_base::out | ios_base::binary:
anatofuz
parents:
diff changeset
525 case ios_base::out | ios_base::trunc | ios_base::binary:
anatofuz
parents:
diff changeset
526 return "wb" _LIBCPP_FOPEN_CLOEXEC_MODE;
anatofuz
parents:
diff changeset
527 case ios_base::out | ios_base::app | ios_base::binary:
anatofuz
parents:
diff changeset
528 case ios_base::app | ios_base::binary:
anatofuz
parents:
diff changeset
529 return "ab" _LIBCPP_FOPEN_CLOEXEC_MODE;
anatofuz
parents:
diff changeset
530 case ios_base::in | ios_base::binary:
anatofuz
parents:
diff changeset
531 return "rb" _LIBCPP_FOPEN_CLOEXEC_MODE;
anatofuz
parents:
diff changeset
532 case ios_base::in | ios_base::out | ios_base::binary:
anatofuz
parents:
diff changeset
533 return "r+b" _LIBCPP_FOPEN_CLOEXEC_MODE;
anatofuz
parents:
diff changeset
534 case ios_base::in | ios_base::out | ios_base::trunc | ios_base::binary:
anatofuz
parents:
diff changeset
535 return "w+b" _LIBCPP_FOPEN_CLOEXEC_MODE;
anatofuz
parents:
diff changeset
536 case ios_base::in | ios_base::out | ios_base::app | ios_base::binary:
anatofuz
parents:
diff changeset
537 case ios_base::in | ios_base::app | ios_base::binary:
anatofuz
parents:
diff changeset
538 return "a+b" _LIBCPP_FOPEN_CLOEXEC_MODE;
anatofuz
parents:
diff changeset
539 default:
anatofuz
parents:
diff changeset
540 return nullptr;
anatofuz
parents:
diff changeset
541 }
anatofuz
parents:
diff changeset
542 _LIBCPP_UNREACHABLE();
anatofuz
parents:
diff changeset
543 }
anatofuz
parents:
diff changeset
544
anatofuz
parents:
diff changeset
545 #ifndef _LIBCPP_HAS_NO_GLOBAL_FILESYSTEM_NAMESPACE
anatofuz
parents:
diff changeset
546 template <class _CharT, class _Traits>
anatofuz
parents:
diff changeset
547 basic_filebuf<_CharT, _Traits>*
anatofuz
parents:
diff changeset
548 basic_filebuf<_CharT, _Traits>::open(const char* __s, ios_base::openmode __mode)
anatofuz
parents:
diff changeset
549 {
anatofuz
parents:
diff changeset
550 basic_filebuf<_CharT, _Traits>* __rt = 0;
anatofuz
parents:
diff changeset
551 if (__file_ == 0)
anatofuz
parents:
diff changeset
552 {
anatofuz
parents:
diff changeset
553 if (const char* __mdstr = __make_mdstring(__mode)) {
anatofuz
parents:
diff changeset
554 __rt = this;
anatofuz
parents:
diff changeset
555 __file_ = fopen(__s, __mdstr);
anatofuz
parents:
diff changeset
556 if (__file_) {
anatofuz
parents:
diff changeset
557 __om_ = __mode;
anatofuz
parents:
diff changeset
558 if (__mode & ios_base::ate) {
anatofuz
parents:
diff changeset
559 if (fseek(__file_, 0, SEEK_END)) {
anatofuz
parents:
diff changeset
560 fclose(__file_);
anatofuz
parents:
diff changeset
561 __file_ = 0;
anatofuz
parents:
diff changeset
562 __rt = 0;
anatofuz
parents:
diff changeset
563 }
anatofuz
parents:
diff changeset
564 }
anatofuz
parents:
diff changeset
565 } else
anatofuz
parents:
diff changeset
566 __rt = 0;
anatofuz
parents:
diff changeset
567 }
anatofuz
parents:
diff changeset
568 }
anatofuz
parents:
diff changeset
569 return __rt;
anatofuz
parents:
diff changeset
570 }
anatofuz
parents:
diff changeset
571
anatofuz
parents:
diff changeset
572 template <class _CharT, class _Traits>
anatofuz
parents:
diff changeset
573 _LIBCPP_INLINE_VISIBILITY basic_filebuf<_CharT, _Traits>*
anatofuz
parents:
diff changeset
574 basic_filebuf<_CharT, _Traits>::__open(int __fd, ios_base::openmode __mode) {
anatofuz
parents:
diff changeset
575 basic_filebuf<_CharT, _Traits>* __rt = 0;
anatofuz
parents:
diff changeset
576 if (__file_ == 0) {
anatofuz
parents:
diff changeset
577 if (const char* __mdstr = __make_mdstring(__mode)) {
anatofuz
parents:
diff changeset
578 __rt = this;
anatofuz
parents:
diff changeset
579 __file_ = fdopen(__fd, __mdstr);
anatofuz
parents:
diff changeset
580 if (__file_) {
anatofuz
parents:
diff changeset
581 __om_ = __mode;
anatofuz
parents:
diff changeset
582 if (__mode & ios_base::ate) {
anatofuz
parents:
diff changeset
583 if (fseek(__file_, 0, SEEK_END)) {
anatofuz
parents:
diff changeset
584 fclose(__file_);
anatofuz
parents:
diff changeset
585 __file_ = 0;
anatofuz
parents:
diff changeset
586 __rt = 0;
anatofuz
parents:
diff changeset
587 }
anatofuz
parents:
diff changeset
588 }
anatofuz
parents:
diff changeset
589 } else
anatofuz
parents:
diff changeset
590 __rt = 0;
anatofuz
parents:
diff changeset
591 }
anatofuz
parents:
diff changeset
592 }
anatofuz
parents:
diff changeset
593 return __rt;
anatofuz
parents:
diff changeset
594 }
anatofuz
parents:
diff changeset
595
anatofuz
parents:
diff changeset
596 #ifdef _LIBCPP_HAS_OPEN_WITH_WCHAR
anatofuz
parents:
diff changeset
597 // This is basically the same as the char* overload except that it uses _wfopen
anatofuz
parents:
diff changeset
598 // and long mode strings.
anatofuz
parents:
diff changeset
599 template <class _CharT, class _Traits>
anatofuz
parents:
diff changeset
600 basic_filebuf<_CharT, _Traits>*
anatofuz
parents:
diff changeset
601 basic_filebuf<_CharT, _Traits>::open(const wchar_t* __s, ios_base::openmode __mode)
anatofuz
parents:
diff changeset
602 {
anatofuz
parents:
diff changeset
603 basic_filebuf<_CharT, _Traits>* __rt = 0;
anatofuz
parents:
diff changeset
604 if (__file_ == 0)
anatofuz
parents:
diff changeset
605 {
anatofuz
parents:
diff changeset
606 __rt = this;
anatofuz
parents:
diff changeset
607 const wchar_t* __mdstr;
anatofuz
parents:
diff changeset
608 switch (__mode & ~ios_base::ate)
anatofuz
parents:
diff changeset
609 {
anatofuz
parents:
diff changeset
610 case ios_base::out:
anatofuz
parents:
diff changeset
611 case ios_base::out | ios_base::trunc:
anatofuz
parents:
diff changeset
612 __mdstr = L"w";
anatofuz
parents:
diff changeset
613 break;
anatofuz
parents:
diff changeset
614 case ios_base::out | ios_base::app:
anatofuz
parents:
diff changeset
615 case ios_base::app:
anatofuz
parents:
diff changeset
616 __mdstr = L"a";
anatofuz
parents:
diff changeset
617 break;
anatofuz
parents:
diff changeset
618 case ios_base::in:
anatofuz
parents:
diff changeset
619 __mdstr = L"r";
anatofuz
parents:
diff changeset
620 break;
anatofuz
parents:
diff changeset
621 case ios_base::in | ios_base::out:
anatofuz
parents:
diff changeset
622 __mdstr = L"r+";
anatofuz
parents:
diff changeset
623 break;
anatofuz
parents:
diff changeset
624 case ios_base::in | ios_base::out | ios_base::trunc:
anatofuz
parents:
diff changeset
625 __mdstr = L"w+";
anatofuz
parents:
diff changeset
626 break;
anatofuz
parents:
diff changeset
627 case ios_base::in | ios_base::out | ios_base::app:
anatofuz
parents:
diff changeset
628 case ios_base::in | ios_base::app:
anatofuz
parents:
diff changeset
629 __mdstr = L"a+";
anatofuz
parents:
diff changeset
630 break;
anatofuz
parents:
diff changeset
631 case ios_base::out | ios_base::binary:
anatofuz
parents:
diff changeset
632 case ios_base::out | ios_base::trunc | ios_base::binary:
anatofuz
parents:
diff changeset
633 __mdstr = L"wb";
anatofuz
parents:
diff changeset
634 break;
anatofuz
parents:
diff changeset
635 case ios_base::out | ios_base::app | ios_base::binary:
anatofuz
parents:
diff changeset
636 case ios_base::app | ios_base::binary:
anatofuz
parents:
diff changeset
637 __mdstr = L"ab";
anatofuz
parents:
diff changeset
638 break;
anatofuz
parents:
diff changeset
639 case ios_base::in | ios_base::binary:
anatofuz
parents:
diff changeset
640 __mdstr = L"rb";
anatofuz
parents:
diff changeset
641 break;
anatofuz
parents:
diff changeset
642 case ios_base::in | ios_base::out | ios_base::binary:
anatofuz
parents:
diff changeset
643 __mdstr = L"r+b";
anatofuz
parents:
diff changeset
644 break;
anatofuz
parents:
diff changeset
645 case ios_base::in | ios_base::out | ios_base::trunc | ios_base::binary:
anatofuz
parents:
diff changeset
646 __mdstr = L"w+b";
anatofuz
parents:
diff changeset
647 break;
anatofuz
parents:
diff changeset
648 case ios_base::in | ios_base::out | ios_base::app | ios_base::binary:
anatofuz
parents:
diff changeset
649 case ios_base::in | ios_base::app | ios_base::binary:
anatofuz
parents:
diff changeset
650 __mdstr = L"a+b";
anatofuz
parents:
diff changeset
651 break;
anatofuz
parents:
diff changeset
652 default:
anatofuz
parents:
diff changeset
653 __rt = 0;
anatofuz
parents:
diff changeset
654 break;
anatofuz
parents:
diff changeset
655 }
anatofuz
parents:
diff changeset
656 if (__rt)
anatofuz
parents:
diff changeset
657 {
anatofuz
parents:
diff changeset
658 __file_ = _wfopen(__s, __mdstr);
anatofuz
parents:
diff changeset
659 if (__file_)
anatofuz
parents:
diff changeset
660 {
anatofuz
parents:
diff changeset
661 __om_ = __mode;
anatofuz
parents:
diff changeset
662 if (__mode & ios_base::ate)
anatofuz
parents:
diff changeset
663 {
anatofuz
parents:
diff changeset
664 if (fseek(__file_, 0, SEEK_END))
anatofuz
parents:
diff changeset
665 {
anatofuz
parents:
diff changeset
666 fclose(__file_);
anatofuz
parents:
diff changeset
667 __file_ = 0;
anatofuz
parents:
diff changeset
668 __rt = 0;
anatofuz
parents:
diff changeset
669 }
anatofuz
parents:
diff changeset
670 }
anatofuz
parents:
diff changeset
671 }
anatofuz
parents:
diff changeset
672 else
anatofuz
parents:
diff changeset
673 __rt = 0;
anatofuz
parents:
diff changeset
674 }
anatofuz
parents:
diff changeset
675 }
anatofuz
parents:
diff changeset
676 return __rt;
anatofuz
parents:
diff changeset
677 }
anatofuz
parents:
diff changeset
678 #endif
anatofuz
parents:
diff changeset
679
anatofuz
parents:
diff changeset
680 template <class _CharT, class _Traits>
anatofuz
parents:
diff changeset
681 inline
anatofuz
parents:
diff changeset
682 basic_filebuf<_CharT, _Traits>*
anatofuz
parents:
diff changeset
683 basic_filebuf<_CharT, _Traits>::open(const string& __s, ios_base::openmode __mode)
anatofuz
parents:
diff changeset
684 {
anatofuz
parents:
diff changeset
685 return open(__s.c_str(), __mode);
anatofuz
parents:
diff changeset
686 }
anatofuz
parents:
diff changeset
687 #endif
anatofuz
parents:
diff changeset
688
anatofuz
parents:
diff changeset
689 template <class _CharT, class _Traits>
anatofuz
parents:
diff changeset
690 basic_filebuf<_CharT, _Traits>*
anatofuz
parents:
diff changeset
691 basic_filebuf<_CharT, _Traits>::close()
anatofuz
parents:
diff changeset
692 {
anatofuz
parents:
diff changeset
693 basic_filebuf<_CharT, _Traits>* __rt = 0;
anatofuz
parents:
diff changeset
694 if (__file_)
anatofuz
parents:
diff changeset
695 {
anatofuz
parents:
diff changeset
696 __rt = this;
anatofuz
parents:
diff changeset
697 unique_ptr<FILE, int(*)(FILE*)> __h(__file_, fclose);
anatofuz
parents:
diff changeset
698 if (sync())
anatofuz
parents:
diff changeset
699 __rt = 0;
anatofuz
parents:
diff changeset
700 if (fclose(__h.release()))
anatofuz
parents:
diff changeset
701 __rt = 0;
anatofuz
parents:
diff changeset
702 __file_ = 0;
anatofuz
parents:
diff changeset
703 setbuf(0, 0);
anatofuz
parents:
diff changeset
704 }
anatofuz
parents:
diff changeset
705 return __rt;
anatofuz
parents:
diff changeset
706 }
anatofuz
parents:
diff changeset
707
anatofuz
parents:
diff changeset
708 template <class _CharT, class _Traits>
anatofuz
parents:
diff changeset
709 typename basic_filebuf<_CharT, _Traits>::int_type
anatofuz
parents:
diff changeset
710 basic_filebuf<_CharT, _Traits>::underflow()
anatofuz
parents:
diff changeset
711 {
anatofuz
parents:
diff changeset
712 if (__file_ == 0)
anatofuz
parents:
diff changeset
713 return traits_type::eof();
anatofuz
parents:
diff changeset
714 bool __initial = __read_mode();
anatofuz
parents:
diff changeset
715 char_type __1buf;
anatofuz
parents:
diff changeset
716 if (this->gptr() == 0)
anatofuz
parents:
diff changeset
717 this->setg(&__1buf, &__1buf+1, &__1buf+1);
anatofuz
parents:
diff changeset
718 const size_t __unget_sz = __initial ? 0 : min<size_t>((this->egptr() - this->eback()) / 2, 4);
anatofuz
parents:
diff changeset
719 int_type __c = traits_type::eof();
anatofuz
parents:
diff changeset
720 if (this->gptr() == this->egptr())
anatofuz
parents:
diff changeset
721 {
anatofuz
parents:
diff changeset
722 memmove(this->eback(), this->egptr() - __unget_sz, __unget_sz * sizeof(char_type));
anatofuz
parents:
diff changeset
723 if (__always_noconv_)
anatofuz
parents:
diff changeset
724 {
anatofuz
parents:
diff changeset
725 size_t __nmemb = static_cast<size_t>(this->egptr() - this->eback() - __unget_sz);
anatofuz
parents:
diff changeset
726 __nmemb = fread(this->eback() + __unget_sz, 1, __nmemb, __file_);
anatofuz
parents:
diff changeset
727 if (__nmemb != 0)
anatofuz
parents:
diff changeset
728 {
anatofuz
parents:
diff changeset
729 this->setg(this->eback(),
anatofuz
parents:
diff changeset
730 this->eback() + __unget_sz,
anatofuz
parents:
diff changeset
731 this->eback() + __unget_sz + __nmemb);
anatofuz
parents:
diff changeset
732 __c = traits_type::to_int_type(*this->gptr());
anatofuz
parents:
diff changeset
733 }
anatofuz
parents:
diff changeset
734 }
anatofuz
parents:
diff changeset
735 else
anatofuz
parents:
diff changeset
736 {
anatofuz
parents:
diff changeset
737 _LIBCPP_ASSERT ( !(__extbufnext_ == NULL && (__extbufend_ != __extbufnext_)), "underflow moving from NULL" );
anatofuz
parents:
diff changeset
738 if (__extbufend_ != __extbufnext_)
anatofuz
parents:
diff changeset
739 memmove(__extbuf_, __extbufnext_, __extbufend_ - __extbufnext_);
anatofuz
parents:
diff changeset
740 __extbufnext_ = __extbuf_ + (__extbufend_ - __extbufnext_);
anatofuz
parents:
diff changeset
741 __extbufend_ = __extbuf_ + (__extbuf_ == __extbuf_min_ ? sizeof(__extbuf_min_) : __ebs_);
anatofuz
parents:
diff changeset
742 size_t __nmemb = _VSTD::min(static_cast<size_t>(__ibs_ - __unget_sz),
anatofuz
parents:
diff changeset
743 static_cast<size_t>(__extbufend_ - __extbufnext_));
anatofuz
parents:
diff changeset
744 codecvt_base::result __r;
anatofuz
parents:
diff changeset
745 __st_last_ = __st_;
anatofuz
parents:
diff changeset
746 size_t __nr = fread((void*) const_cast<char *>(__extbufnext_), 1, __nmemb, __file_);
anatofuz
parents:
diff changeset
747 if (__nr != 0)
anatofuz
parents:
diff changeset
748 {
anatofuz
parents:
diff changeset
749 if (!__cv_)
anatofuz
parents:
diff changeset
750 __throw_bad_cast();
anatofuz
parents:
diff changeset
751
anatofuz
parents:
diff changeset
752 __extbufend_ = __extbufnext_ + __nr;
anatofuz
parents:
diff changeset
753 char_type* __inext;
anatofuz
parents:
diff changeset
754 __r = __cv_->in(__st_, __extbuf_, __extbufend_, __extbufnext_,
anatofuz
parents:
diff changeset
755 this->eback() + __unget_sz,
anatofuz
parents:
diff changeset
756 this->eback() + __ibs_, __inext);
anatofuz
parents:
diff changeset
757 if (__r == codecvt_base::noconv)
anatofuz
parents:
diff changeset
758 {
anatofuz
parents:
diff changeset
759 this->setg((char_type*)__extbuf_, (char_type*)__extbuf_,
anatofuz
parents:
diff changeset
760 (char_type*)const_cast<char *>(__extbufend_));
anatofuz
parents:
diff changeset
761 __c = traits_type::to_int_type(*this->gptr());
anatofuz
parents:
diff changeset
762 }
anatofuz
parents:
diff changeset
763 else if (__inext != this->eback() + __unget_sz)
anatofuz
parents:
diff changeset
764 {
anatofuz
parents:
diff changeset
765 this->setg(this->eback(), this->eback() + __unget_sz, __inext);
anatofuz
parents:
diff changeset
766 __c = traits_type::to_int_type(*this->gptr());
anatofuz
parents:
diff changeset
767 }
anatofuz
parents:
diff changeset
768 }
anatofuz
parents:
diff changeset
769 }
anatofuz
parents:
diff changeset
770 }
anatofuz
parents:
diff changeset
771 else
anatofuz
parents:
diff changeset
772 __c = traits_type::to_int_type(*this->gptr());
anatofuz
parents:
diff changeset
773 if (this->eback() == &__1buf)
anatofuz
parents:
diff changeset
774 this->setg(0, 0, 0);
anatofuz
parents:
diff changeset
775 return __c;
anatofuz
parents:
diff changeset
776 }
anatofuz
parents:
diff changeset
777
anatofuz
parents:
diff changeset
778 template <class _CharT, class _Traits>
anatofuz
parents:
diff changeset
779 typename basic_filebuf<_CharT, _Traits>::int_type
anatofuz
parents:
diff changeset
780 basic_filebuf<_CharT, _Traits>::pbackfail(int_type __c)
anatofuz
parents:
diff changeset
781 {
anatofuz
parents:
diff changeset
782 if (__file_ && this->eback() < this->gptr())
anatofuz
parents:
diff changeset
783 {
anatofuz
parents:
diff changeset
784 if (traits_type::eq_int_type(__c, traits_type::eof()))
anatofuz
parents:
diff changeset
785 {
anatofuz
parents:
diff changeset
786 this->gbump(-1);
anatofuz
parents:
diff changeset
787 return traits_type::not_eof(__c);
anatofuz
parents:
diff changeset
788 }
anatofuz
parents:
diff changeset
789 if ((__om_ & ios_base::out) ||
anatofuz
parents:
diff changeset
790 traits_type::eq(traits_type::to_char_type(__c), this->gptr()[-1]))
anatofuz
parents:
diff changeset
791 {
anatofuz
parents:
diff changeset
792 this->gbump(-1);
anatofuz
parents:
diff changeset
793 *this->gptr() = traits_type::to_char_type(__c);
anatofuz
parents:
diff changeset
794 return __c;
anatofuz
parents:
diff changeset
795 }
anatofuz
parents:
diff changeset
796 }
anatofuz
parents:
diff changeset
797 return traits_type::eof();
anatofuz
parents:
diff changeset
798 }
anatofuz
parents:
diff changeset
799
anatofuz
parents:
diff changeset
800 template <class _CharT, class _Traits>
anatofuz
parents:
diff changeset
801 typename basic_filebuf<_CharT, _Traits>::int_type
anatofuz
parents:
diff changeset
802 basic_filebuf<_CharT, _Traits>::overflow(int_type __c)
anatofuz
parents:
diff changeset
803 {
anatofuz
parents:
diff changeset
804 if (__file_ == 0)
anatofuz
parents:
diff changeset
805 return traits_type::eof();
anatofuz
parents:
diff changeset
806 __write_mode();
anatofuz
parents:
diff changeset
807 char_type __1buf;
anatofuz
parents:
diff changeset
808 char_type* __pb_save = this->pbase();
anatofuz
parents:
diff changeset
809 char_type* __epb_save = this->epptr();
anatofuz
parents:
diff changeset
810 if (!traits_type::eq_int_type(__c, traits_type::eof()))
anatofuz
parents:
diff changeset
811 {
anatofuz
parents:
diff changeset
812 if (this->pptr() == 0)
anatofuz
parents:
diff changeset
813 this->setp(&__1buf, &__1buf+1);
anatofuz
parents:
diff changeset
814 *this->pptr() = traits_type::to_char_type(__c);
anatofuz
parents:
diff changeset
815 this->pbump(1);
anatofuz
parents:
diff changeset
816 }
anatofuz
parents:
diff changeset
817 if (this->pptr() != this->pbase())
anatofuz
parents:
diff changeset
818 {
anatofuz
parents:
diff changeset
819 if (__always_noconv_)
anatofuz
parents:
diff changeset
820 {
anatofuz
parents:
diff changeset
821 size_t __nmemb = static_cast<size_t>(this->pptr() - this->pbase());
anatofuz
parents:
diff changeset
822 if (fwrite(this->pbase(), sizeof(char_type), __nmemb, __file_) != __nmemb)
anatofuz
parents:
diff changeset
823 return traits_type::eof();
anatofuz
parents:
diff changeset
824 }
anatofuz
parents:
diff changeset
825 else
anatofuz
parents:
diff changeset
826 {
anatofuz
parents:
diff changeset
827 char* __extbe = __extbuf_;
anatofuz
parents:
diff changeset
828 codecvt_base::result __r;
anatofuz
parents:
diff changeset
829 do
anatofuz
parents:
diff changeset
830 {
anatofuz
parents:
diff changeset
831 if (!__cv_)
anatofuz
parents:
diff changeset
832 __throw_bad_cast();
anatofuz
parents:
diff changeset
833
anatofuz
parents:
diff changeset
834 const char_type* __e;
anatofuz
parents:
diff changeset
835 __r = __cv_->out(__st_, this->pbase(), this->pptr(), __e,
anatofuz
parents:
diff changeset
836 __extbuf_, __extbuf_ + __ebs_, __extbe);
anatofuz
parents:
diff changeset
837 if (__e == this->pbase())
anatofuz
parents:
diff changeset
838 return traits_type::eof();
anatofuz
parents:
diff changeset
839 if (__r == codecvt_base::noconv)
anatofuz
parents:
diff changeset
840 {
anatofuz
parents:
diff changeset
841 size_t __nmemb = static_cast<size_t>(this->pptr() - this->pbase());
anatofuz
parents:
diff changeset
842 if (fwrite(this->pbase(), 1, __nmemb, __file_) != __nmemb)
anatofuz
parents:
diff changeset
843 return traits_type::eof();
anatofuz
parents:
diff changeset
844 }
anatofuz
parents:
diff changeset
845 else if (__r == codecvt_base::ok || __r == codecvt_base::partial)
anatofuz
parents:
diff changeset
846 {
anatofuz
parents:
diff changeset
847 size_t __nmemb = static_cast<size_t>(__extbe - __extbuf_);
anatofuz
parents:
diff changeset
848 if (fwrite(__extbuf_, 1, __nmemb, __file_) != __nmemb)
anatofuz
parents:
diff changeset
849 return traits_type::eof();
anatofuz
parents:
diff changeset
850 if (__r == codecvt_base::partial)
anatofuz
parents:
diff changeset
851 {
anatofuz
parents:
diff changeset
852 this->setp(const_cast<char_type*>(__e), this->pptr());
anatofuz
parents:
diff changeset
853 this->__pbump(this->epptr() - this->pbase());
anatofuz
parents:
diff changeset
854 }
anatofuz
parents:
diff changeset
855 }
anatofuz
parents:
diff changeset
856 else
anatofuz
parents:
diff changeset
857 return traits_type::eof();
anatofuz
parents:
diff changeset
858 } while (__r == codecvt_base::partial);
anatofuz
parents:
diff changeset
859 }
anatofuz
parents:
diff changeset
860 this->setp(__pb_save, __epb_save);
anatofuz
parents:
diff changeset
861 }
anatofuz
parents:
diff changeset
862 return traits_type::not_eof(__c);
anatofuz
parents:
diff changeset
863 }
anatofuz
parents:
diff changeset
864
anatofuz
parents:
diff changeset
865 template <class _CharT, class _Traits>
anatofuz
parents:
diff changeset
866 basic_streambuf<_CharT, _Traits>*
anatofuz
parents:
diff changeset
867 basic_filebuf<_CharT, _Traits>::setbuf(char_type* __s, streamsize __n)
anatofuz
parents:
diff changeset
868 {
anatofuz
parents:
diff changeset
869 this->setg(0, 0, 0);
anatofuz
parents:
diff changeset
870 this->setp(0, 0);
anatofuz
parents:
diff changeset
871 if (__owns_eb_)
anatofuz
parents:
diff changeset
872 delete [] __extbuf_;
anatofuz
parents:
diff changeset
873 if (__owns_ib_)
anatofuz
parents:
diff changeset
874 delete [] __intbuf_;
anatofuz
parents:
diff changeset
875 __ebs_ = __n;
anatofuz
parents:
diff changeset
876 if (__ebs_ > sizeof(__extbuf_min_))
anatofuz
parents:
diff changeset
877 {
anatofuz
parents:
diff changeset
878 if (__always_noconv_ && __s)
anatofuz
parents:
diff changeset
879 {
anatofuz
parents:
diff changeset
880 __extbuf_ = (char*)__s;
anatofuz
parents:
diff changeset
881 __owns_eb_ = false;
anatofuz
parents:
diff changeset
882 }
anatofuz
parents:
diff changeset
883 else
anatofuz
parents:
diff changeset
884 {
anatofuz
parents:
diff changeset
885 __extbuf_ = new char[__ebs_];
anatofuz
parents:
diff changeset
886 __owns_eb_ = true;
anatofuz
parents:
diff changeset
887 }
anatofuz
parents:
diff changeset
888 }
anatofuz
parents:
diff changeset
889 else
anatofuz
parents:
diff changeset
890 {
anatofuz
parents:
diff changeset
891 __extbuf_ = __extbuf_min_;
anatofuz
parents:
diff changeset
892 __ebs_ = sizeof(__extbuf_min_);
anatofuz
parents:
diff changeset
893 __owns_eb_ = false;
anatofuz
parents:
diff changeset
894 }
anatofuz
parents:
diff changeset
895 if (!__always_noconv_)
anatofuz
parents:
diff changeset
896 {
anatofuz
parents:
diff changeset
897 __ibs_ = max<streamsize>(__n, sizeof(__extbuf_min_));
anatofuz
parents:
diff changeset
898 if (__s && __ibs_ >= sizeof(__extbuf_min_))
anatofuz
parents:
diff changeset
899 {
anatofuz
parents:
diff changeset
900 __intbuf_ = __s;
anatofuz
parents:
diff changeset
901 __owns_ib_ = false;
anatofuz
parents:
diff changeset
902 }
anatofuz
parents:
diff changeset
903 else
anatofuz
parents:
diff changeset
904 {
anatofuz
parents:
diff changeset
905 __intbuf_ = new char_type[__ibs_];
anatofuz
parents:
diff changeset
906 __owns_ib_ = true;
anatofuz
parents:
diff changeset
907 }
anatofuz
parents:
diff changeset
908 }
anatofuz
parents:
diff changeset
909 else
anatofuz
parents:
diff changeset
910 {
anatofuz
parents:
diff changeset
911 __ibs_ = 0;
anatofuz
parents:
diff changeset
912 __intbuf_ = 0;
anatofuz
parents:
diff changeset
913 __owns_ib_ = false;
anatofuz
parents:
diff changeset
914 }
anatofuz
parents:
diff changeset
915 return this;
anatofuz
parents:
diff changeset
916 }
anatofuz
parents:
diff changeset
917
anatofuz
parents:
diff changeset
918 template <class _CharT, class _Traits>
anatofuz
parents:
diff changeset
919 typename basic_filebuf<_CharT, _Traits>::pos_type
anatofuz
parents:
diff changeset
920 basic_filebuf<_CharT, _Traits>::seekoff(off_type __off, ios_base::seekdir __way,
anatofuz
parents:
diff changeset
921 ios_base::openmode)
anatofuz
parents:
diff changeset
922 {
anatofuz
parents:
diff changeset
923 if (!__cv_)
anatofuz
parents:
diff changeset
924 __throw_bad_cast();
anatofuz
parents:
diff changeset
925
anatofuz
parents:
diff changeset
926 int __width = __cv_->encoding();
anatofuz
parents:
diff changeset
927 if (__file_ == 0 || (__width <= 0 && __off != 0) || sync())
anatofuz
parents:
diff changeset
928 return pos_type(off_type(-1));
anatofuz
parents:
diff changeset
929 // __width > 0 || __off == 0
anatofuz
parents:
diff changeset
930 int __whence;
anatofuz
parents:
diff changeset
931 switch (__way)
anatofuz
parents:
diff changeset
932 {
anatofuz
parents:
diff changeset
933 case ios_base::beg:
anatofuz
parents:
diff changeset
934 __whence = SEEK_SET;
anatofuz
parents:
diff changeset
935 break;
anatofuz
parents:
diff changeset
936 case ios_base::cur:
anatofuz
parents:
diff changeset
937 __whence = SEEK_CUR;
anatofuz
parents:
diff changeset
938 break;
anatofuz
parents:
diff changeset
939 case ios_base::end:
anatofuz
parents:
diff changeset
940 __whence = SEEK_END;
anatofuz
parents:
diff changeset
941 break;
anatofuz
parents:
diff changeset
942 default:
anatofuz
parents:
diff changeset
943 return pos_type(off_type(-1));
anatofuz
parents:
diff changeset
944 }
anatofuz
parents:
diff changeset
945 #if defined(_LIBCPP_HAS_NO_OFF_T_FUNCTIONS)
anatofuz
parents:
diff changeset
946 if (fseek(__file_, __width > 0 ? __width * __off : 0, __whence))
anatofuz
parents:
diff changeset
947 return pos_type(off_type(-1));
anatofuz
parents:
diff changeset
948 pos_type __r = ftell(__file_);
anatofuz
parents:
diff changeset
949 #else
anatofuz
parents:
diff changeset
950 if (fseeko(__file_, __width > 0 ? __width * __off : 0, __whence))
anatofuz
parents:
diff changeset
951 return pos_type(off_type(-1));
anatofuz
parents:
diff changeset
952 pos_type __r = ftello(__file_);
anatofuz
parents:
diff changeset
953 #endif
anatofuz
parents:
diff changeset
954 __r.state(__st_);
anatofuz
parents:
diff changeset
955 return __r;
anatofuz
parents:
diff changeset
956 }
anatofuz
parents:
diff changeset
957
anatofuz
parents:
diff changeset
958 template <class _CharT, class _Traits>
anatofuz
parents:
diff changeset
959 typename basic_filebuf<_CharT, _Traits>::pos_type
anatofuz
parents:
diff changeset
960 basic_filebuf<_CharT, _Traits>::seekpos(pos_type __sp, ios_base::openmode)
anatofuz
parents:
diff changeset
961 {
anatofuz
parents:
diff changeset
962 if (__file_ == 0 || sync())
anatofuz
parents:
diff changeset
963 return pos_type(off_type(-1));
anatofuz
parents:
diff changeset
964 #if defined(_LIBCPP_HAS_NO_OFF_T_FUNCTIONS)
anatofuz
parents:
diff changeset
965 if (fseek(__file_, __sp, SEEK_SET))
anatofuz
parents:
diff changeset
966 return pos_type(off_type(-1));
anatofuz
parents:
diff changeset
967 #else
anatofuz
parents:
diff changeset
968 if (fseeko(__file_, __sp, SEEK_SET))
anatofuz
parents:
diff changeset
969 return pos_type(off_type(-1));
anatofuz
parents:
diff changeset
970 #endif
anatofuz
parents:
diff changeset
971 __st_ = __sp.state();
anatofuz
parents:
diff changeset
972 return __sp;
anatofuz
parents:
diff changeset
973 }
anatofuz
parents:
diff changeset
974
anatofuz
parents:
diff changeset
975 template <class _CharT, class _Traits>
anatofuz
parents:
diff changeset
976 int
anatofuz
parents:
diff changeset
977 basic_filebuf<_CharT, _Traits>::sync()
anatofuz
parents:
diff changeset
978 {
anatofuz
parents:
diff changeset
979 if (__file_ == 0)
anatofuz
parents:
diff changeset
980 return 0;
anatofuz
parents:
diff changeset
981 if (!__cv_)
anatofuz
parents:
diff changeset
982 __throw_bad_cast();
anatofuz
parents:
diff changeset
983
anatofuz
parents:
diff changeset
984 if (__cm_ & ios_base::out)
anatofuz
parents:
diff changeset
985 {
anatofuz
parents:
diff changeset
986 if (this->pptr() != this->pbase())
anatofuz
parents:
diff changeset
987 if (overflow() == traits_type::eof())
anatofuz
parents:
diff changeset
988 return -1;
anatofuz
parents:
diff changeset
989 codecvt_base::result __r;
anatofuz
parents:
diff changeset
990 do
anatofuz
parents:
diff changeset
991 {
anatofuz
parents:
diff changeset
992 char* __extbe;
anatofuz
parents:
diff changeset
993 __r = __cv_->unshift(__st_, __extbuf_, __extbuf_ + __ebs_, __extbe);
anatofuz
parents:
diff changeset
994 size_t __nmemb = static_cast<size_t>(__extbe - __extbuf_);
anatofuz
parents:
diff changeset
995 if (fwrite(__extbuf_, 1, __nmemb, __file_) != __nmemb)
anatofuz
parents:
diff changeset
996 return -1;
anatofuz
parents:
diff changeset
997 } while (__r == codecvt_base::partial);
anatofuz
parents:
diff changeset
998 if (__r == codecvt_base::error)
anatofuz
parents:
diff changeset
999 return -1;
anatofuz
parents:
diff changeset
1000 if (fflush(__file_))
anatofuz
parents:
diff changeset
1001 return -1;
anatofuz
parents:
diff changeset
1002 }
anatofuz
parents:
diff changeset
1003 else if (__cm_ & ios_base::in)
anatofuz
parents:
diff changeset
1004 {
anatofuz
parents:
diff changeset
1005 off_type __c;
anatofuz
parents:
diff changeset
1006 state_type __state = __st_last_;
anatofuz
parents:
diff changeset
1007 bool __update_st = false;
anatofuz
parents:
diff changeset
1008 if (__always_noconv_)
anatofuz
parents:
diff changeset
1009 __c = this->egptr() - this->gptr();
anatofuz
parents:
diff changeset
1010 else
anatofuz
parents:
diff changeset
1011 {
anatofuz
parents:
diff changeset
1012 int __width = __cv_->encoding();
anatofuz
parents:
diff changeset
1013 __c = __extbufend_ - __extbufnext_;
anatofuz
parents:
diff changeset
1014 if (__width > 0)
anatofuz
parents:
diff changeset
1015 __c += __width * (this->egptr() - this->gptr());
anatofuz
parents:
diff changeset
1016 else
anatofuz
parents:
diff changeset
1017 {
anatofuz
parents:
diff changeset
1018 if (this->gptr() != this->egptr())
anatofuz
parents:
diff changeset
1019 {
anatofuz
parents:
diff changeset
1020 const int __off = __cv_->length(__state, __extbuf_,
anatofuz
parents:
diff changeset
1021 __extbufnext_,
anatofuz
parents:
diff changeset
1022 this->gptr() - this->eback());
anatofuz
parents:
diff changeset
1023 __c += __extbufnext_ - __extbuf_ - __off;
anatofuz
parents:
diff changeset
1024 __update_st = true;
anatofuz
parents:
diff changeset
1025 }
anatofuz
parents:
diff changeset
1026 }
anatofuz
parents:
diff changeset
1027 }
anatofuz
parents:
diff changeset
1028 #if defined(_LIBCPP_HAS_NO_OFF_T_FUNCTIONS)
anatofuz
parents:
diff changeset
1029 if (fseek(__file_, -__c, SEEK_CUR))
anatofuz
parents:
diff changeset
1030 return -1;
anatofuz
parents:
diff changeset
1031 #else
anatofuz
parents:
diff changeset
1032 if (fseeko(__file_, -__c, SEEK_CUR))
anatofuz
parents:
diff changeset
1033 return -1;
anatofuz
parents:
diff changeset
1034 #endif
anatofuz
parents:
diff changeset
1035 if (__update_st)
anatofuz
parents:
diff changeset
1036 __st_ = __state;
anatofuz
parents:
diff changeset
1037 __extbufnext_ = __extbufend_ = __extbuf_;
anatofuz
parents:
diff changeset
1038 this->setg(0, 0, 0);
anatofuz
parents:
diff changeset
1039 __cm_ = 0;
anatofuz
parents:
diff changeset
1040 }
anatofuz
parents:
diff changeset
1041 return 0;
anatofuz
parents:
diff changeset
1042 }
anatofuz
parents:
diff changeset
1043
anatofuz
parents:
diff changeset
1044 template <class _CharT, class _Traits>
anatofuz
parents:
diff changeset
1045 void
anatofuz
parents:
diff changeset
1046 basic_filebuf<_CharT, _Traits>::imbue(const locale& __loc)
anatofuz
parents:
diff changeset
1047 {
anatofuz
parents:
diff changeset
1048 sync();
anatofuz
parents:
diff changeset
1049 __cv_ = &use_facet<codecvt<char_type, char, state_type> >(__loc);
anatofuz
parents:
diff changeset
1050 bool __old_anc = __always_noconv_;
anatofuz
parents:
diff changeset
1051 __always_noconv_ = __cv_->always_noconv();
anatofuz
parents:
diff changeset
1052 if (__old_anc != __always_noconv_)
anatofuz
parents:
diff changeset
1053 {
anatofuz
parents:
diff changeset
1054 this->setg(0, 0, 0);
anatofuz
parents:
diff changeset
1055 this->setp(0, 0);
anatofuz
parents:
diff changeset
1056 // invariant, char_type is char, else we couldn't get here
anatofuz
parents:
diff changeset
1057 if (__always_noconv_) // need to dump __intbuf_
anatofuz
parents:
diff changeset
1058 {
anatofuz
parents:
diff changeset
1059 if (__owns_eb_)
anatofuz
parents:
diff changeset
1060 delete [] __extbuf_;
anatofuz
parents:
diff changeset
1061 __owns_eb_ = __owns_ib_;
anatofuz
parents:
diff changeset
1062 __ebs_ = __ibs_;
anatofuz
parents:
diff changeset
1063 __extbuf_ = (char*)__intbuf_;
anatofuz
parents:
diff changeset
1064 __ibs_ = 0;
anatofuz
parents:
diff changeset
1065 __intbuf_ = 0;
anatofuz
parents:
diff changeset
1066 __owns_ib_ = false;
anatofuz
parents:
diff changeset
1067 }
anatofuz
parents:
diff changeset
1068 else // need to obtain an __intbuf_.
anatofuz
parents:
diff changeset
1069 { // If __extbuf_ is user-supplied, use it, else new __intbuf_
anatofuz
parents:
diff changeset
1070 if (!__owns_eb_ && __extbuf_ != __extbuf_min_)
anatofuz
parents:
diff changeset
1071 {
anatofuz
parents:
diff changeset
1072 __ibs_ = __ebs_;
anatofuz
parents:
diff changeset
1073 __intbuf_ = (char_type*)__extbuf_;
anatofuz
parents:
diff changeset
1074 __owns_ib_ = false;
anatofuz
parents:
diff changeset
1075 __extbuf_ = new char[__ebs_];
anatofuz
parents:
diff changeset
1076 __owns_eb_ = true;
anatofuz
parents:
diff changeset
1077 }
anatofuz
parents:
diff changeset
1078 else
anatofuz
parents:
diff changeset
1079 {
anatofuz
parents:
diff changeset
1080 __ibs_ = __ebs_;
anatofuz
parents:
diff changeset
1081 __intbuf_ = new char_type[__ibs_];
anatofuz
parents:
diff changeset
1082 __owns_ib_ = true;
anatofuz
parents:
diff changeset
1083 }
anatofuz
parents:
diff changeset
1084 }
anatofuz
parents:
diff changeset
1085 }
anatofuz
parents:
diff changeset
1086 }
anatofuz
parents:
diff changeset
1087
anatofuz
parents:
diff changeset
1088 template <class _CharT, class _Traits>
anatofuz
parents:
diff changeset
1089 bool
anatofuz
parents:
diff changeset
1090 basic_filebuf<_CharT, _Traits>::__read_mode()
anatofuz
parents:
diff changeset
1091 {
anatofuz
parents:
diff changeset
1092 if (!(__cm_ & ios_base::in))
anatofuz
parents:
diff changeset
1093 {
anatofuz
parents:
diff changeset
1094 this->setp(0, 0);
anatofuz
parents:
diff changeset
1095 if (__always_noconv_)
anatofuz
parents:
diff changeset
1096 this->setg((char_type*)__extbuf_,
anatofuz
parents:
diff changeset
1097 (char_type*)__extbuf_ + __ebs_,
anatofuz
parents:
diff changeset
1098 (char_type*)__extbuf_ + __ebs_);
anatofuz
parents:
diff changeset
1099 else
anatofuz
parents:
diff changeset
1100 this->setg(__intbuf_, __intbuf_ + __ibs_, __intbuf_ + __ibs_);
anatofuz
parents:
diff changeset
1101 __cm_ = ios_base::in;
anatofuz
parents:
diff changeset
1102 return true;
anatofuz
parents:
diff changeset
1103 }
anatofuz
parents:
diff changeset
1104 return false;
anatofuz
parents:
diff changeset
1105 }
anatofuz
parents:
diff changeset
1106
anatofuz
parents:
diff changeset
1107 template <class _CharT, class _Traits>
anatofuz
parents:
diff changeset
1108 void
anatofuz
parents:
diff changeset
1109 basic_filebuf<_CharT, _Traits>::__write_mode()
anatofuz
parents:
diff changeset
1110 {
anatofuz
parents:
diff changeset
1111 if (!(__cm_ & ios_base::out))
anatofuz
parents:
diff changeset
1112 {
anatofuz
parents:
diff changeset
1113 this->setg(0, 0, 0);
anatofuz
parents:
diff changeset
1114 if (__ebs_ > sizeof(__extbuf_min_))
anatofuz
parents:
diff changeset
1115 {
anatofuz
parents:
diff changeset
1116 if (__always_noconv_)
anatofuz
parents:
diff changeset
1117 this->setp((char_type*)__extbuf_,
anatofuz
parents:
diff changeset
1118 (char_type*)__extbuf_ + (__ebs_ - 1));
anatofuz
parents:
diff changeset
1119 else
anatofuz
parents:
diff changeset
1120 this->setp(__intbuf_, __intbuf_ + (__ibs_ - 1));
anatofuz
parents:
diff changeset
1121 }
anatofuz
parents:
diff changeset
1122 else
anatofuz
parents:
diff changeset
1123 this->setp(0, 0);
anatofuz
parents:
diff changeset
1124 __cm_ = ios_base::out;
anatofuz
parents:
diff changeset
1125 }
anatofuz
parents:
diff changeset
1126 }
anatofuz
parents:
diff changeset
1127
anatofuz
parents:
diff changeset
1128 // basic_ifstream
anatofuz
parents:
diff changeset
1129
anatofuz
parents:
diff changeset
1130 template <class _CharT, class _Traits>
anatofuz
parents:
diff changeset
1131 class _LIBCPP_TEMPLATE_VIS basic_ifstream
anatofuz
parents:
diff changeset
1132 : public basic_istream<_CharT, _Traits>
anatofuz
parents:
diff changeset
1133 {
anatofuz
parents:
diff changeset
1134 public:
anatofuz
parents:
diff changeset
1135 typedef _CharT char_type;
anatofuz
parents:
diff changeset
1136 typedef _Traits traits_type;
anatofuz
parents:
diff changeset
1137 typedef typename traits_type::int_type int_type;
anatofuz
parents:
diff changeset
1138 typedef typename traits_type::pos_type pos_type;
anatofuz
parents:
diff changeset
1139 typedef typename traits_type::off_type off_type;
anatofuz
parents:
diff changeset
1140
anatofuz
parents:
diff changeset
1141 _LIBCPP_INLINE_VISIBILITY
anatofuz
parents:
diff changeset
1142 basic_ifstream();
anatofuz
parents:
diff changeset
1143 #ifndef _LIBCPP_HAS_NO_GLOBAL_FILESYSTEM_NAMESPACE
anatofuz
parents:
diff changeset
1144 _LIBCPP_INLINE_VISIBILITY
anatofuz
parents:
diff changeset
1145 explicit basic_ifstream(const char* __s, ios_base::openmode __mode = ios_base::in);
anatofuz
parents:
diff changeset
1146 #ifdef _LIBCPP_HAS_OPEN_WITH_WCHAR
anatofuz
parents:
diff changeset
1147 _LIBCPP_INLINE_VISIBILITY
anatofuz
parents:
diff changeset
1148 explicit basic_ifstream(const wchar_t* __s, ios_base::openmode __mode = ios_base::in);
anatofuz
parents:
diff changeset
1149 #endif
anatofuz
parents:
diff changeset
1150 _LIBCPP_INLINE_VISIBILITY
anatofuz
parents:
diff changeset
1151 explicit basic_ifstream(const string& __s, ios_base::openmode __mode = ios_base::in);
anatofuz
parents:
diff changeset
1152 #if _LIBCPP_STD_VER >= 17
anatofuz
parents:
diff changeset
1153 _LIBCPP_AVAILABILITY_FILESYSTEM _LIBCPP_INLINE_VISIBILITY
anatofuz
parents:
diff changeset
1154 explicit basic_ifstream(const filesystem::path& __p, ios_base::openmode __mode = ios_base::in)
anatofuz
parents:
diff changeset
1155 : basic_ifstream(__p.c_str(), __mode) {}
anatofuz
parents:
diff changeset
1156 #endif // _LIBCPP_STD_VER >= 17
anatofuz
parents:
diff changeset
1157 #endif
anatofuz
parents:
diff changeset
1158 #ifndef _LIBCPP_CXX03_LANG
anatofuz
parents:
diff changeset
1159 _LIBCPP_INLINE_VISIBILITY
anatofuz
parents:
diff changeset
1160 basic_ifstream(basic_ifstream&& __rhs);
anatofuz
parents:
diff changeset
1161
anatofuz
parents:
diff changeset
1162 _LIBCPP_INLINE_VISIBILITY
anatofuz
parents:
diff changeset
1163 basic_ifstream& operator=(basic_ifstream&& __rhs);
anatofuz
parents:
diff changeset
1164 #endif
anatofuz
parents:
diff changeset
1165 _LIBCPP_INLINE_VISIBILITY
anatofuz
parents:
diff changeset
1166 void swap(basic_ifstream& __rhs);
anatofuz
parents:
diff changeset
1167
anatofuz
parents:
diff changeset
1168 _LIBCPP_INLINE_VISIBILITY
anatofuz
parents:
diff changeset
1169 basic_filebuf<char_type, traits_type>* rdbuf() const;
anatofuz
parents:
diff changeset
1170 _LIBCPP_INLINE_VISIBILITY
anatofuz
parents:
diff changeset
1171 bool is_open() const;
anatofuz
parents:
diff changeset
1172 #ifndef _LIBCPP_HAS_NO_GLOBAL_FILESYSTEM_NAMESPACE
anatofuz
parents:
diff changeset
1173 void open(const char* __s, ios_base::openmode __mode = ios_base::in);
anatofuz
parents:
diff changeset
1174 #ifdef _LIBCPP_HAS_OPEN_WITH_WCHAR
anatofuz
parents:
diff changeset
1175 void open(const wchar_t* __s, ios_base::openmode __mode = ios_base::in);
anatofuz
parents:
diff changeset
1176 #endif
anatofuz
parents:
diff changeset
1177 void open(const string& __s, ios_base::openmode __mode = ios_base::in);
anatofuz
parents:
diff changeset
1178 #if _LIBCPP_STD_VER >= 17
anatofuz
parents:
diff changeset
1179 _LIBCPP_AVAILABILITY_FILESYSTEM _LIBCPP_INLINE_VISIBILITY
anatofuz
parents:
diff changeset
1180 void open(const filesystem::path& __p,
anatofuz
parents:
diff changeset
1181 ios_base::openmode __mode = ios_base::in) {
anatofuz
parents:
diff changeset
1182 return open(__p.c_str(), __mode);
anatofuz
parents:
diff changeset
1183 }
anatofuz
parents:
diff changeset
1184 #endif // _LIBCPP_STD_VER >= 17
anatofuz
parents:
diff changeset
1185
anatofuz
parents:
diff changeset
1186 _LIBCPP_INLINE_VISIBILITY
anatofuz
parents:
diff changeset
1187 void __open(int __fd, ios_base::openmode __mode);
anatofuz
parents:
diff changeset
1188 #endif
anatofuz
parents:
diff changeset
1189 _LIBCPP_INLINE_VISIBILITY
anatofuz
parents:
diff changeset
1190 void close();
anatofuz
parents:
diff changeset
1191
anatofuz
parents:
diff changeset
1192 private:
anatofuz
parents:
diff changeset
1193 basic_filebuf<char_type, traits_type> __sb_;
anatofuz
parents:
diff changeset
1194 };
anatofuz
parents:
diff changeset
1195
anatofuz
parents:
diff changeset
1196 template <class _CharT, class _Traits>
anatofuz
parents:
diff changeset
1197 inline
anatofuz
parents:
diff changeset
1198 basic_ifstream<_CharT, _Traits>::basic_ifstream()
anatofuz
parents:
diff changeset
1199 : basic_istream<char_type, traits_type>(&__sb_)
anatofuz
parents:
diff changeset
1200 {
anatofuz
parents:
diff changeset
1201 }
anatofuz
parents:
diff changeset
1202
anatofuz
parents:
diff changeset
1203 #ifndef _LIBCPP_HAS_NO_GLOBAL_FILESYSTEM_NAMESPACE
anatofuz
parents:
diff changeset
1204 template <class _CharT, class _Traits>
anatofuz
parents:
diff changeset
1205 inline
anatofuz
parents:
diff changeset
1206 basic_ifstream<_CharT, _Traits>::basic_ifstream(const char* __s, ios_base::openmode __mode)
anatofuz
parents:
diff changeset
1207 : basic_istream<char_type, traits_type>(&__sb_)
anatofuz
parents:
diff changeset
1208 {
anatofuz
parents:
diff changeset
1209 if (__sb_.open(__s, __mode | ios_base::in) == 0)
anatofuz
parents:
diff changeset
1210 this->setstate(ios_base::failbit);
anatofuz
parents:
diff changeset
1211 }
anatofuz
parents:
diff changeset
1212
anatofuz
parents:
diff changeset
1213 #ifdef _LIBCPP_HAS_OPEN_WITH_WCHAR
anatofuz
parents:
diff changeset
1214 template <class _CharT, class _Traits>
anatofuz
parents:
diff changeset
1215 inline
anatofuz
parents:
diff changeset
1216 basic_ifstream<_CharT, _Traits>::basic_ifstream(const wchar_t* __s, ios_base::openmode __mode)
anatofuz
parents:
diff changeset
1217 : basic_istream<char_type, traits_type>(&__sb_)
anatofuz
parents:
diff changeset
1218 {
anatofuz
parents:
diff changeset
1219 if (__sb_.open(__s, __mode | ios_base::in) == 0)
anatofuz
parents:
diff changeset
1220 this->setstate(ios_base::failbit);
anatofuz
parents:
diff changeset
1221 }
anatofuz
parents:
diff changeset
1222 #endif
anatofuz
parents:
diff changeset
1223
anatofuz
parents:
diff changeset
1224 template <class _CharT, class _Traits>
anatofuz
parents:
diff changeset
1225 inline
anatofuz
parents:
diff changeset
1226 basic_ifstream<_CharT, _Traits>::basic_ifstream(const string& __s, ios_base::openmode __mode)
anatofuz
parents:
diff changeset
1227 : basic_istream<char_type, traits_type>(&__sb_)
anatofuz
parents:
diff changeset
1228 {
anatofuz
parents:
diff changeset
1229 if (__sb_.open(__s, __mode | ios_base::in) == 0)
anatofuz
parents:
diff changeset
1230 this->setstate(ios_base::failbit);
anatofuz
parents:
diff changeset
1231 }
anatofuz
parents:
diff changeset
1232 #endif
anatofuz
parents:
diff changeset
1233
anatofuz
parents:
diff changeset
1234 #ifndef _LIBCPP_CXX03_LANG
anatofuz
parents:
diff changeset
1235
anatofuz
parents:
diff changeset
1236 template <class _CharT, class _Traits>
anatofuz
parents:
diff changeset
1237 inline
anatofuz
parents:
diff changeset
1238 basic_ifstream<_CharT, _Traits>::basic_ifstream(basic_ifstream&& __rhs)
anatofuz
parents:
diff changeset
1239 : basic_istream<char_type, traits_type>(_VSTD::move(__rhs)),
anatofuz
parents:
diff changeset
1240 __sb_(_VSTD::move(__rhs.__sb_))
anatofuz
parents:
diff changeset
1241 {
anatofuz
parents:
diff changeset
1242 this->set_rdbuf(&__sb_);
anatofuz
parents:
diff changeset
1243 }
anatofuz
parents:
diff changeset
1244
anatofuz
parents:
diff changeset
1245 template <class _CharT, class _Traits>
anatofuz
parents:
diff changeset
1246 inline
anatofuz
parents:
diff changeset
1247 basic_ifstream<_CharT, _Traits>&
anatofuz
parents:
diff changeset
1248 basic_ifstream<_CharT, _Traits>::operator=(basic_ifstream&& __rhs)
anatofuz
parents:
diff changeset
1249 {
anatofuz
parents:
diff changeset
1250 basic_istream<char_type, traits_type>::operator=(_VSTD::move(__rhs));
anatofuz
parents:
diff changeset
1251 __sb_ = _VSTD::move(__rhs.__sb_);
anatofuz
parents:
diff changeset
1252 return *this;
anatofuz
parents:
diff changeset
1253 }
anatofuz
parents:
diff changeset
1254
anatofuz
parents:
diff changeset
1255 #endif // _LIBCPP_CXX03_LANG
anatofuz
parents:
diff changeset
1256
anatofuz
parents:
diff changeset
1257 template <class _CharT, class _Traits>
anatofuz
parents:
diff changeset
1258 inline
anatofuz
parents:
diff changeset
1259 void
anatofuz
parents:
diff changeset
1260 basic_ifstream<_CharT, _Traits>::swap(basic_ifstream& __rhs)
anatofuz
parents:
diff changeset
1261 {
anatofuz
parents:
diff changeset
1262 basic_istream<char_type, traits_type>::swap(__rhs);
anatofuz
parents:
diff changeset
1263 __sb_.swap(__rhs.__sb_);
anatofuz
parents:
diff changeset
1264 }
anatofuz
parents:
diff changeset
1265
anatofuz
parents:
diff changeset
1266 template <class _CharT, class _Traits>
anatofuz
parents:
diff changeset
1267 inline _LIBCPP_INLINE_VISIBILITY
anatofuz
parents:
diff changeset
1268 void
anatofuz
parents:
diff changeset
1269 swap(basic_ifstream<_CharT, _Traits>& __x, basic_ifstream<_CharT, _Traits>& __y)
anatofuz
parents:
diff changeset
1270 {
anatofuz
parents:
diff changeset
1271 __x.swap(__y);
anatofuz
parents:
diff changeset
1272 }
anatofuz
parents:
diff changeset
1273
anatofuz
parents:
diff changeset
1274 template <class _CharT, class _Traits>
anatofuz
parents:
diff changeset
1275 inline
anatofuz
parents:
diff changeset
1276 basic_filebuf<_CharT, _Traits>*
anatofuz
parents:
diff changeset
1277 basic_ifstream<_CharT, _Traits>::rdbuf() const
anatofuz
parents:
diff changeset
1278 {
anatofuz
parents:
diff changeset
1279 return const_cast<basic_filebuf<char_type, traits_type>*>(&__sb_);
anatofuz
parents:
diff changeset
1280 }
anatofuz
parents:
diff changeset
1281
anatofuz
parents:
diff changeset
1282 template <class _CharT, class _Traits>
anatofuz
parents:
diff changeset
1283 inline
anatofuz
parents:
diff changeset
1284 bool
anatofuz
parents:
diff changeset
1285 basic_ifstream<_CharT, _Traits>::is_open() const
anatofuz
parents:
diff changeset
1286 {
anatofuz
parents:
diff changeset
1287 return __sb_.is_open();
anatofuz
parents:
diff changeset
1288 }
anatofuz
parents:
diff changeset
1289
anatofuz
parents:
diff changeset
1290 #ifndef _LIBCPP_HAS_NO_GLOBAL_FILESYSTEM_NAMESPACE
anatofuz
parents:
diff changeset
1291 template <class _CharT, class _Traits>
anatofuz
parents:
diff changeset
1292 void
anatofuz
parents:
diff changeset
1293 basic_ifstream<_CharT, _Traits>::open(const char* __s, ios_base::openmode __mode)
anatofuz
parents:
diff changeset
1294 {
anatofuz
parents:
diff changeset
1295 if (__sb_.open(__s, __mode | ios_base::in))
anatofuz
parents:
diff changeset
1296 this->clear();
anatofuz
parents:
diff changeset
1297 else
anatofuz
parents:
diff changeset
1298 this->setstate(ios_base::failbit);
anatofuz
parents:
diff changeset
1299 }
anatofuz
parents:
diff changeset
1300
anatofuz
parents:
diff changeset
1301 #ifdef _LIBCPP_HAS_OPEN_WITH_WCHAR
anatofuz
parents:
diff changeset
1302 template <class _CharT, class _Traits>
anatofuz
parents:
diff changeset
1303 void
anatofuz
parents:
diff changeset
1304 basic_ifstream<_CharT, _Traits>::open(const wchar_t* __s, ios_base::openmode __mode)
anatofuz
parents:
diff changeset
1305 {
anatofuz
parents:
diff changeset
1306 if (__sb_.open(__s, __mode | ios_base::in))
anatofuz
parents:
diff changeset
1307 this->clear();
anatofuz
parents:
diff changeset
1308 else
anatofuz
parents:
diff changeset
1309 this->setstate(ios_base::failbit);
anatofuz
parents:
diff changeset
1310 }
anatofuz
parents:
diff changeset
1311 #endif
anatofuz
parents:
diff changeset
1312
anatofuz
parents:
diff changeset
1313 template <class _CharT, class _Traits>
anatofuz
parents:
diff changeset
1314 void
anatofuz
parents:
diff changeset
1315 basic_ifstream<_CharT, _Traits>::open(const string& __s, ios_base::openmode __mode)
anatofuz
parents:
diff changeset
1316 {
anatofuz
parents:
diff changeset
1317 if (__sb_.open(__s, __mode | ios_base::in))
anatofuz
parents:
diff changeset
1318 this->clear();
anatofuz
parents:
diff changeset
1319 else
anatofuz
parents:
diff changeset
1320 this->setstate(ios_base::failbit);
anatofuz
parents:
diff changeset
1321 }
anatofuz
parents:
diff changeset
1322
anatofuz
parents:
diff changeset
1323 template <class _CharT, class _Traits>
anatofuz
parents:
diff changeset
1324 void basic_ifstream<_CharT, _Traits>::__open(int __fd,
anatofuz
parents:
diff changeset
1325 ios_base::openmode __mode) {
anatofuz
parents:
diff changeset
1326 if (__sb_.__open(__fd, __mode | ios_base::in))
anatofuz
parents:
diff changeset
1327 this->clear();
anatofuz
parents:
diff changeset
1328 else
anatofuz
parents:
diff changeset
1329 this->setstate(ios_base::failbit);
anatofuz
parents:
diff changeset
1330 }
anatofuz
parents:
diff changeset
1331 #endif
anatofuz
parents:
diff changeset
1332
anatofuz
parents:
diff changeset
1333 template <class _CharT, class _Traits>
anatofuz
parents:
diff changeset
1334 inline
anatofuz
parents:
diff changeset
1335 void
anatofuz
parents:
diff changeset
1336 basic_ifstream<_CharT, _Traits>::close()
anatofuz
parents:
diff changeset
1337 {
anatofuz
parents:
diff changeset
1338 if (__sb_.close() == 0)
anatofuz
parents:
diff changeset
1339 this->setstate(ios_base::failbit);
anatofuz
parents:
diff changeset
1340 }
anatofuz
parents:
diff changeset
1341
anatofuz
parents:
diff changeset
1342 // basic_ofstream
anatofuz
parents:
diff changeset
1343
anatofuz
parents:
diff changeset
1344 template <class _CharT, class _Traits>
anatofuz
parents:
diff changeset
1345 class _LIBCPP_TEMPLATE_VIS basic_ofstream
anatofuz
parents:
diff changeset
1346 : public basic_ostream<_CharT, _Traits>
anatofuz
parents:
diff changeset
1347 {
anatofuz
parents:
diff changeset
1348 public:
anatofuz
parents:
diff changeset
1349 typedef _CharT char_type;
anatofuz
parents:
diff changeset
1350 typedef _Traits traits_type;
anatofuz
parents:
diff changeset
1351 typedef typename traits_type::int_type int_type;
anatofuz
parents:
diff changeset
1352 typedef typename traits_type::pos_type pos_type;
anatofuz
parents:
diff changeset
1353 typedef typename traits_type::off_type off_type;
anatofuz
parents:
diff changeset
1354
anatofuz
parents:
diff changeset
1355 _LIBCPP_INLINE_VISIBILITY
anatofuz
parents:
diff changeset
1356 basic_ofstream();
anatofuz
parents:
diff changeset
1357 _LIBCPP_INLINE_VISIBILITY
anatofuz
parents:
diff changeset
1358 explicit basic_ofstream(const char* __s, ios_base::openmode __mode = ios_base::out);
anatofuz
parents:
diff changeset
1359 #ifdef _LIBCPP_HAS_OPEN_WITH_WCHAR
anatofuz
parents:
diff changeset
1360 _LIBCPP_INLINE_VISIBILITY
anatofuz
parents:
diff changeset
1361 explicit basic_ofstream(const wchar_t* __s, ios_base::openmode __mode = ios_base::out);
anatofuz
parents:
diff changeset
1362 #endif
anatofuz
parents:
diff changeset
1363 _LIBCPP_INLINE_VISIBILITY
anatofuz
parents:
diff changeset
1364 explicit basic_ofstream(const string& __s, ios_base::openmode __mode = ios_base::out);
anatofuz
parents:
diff changeset
1365
anatofuz
parents:
diff changeset
1366 #if _LIBCPP_STD_VER >= 17
anatofuz
parents:
diff changeset
1367 _LIBCPP_AVAILABILITY_FILESYSTEM _LIBCPP_INLINE_VISIBILITY
anatofuz
parents:
diff changeset
1368 explicit basic_ofstream(const filesystem::path& __p, ios_base::openmode __mode = ios_base::out)
anatofuz
parents:
diff changeset
1369 : basic_ofstream(__p.c_str(), __mode) {}
anatofuz
parents:
diff changeset
1370 #endif // _LIBCPP_STD_VER >= 17
anatofuz
parents:
diff changeset
1371
anatofuz
parents:
diff changeset
1372 #ifndef _LIBCPP_CXX03_LANG
anatofuz
parents:
diff changeset
1373 _LIBCPP_INLINE_VISIBILITY
anatofuz
parents:
diff changeset
1374 basic_ofstream(basic_ofstream&& __rhs);
anatofuz
parents:
diff changeset
1375
anatofuz
parents:
diff changeset
1376 _LIBCPP_INLINE_VISIBILITY
anatofuz
parents:
diff changeset
1377 basic_ofstream& operator=(basic_ofstream&& __rhs);
anatofuz
parents:
diff changeset
1378 #endif
anatofuz
parents:
diff changeset
1379 _LIBCPP_INLINE_VISIBILITY
anatofuz
parents:
diff changeset
1380 void swap(basic_ofstream& __rhs);
anatofuz
parents:
diff changeset
1381
anatofuz
parents:
diff changeset
1382 _LIBCPP_INLINE_VISIBILITY
anatofuz
parents:
diff changeset
1383 basic_filebuf<char_type, traits_type>* rdbuf() const;
anatofuz
parents:
diff changeset
1384 _LIBCPP_INLINE_VISIBILITY
anatofuz
parents:
diff changeset
1385 bool is_open() const;
anatofuz
parents:
diff changeset
1386 #ifndef _LIBCPP_HAS_NO_GLOBAL_FILESYSTEM_NAMESPACE
anatofuz
parents:
diff changeset
1387 void open(const char* __s, ios_base::openmode __mode = ios_base::out);
anatofuz
parents:
diff changeset
1388 #ifdef _LIBCPP_HAS_OPEN_WITH_WCHAR
anatofuz
parents:
diff changeset
1389 void open(const wchar_t* __s, ios_base::openmode __mode = ios_base::out);
anatofuz
parents:
diff changeset
1390 #endif
anatofuz
parents:
diff changeset
1391 void open(const string& __s, ios_base::openmode __mode = ios_base::out);
anatofuz
parents:
diff changeset
1392
anatofuz
parents:
diff changeset
1393 #if _LIBCPP_STD_VER >= 17
anatofuz
parents:
diff changeset
1394 _LIBCPP_AVAILABILITY_FILESYSTEM _LIBCPP_INLINE_VISIBILITY
anatofuz
parents:
diff changeset
1395 void open(const filesystem::path& __p, ios_base::openmode __mode = ios_base::out)
anatofuz
parents:
diff changeset
1396 { return open(__p.c_str(), __mode); }
anatofuz
parents:
diff changeset
1397 #endif // _LIBCPP_STD_VER >= 17
anatofuz
parents:
diff changeset
1398
anatofuz
parents:
diff changeset
1399 _LIBCPP_INLINE_VISIBILITY
anatofuz
parents:
diff changeset
1400 void __open(int __fd, ios_base::openmode __mode);
anatofuz
parents:
diff changeset
1401 #endif
anatofuz
parents:
diff changeset
1402 _LIBCPP_INLINE_VISIBILITY
anatofuz
parents:
diff changeset
1403 void close();
anatofuz
parents:
diff changeset
1404
anatofuz
parents:
diff changeset
1405 private:
anatofuz
parents:
diff changeset
1406 basic_filebuf<char_type, traits_type> __sb_;
anatofuz
parents:
diff changeset
1407 };
anatofuz
parents:
diff changeset
1408
anatofuz
parents:
diff changeset
1409 template <class _CharT, class _Traits>
anatofuz
parents:
diff changeset
1410 inline
anatofuz
parents:
diff changeset
1411 basic_ofstream<_CharT, _Traits>::basic_ofstream()
anatofuz
parents:
diff changeset
1412 : basic_ostream<char_type, traits_type>(&__sb_)
anatofuz
parents:
diff changeset
1413 {
anatofuz
parents:
diff changeset
1414 }
anatofuz
parents:
diff changeset
1415
anatofuz
parents:
diff changeset
1416 #ifndef _LIBCPP_HAS_NO_GLOBAL_FILESYSTEM_NAMESPACE
anatofuz
parents:
diff changeset
1417 template <class _CharT, class _Traits>
anatofuz
parents:
diff changeset
1418 inline
anatofuz
parents:
diff changeset
1419 basic_ofstream<_CharT, _Traits>::basic_ofstream(const char* __s, ios_base::openmode __mode)
anatofuz
parents:
diff changeset
1420 : basic_ostream<char_type, traits_type>(&__sb_)
anatofuz
parents:
diff changeset
1421 {
anatofuz
parents:
diff changeset
1422 if (__sb_.open(__s, __mode | ios_base::out) == 0)
anatofuz
parents:
diff changeset
1423 this->setstate(ios_base::failbit);
anatofuz
parents:
diff changeset
1424 }
anatofuz
parents:
diff changeset
1425
anatofuz
parents:
diff changeset
1426 #ifdef _LIBCPP_HAS_OPEN_WITH_WCHAR
anatofuz
parents:
diff changeset
1427 template <class _CharT, class _Traits>
anatofuz
parents:
diff changeset
1428 inline
anatofuz
parents:
diff changeset
1429 basic_ofstream<_CharT, _Traits>::basic_ofstream(const wchar_t* __s, ios_base::openmode __mode)
anatofuz
parents:
diff changeset
1430 : basic_ostream<char_type, traits_type>(&__sb_)
anatofuz
parents:
diff changeset
1431 {
anatofuz
parents:
diff changeset
1432 if (__sb_.open(__s, __mode | ios_base::out) == 0)
anatofuz
parents:
diff changeset
1433 this->setstate(ios_base::failbit);
anatofuz
parents:
diff changeset
1434 }
anatofuz
parents:
diff changeset
1435 #endif
anatofuz
parents:
diff changeset
1436
anatofuz
parents:
diff changeset
1437 template <class _CharT, class _Traits>
anatofuz
parents:
diff changeset
1438 inline
anatofuz
parents:
diff changeset
1439 basic_ofstream<_CharT, _Traits>::basic_ofstream(const string& __s, ios_base::openmode __mode)
anatofuz
parents:
diff changeset
1440 : basic_ostream<char_type, traits_type>(&__sb_)
anatofuz
parents:
diff changeset
1441 {
anatofuz
parents:
diff changeset
1442 if (__sb_.open(__s, __mode | ios_base::out) == 0)
anatofuz
parents:
diff changeset
1443 this->setstate(ios_base::failbit);
anatofuz
parents:
diff changeset
1444 }
anatofuz
parents:
diff changeset
1445 #endif
anatofuz
parents:
diff changeset
1446
anatofuz
parents:
diff changeset
1447 #ifndef _LIBCPP_CXX03_LANG
anatofuz
parents:
diff changeset
1448
anatofuz
parents:
diff changeset
1449 template <class _CharT, class _Traits>
anatofuz
parents:
diff changeset
1450 inline
anatofuz
parents:
diff changeset
1451 basic_ofstream<_CharT, _Traits>::basic_ofstream(basic_ofstream&& __rhs)
anatofuz
parents:
diff changeset
1452 : basic_ostream<char_type, traits_type>(_VSTD::move(__rhs)),
anatofuz
parents:
diff changeset
1453 __sb_(_VSTD::move(__rhs.__sb_))
anatofuz
parents:
diff changeset
1454 {
anatofuz
parents:
diff changeset
1455 this->set_rdbuf(&__sb_);
anatofuz
parents:
diff changeset
1456 }
anatofuz
parents:
diff changeset
1457
anatofuz
parents:
diff changeset
1458 template <class _CharT, class _Traits>
anatofuz
parents:
diff changeset
1459 inline
anatofuz
parents:
diff changeset
1460 basic_ofstream<_CharT, _Traits>&
anatofuz
parents:
diff changeset
1461 basic_ofstream<_CharT, _Traits>::operator=(basic_ofstream&& __rhs)
anatofuz
parents:
diff changeset
1462 {
anatofuz
parents:
diff changeset
1463 basic_ostream<char_type, traits_type>::operator=(_VSTD::move(__rhs));
anatofuz
parents:
diff changeset
1464 __sb_ = _VSTD::move(__rhs.__sb_);
anatofuz
parents:
diff changeset
1465 return *this;
anatofuz
parents:
diff changeset
1466 }
anatofuz
parents:
diff changeset
1467
anatofuz
parents:
diff changeset
1468 #endif // _LIBCPP_CXX03_LANG
anatofuz
parents:
diff changeset
1469
anatofuz
parents:
diff changeset
1470 template <class _CharT, class _Traits>
anatofuz
parents:
diff changeset
1471 inline
anatofuz
parents:
diff changeset
1472 void
anatofuz
parents:
diff changeset
1473 basic_ofstream<_CharT, _Traits>::swap(basic_ofstream& __rhs)
anatofuz
parents:
diff changeset
1474 {
anatofuz
parents:
diff changeset
1475 basic_ostream<char_type, traits_type>::swap(__rhs);
anatofuz
parents:
diff changeset
1476 __sb_.swap(__rhs.__sb_);
anatofuz
parents:
diff changeset
1477 }
anatofuz
parents:
diff changeset
1478
anatofuz
parents:
diff changeset
1479 template <class _CharT, class _Traits>
anatofuz
parents:
diff changeset
1480 inline _LIBCPP_INLINE_VISIBILITY
anatofuz
parents:
diff changeset
1481 void
anatofuz
parents:
diff changeset
1482 swap(basic_ofstream<_CharT, _Traits>& __x, basic_ofstream<_CharT, _Traits>& __y)
anatofuz
parents:
diff changeset
1483 {
anatofuz
parents:
diff changeset
1484 __x.swap(__y);
anatofuz
parents:
diff changeset
1485 }
anatofuz
parents:
diff changeset
1486
anatofuz
parents:
diff changeset
1487 template <class _CharT, class _Traits>
anatofuz
parents:
diff changeset
1488 inline
anatofuz
parents:
diff changeset
1489 basic_filebuf<_CharT, _Traits>*
anatofuz
parents:
diff changeset
1490 basic_ofstream<_CharT, _Traits>::rdbuf() const
anatofuz
parents:
diff changeset
1491 {
anatofuz
parents:
diff changeset
1492 return const_cast<basic_filebuf<char_type, traits_type>*>(&__sb_);
anatofuz
parents:
diff changeset
1493 }
anatofuz
parents:
diff changeset
1494
anatofuz
parents:
diff changeset
1495 template <class _CharT, class _Traits>
anatofuz
parents:
diff changeset
1496 inline
anatofuz
parents:
diff changeset
1497 bool
anatofuz
parents:
diff changeset
1498 basic_ofstream<_CharT, _Traits>::is_open() const
anatofuz
parents:
diff changeset
1499 {
anatofuz
parents:
diff changeset
1500 return __sb_.is_open();
anatofuz
parents:
diff changeset
1501 }
anatofuz
parents:
diff changeset
1502
anatofuz
parents:
diff changeset
1503 #ifndef _LIBCPP_HAS_NO_GLOBAL_FILESYSTEM_NAMESPACE
anatofuz
parents:
diff changeset
1504 template <class _CharT, class _Traits>
anatofuz
parents:
diff changeset
1505 void
anatofuz
parents:
diff changeset
1506 basic_ofstream<_CharT, _Traits>::open(const char* __s, ios_base::openmode __mode)
anatofuz
parents:
diff changeset
1507 {
anatofuz
parents:
diff changeset
1508 if (__sb_.open(__s, __mode | ios_base::out))
anatofuz
parents:
diff changeset
1509 this->clear();
anatofuz
parents:
diff changeset
1510 else
anatofuz
parents:
diff changeset
1511 this->setstate(ios_base::failbit);
anatofuz
parents:
diff changeset
1512 }
anatofuz
parents:
diff changeset
1513
anatofuz
parents:
diff changeset
1514 #ifdef _LIBCPP_HAS_OPEN_WITH_WCHAR
anatofuz
parents:
diff changeset
1515 template <class _CharT, class _Traits>
anatofuz
parents:
diff changeset
1516 void
anatofuz
parents:
diff changeset
1517 basic_ofstream<_CharT, _Traits>::open(const wchar_t* __s, ios_base::openmode __mode)
anatofuz
parents:
diff changeset
1518 {
anatofuz
parents:
diff changeset
1519 if (__sb_.open(__s, __mode | ios_base::out))
anatofuz
parents:
diff changeset
1520 this->clear();
anatofuz
parents:
diff changeset
1521 else
anatofuz
parents:
diff changeset
1522 this->setstate(ios_base::failbit);
anatofuz
parents:
diff changeset
1523 }
anatofuz
parents:
diff changeset
1524 #endif
anatofuz
parents:
diff changeset
1525
anatofuz
parents:
diff changeset
1526 template <class _CharT, class _Traits>
anatofuz
parents:
diff changeset
1527 void
anatofuz
parents:
diff changeset
1528 basic_ofstream<_CharT, _Traits>::open(const string& __s, ios_base::openmode __mode)
anatofuz
parents:
diff changeset
1529 {
anatofuz
parents:
diff changeset
1530 if (__sb_.open(__s, __mode | ios_base::out))
anatofuz
parents:
diff changeset
1531 this->clear();
anatofuz
parents:
diff changeset
1532 else
anatofuz
parents:
diff changeset
1533 this->setstate(ios_base::failbit);
anatofuz
parents:
diff changeset
1534 }
anatofuz
parents:
diff changeset
1535
anatofuz
parents:
diff changeset
1536 template <class _CharT, class _Traits>
anatofuz
parents:
diff changeset
1537 void basic_ofstream<_CharT, _Traits>::__open(int __fd,
anatofuz
parents:
diff changeset
1538 ios_base::openmode __mode) {
anatofuz
parents:
diff changeset
1539 if (__sb_.__open(__fd, __mode | ios_base::out))
anatofuz
parents:
diff changeset
1540 this->clear();
anatofuz
parents:
diff changeset
1541 else
anatofuz
parents:
diff changeset
1542 this->setstate(ios_base::failbit);
anatofuz
parents:
diff changeset
1543 }
anatofuz
parents:
diff changeset
1544 #endif
anatofuz
parents:
diff changeset
1545
anatofuz
parents:
diff changeset
1546 template <class _CharT, class _Traits>
anatofuz
parents:
diff changeset
1547 inline
anatofuz
parents:
diff changeset
1548 void
anatofuz
parents:
diff changeset
1549 basic_ofstream<_CharT, _Traits>::close()
anatofuz
parents:
diff changeset
1550 {
anatofuz
parents:
diff changeset
1551 if (__sb_.close() == 0)
anatofuz
parents:
diff changeset
1552 this->setstate(ios_base::failbit);
anatofuz
parents:
diff changeset
1553 }
anatofuz
parents:
diff changeset
1554
anatofuz
parents:
diff changeset
1555 // basic_fstream
anatofuz
parents:
diff changeset
1556
anatofuz
parents:
diff changeset
1557 template <class _CharT, class _Traits>
anatofuz
parents:
diff changeset
1558 class _LIBCPP_TEMPLATE_VIS basic_fstream
anatofuz
parents:
diff changeset
1559 : public basic_iostream<_CharT, _Traits>
anatofuz
parents:
diff changeset
1560 {
anatofuz
parents:
diff changeset
1561 public:
anatofuz
parents:
diff changeset
1562 typedef _CharT char_type;
anatofuz
parents:
diff changeset
1563 typedef _Traits traits_type;
anatofuz
parents:
diff changeset
1564 typedef typename traits_type::int_type int_type;
anatofuz
parents:
diff changeset
1565 typedef typename traits_type::pos_type pos_type;
anatofuz
parents:
diff changeset
1566 typedef typename traits_type::off_type off_type;
anatofuz
parents:
diff changeset
1567
anatofuz
parents:
diff changeset
1568 _LIBCPP_INLINE_VISIBILITY
anatofuz
parents:
diff changeset
1569 basic_fstream();
anatofuz
parents:
diff changeset
1570 #ifndef _LIBCPP_HAS_NO_GLOBAL_FILESYSTEM_NAMESPACE
anatofuz
parents:
diff changeset
1571 _LIBCPP_INLINE_VISIBILITY
anatofuz
parents:
diff changeset
1572 explicit basic_fstream(const char* __s, ios_base::openmode __mode = ios_base::in | ios_base::out);
anatofuz
parents:
diff changeset
1573 #ifdef _LIBCPP_HAS_OPEN_WITH_WCHAR
anatofuz
parents:
diff changeset
1574 _LIBCPP_INLINE_VISIBILITY
anatofuz
parents:
diff changeset
1575 explicit basic_fstream(const wchar_t* __s, ios_base::openmode __mode = ios_base::in | ios_base::out);
anatofuz
parents:
diff changeset
1576 #endif
anatofuz
parents:
diff changeset
1577 _LIBCPP_INLINE_VISIBILITY
anatofuz
parents:
diff changeset
1578 explicit basic_fstream(const string& __s, ios_base::openmode __mode = ios_base::in | ios_base::out);
anatofuz
parents:
diff changeset
1579
anatofuz
parents:
diff changeset
1580 #if _LIBCPP_STD_VER >= 17
anatofuz
parents:
diff changeset
1581 _LIBCPP_AVAILABILITY_FILESYSTEM _LIBCPP_INLINE_VISIBILITY
anatofuz
parents:
diff changeset
1582 explicit basic_fstream(const filesystem::path& __p, ios_base::openmode __mode = ios_base::in | ios_base::out)
anatofuz
parents:
diff changeset
1583 : basic_fstream(__p.c_str(), __mode) {}
anatofuz
parents:
diff changeset
1584 #endif // _LIBCPP_STD_VER >= 17
anatofuz
parents:
diff changeset
1585
anatofuz
parents:
diff changeset
1586 #endif
anatofuz
parents:
diff changeset
1587 #ifndef _LIBCPP_CXX03_LANG
anatofuz
parents:
diff changeset
1588 _LIBCPP_INLINE_VISIBILITY
anatofuz
parents:
diff changeset
1589 basic_fstream(basic_fstream&& __rhs);
anatofuz
parents:
diff changeset
1590
anatofuz
parents:
diff changeset
1591 _LIBCPP_INLINE_VISIBILITY
anatofuz
parents:
diff changeset
1592 basic_fstream& operator=(basic_fstream&& __rhs);
anatofuz
parents:
diff changeset
1593 #endif
anatofuz
parents:
diff changeset
1594 _LIBCPP_INLINE_VISIBILITY
anatofuz
parents:
diff changeset
1595 void swap(basic_fstream& __rhs);
anatofuz
parents:
diff changeset
1596
anatofuz
parents:
diff changeset
1597 _LIBCPP_INLINE_VISIBILITY
anatofuz
parents:
diff changeset
1598 basic_filebuf<char_type, traits_type>* rdbuf() const;
anatofuz
parents:
diff changeset
1599 _LIBCPP_INLINE_VISIBILITY
anatofuz
parents:
diff changeset
1600 bool is_open() const;
anatofuz
parents:
diff changeset
1601 #ifndef _LIBCPP_HAS_NO_GLOBAL_FILESYSTEM_NAMESPACE
anatofuz
parents:
diff changeset
1602 void open(const char* __s, ios_base::openmode __mode = ios_base::in | ios_base::out);
anatofuz
parents:
diff changeset
1603 #ifdef _LIBCPP_HAS_OPEN_WITH_WCHAR
anatofuz
parents:
diff changeset
1604 void open(const wchar_t* __s, ios_base::openmode __mode = ios_base::in | ios_base::out);
anatofuz
parents:
diff changeset
1605 #endif
anatofuz
parents:
diff changeset
1606 void open(const string& __s, ios_base::openmode __mode = ios_base::in | ios_base::out);
anatofuz
parents:
diff changeset
1607
anatofuz
parents:
diff changeset
1608 #if _LIBCPP_STD_VER >= 17
anatofuz
parents:
diff changeset
1609 _LIBCPP_AVAILABILITY_FILESYSTEM _LIBCPP_INLINE_VISIBILITY
anatofuz
parents:
diff changeset
1610 void open(const filesystem::path& __p, ios_base::openmode __mode = ios_base::in|ios_base::out)
anatofuz
parents:
diff changeset
1611 { return open(__p.c_str(), __mode); }
anatofuz
parents:
diff changeset
1612 #endif // _LIBCPP_STD_VER >= 17
anatofuz
parents:
diff changeset
1613
anatofuz
parents:
diff changeset
1614 #endif
anatofuz
parents:
diff changeset
1615 _LIBCPP_INLINE_VISIBILITY
anatofuz
parents:
diff changeset
1616 void close();
anatofuz
parents:
diff changeset
1617
anatofuz
parents:
diff changeset
1618 private:
anatofuz
parents:
diff changeset
1619 basic_filebuf<char_type, traits_type> __sb_;
anatofuz
parents:
diff changeset
1620 };
anatofuz
parents:
diff changeset
1621
anatofuz
parents:
diff changeset
1622 template <class _CharT, class _Traits>
anatofuz
parents:
diff changeset
1623 inline
anatofuz
parents:
diff changeset
1624 basic_fstream<_CharT, _Traits>::basic_fstream()
anatofuz
parents:
diff changeset
1625 : basic_iostream<char_type, traits_type>(&__sb_)
anatofuz
parents:
diff changeset
1626 {
anatofuz
parents:
diff changeset
1627 }
anatofuz
parents:
diff changeset
1628
anatofuz
parents:
diff changeset
1629 #ifndef _LIBCPP_HAS_NO_GLOBAL_FILESYSTEM_NAMESPACE
anatofuz
parents:
diff changeset
1630 template <class _CharT, class _Traits>
anatofuz
parents:
diff changeset
1631 inline
anatofuz
parents:
diff changeset
1632 basic_fstream<_CharT, _Traits>::basic_fstream(const char* __s, ios_base::openmode __mode)
anatofuz
parents:
diff changeset
1633 : basic_iostream<char_type, traits_type>(&__sb_)
anatofuz
parents:
diff changeset
1634 {
anatofuz
parents:
diff changeset
1635 if (__sb_.open(__s, __mode) == 0)
anatofuz
parents:
diff changeset
1636 this->setstate(ios_base::failbit);
anatofuz
parents:
diff changeset
1637 }
anatofuz
parents:
diff changeset
1638
anatofuz
parents:
diff changeset
1639 #ifdef _LIBCPP_HAS_OPEN_WITH_WCHAR
anatofuz
parents:
diff changeset
1640 template <class _CharT, class _Traits>
anatofuz
parents:
diff changeset
1641 inline
anatofuz
parents:
diff changeset
1642 basic_fstream<_CharT, _Traits>::basic_fstream(const wchar_t* __s, ios_base::openmode __mode)
anatofuz
parents:
diff changeset
1643 : basic_iostream<char_type, traits_type>(&__sb_)
anatofuz
parents:
diff changeset
1644 {
anatofuz
parents:
diff changeset
1645 if (__sb_.open(__s, __mode) == 0)
anatofuz
parents:
diff changeset
1646 this->setstate(ios_base::failbit);
anatofuz
parents:
diff changeset
1647 }
anatofuz
parents:
diff changeset
1648 #endif
anatofuz
parents:
diff changeset
1649
anatofuz
parents:
diff changeset
1650 template <class _CharT, class _Traits>
anatofuz
parents:
diff changeset
1651 inline
anatofuz
parents:
diff changeset
1652 basic_fstream<_CharT, _Traits>::basic_fstream(const string& __s, ios_base::openmode __mode)
anatofuz
parents:
diff changeset
1653 : basic_iostream<char_type, traits_type>(&__sb_)
anatofuz
parents:
diff changeset
1654 {
anatofuz
parents:
diff changeset
1655 if (__sb_.open(__s, __mode) == 0)
anatofuz
parents:
diff changeset
1656 this->setstate(ios_base::failbit);
anatofuz
parents:
diff changeset
1657 }
anatofuz
parents:
diff changeset
1658 #endif
anatofuz
parents:
diff changeset
1659
anatofuz
parents:
diff changeset
1660 #ifndef _LIBCPP_CXX03_LANG
anatofuz
parents:
diff changeset
1661
anatofuz
parents:
diff changeset
1662 template <class _CharT, class _Traits>
anatofuz
parents:
diff changeset
1663 inline
anatofuz
parents:
diff changeset
1664 basic_fstream<_CharT, _Traits>::basic_fstream(basic_fstream&& __rhs)
anatofuz
parents:
diff changeset
1665 : basic_iostream<char_type, traits_type>(_VSTD::move(__rhs)),
anatofuz
parents:
diff changeset
1666 __sb_(_VSTD::move(__rhs.__sb_))
anatofuz
parents:
diff changeset
1667 {
anatofuz
parents:
diff changeset
1668 this->set_rdbuf(&__sb_);
anatofuz
parents:
diff changeset
1669 }
anatofuz
parents:
diff changeset
1670
anatofuz
parents:
diff changeset
1671 template <class _CharT, class _Traits>
anatofuz
parents:
diff changeset
1672 inline
anatofuz
parents:
diff changeset
1673 basic_fstream<_CharT, _Traits>&
anatofuz
parents:
diff changeset
1674 basic_fstream<_CharT, _Traits>::operator=(basic_fstream&& __rhs)
anatofuz
parents:
diff changeset
1675 {
anatofuz
parents:
diff changeset
1676 basic_iostream<char_type, traits_type>::operator=(_VSTD::move(__rhs));
anatofuz
parents:
diff changeset
1677 __sb_ = _VSTD::move(__rhs.__sb_);
anatofuz
parents:
diff changeset
1678 return *this;
anatofuz
parents:
diff changeset
1679 }
anatofuz
parents:
diff changeset
1680
anatofuz
parents:
diff changeset
1681 #endif // _LIBCPP_CXX03_LANG
anatofuz
parents:
diff changeset
1682
anatofuz
parents:
diff changeset
1683 template <class _CharT, class _Traits>
anatofuz
parents:
diff changeset
1684 inline
anatofuz
parents:
diff changeset
1685 void
anatofuz
parents:
diff changeset
1686 basic_fstream<_CharT, _Traits>::swap(basic_fstream& __rhs)
anatofuz
parents:
diff changeset
1687 {
anatofuz
parents:
diff changeset
1688 basic_iostream<char_type, traits_type>::swap(__rhs);
anatofuz
parents:
diff changeset
1689 __sb_.swap(__rhs.__sb_);
anatofuz
parents:
diff changeset
1690 }
anatofuz
parents:
diff changeset
1691
anatofuz
parents:
diff changeset
1692 template <class _CharT, class _Traits>
anatofuz
parents:
diff changeset
1693 inline _LIBCPP_INLINE_VISIBILITY
anatofuz
parents:
diff changeset
1694 void
anatofuz
parents:
diff changeset
1695 swap(basic_fstream<_CharT, _Traits>& __x, basic_fstream<_CharT, _Traits>& __y)
anatofuz
parents:
diff changeset
1696 {
anatofuz
parents:
diff changeset
1697 __x.swap(__y);
anatofuz
parents:
diff changeset
1698 }
anatofuz
parents:
diff changeset
1699
anatofuz
parents:
diff changeset
1700 template <class _CharT, class _Traits>
anatofuz
parents:
diff changeset
1701 inline
anatofuz
parents:
diff changeset
1702 basic_filebuf<_CharT, _Traits>*
anatofuz
parents:
diff changeset
1703 basic_fstream<_CharT, _Traits>::rdbuf() const
anatofuz
parents:
diff changeset
1704 {
anatofuz
parents:
diff changeset
1705 return const_cast<basic_filebuf<char_type, traits_type>*>(&__sb_);
anatofuz
parents:
diff changeset
1706 }
anatofuz
parents:
diff changeset
1707
anatofuz
parents:
diff changeset
1708 template <class _CharT, class _Traits>
anatofuz
parents:
diff changeset
1709 inline
anatofuz
parents:
diff changeset
1710 bool
anatofuz
parents:
diff changeset
1711 basic_fstream<_CharT, _Traits>::is_open() const
anatofuz
parents:
diff changeset
1712 {
anatofuz
parents:
diff changeset
1713 return __sb_.is_open();
anatofuz
parents:
diff changeset
1714 }
anatofuz
parents:
diff changeset
1715
anatofuz
parents:
diff changeset
1716 #ifndef _LIBCPP_HAS_NO_GLOBAL_FILESYSTEM_NAMESPACE
anatofuz
parents:
diff changeset
1717 template <class _CharT, class _Traits>
anatofuz
parents:
diff changeset
1718 void
anatofuz
parents:
diff changeset
1719 basic_fstream<_CharT, _Traits>::open(const char* __s, ios_base::openmode __mode)
anatofuz
parents:
diff changeset
1720 {
anatofuz
parents:
diff changeset
1721 if (__sb_.open(__s, __mode))
anatofuz
parents:
diff changeset
1722 this->clear();
anatofuz
parents:
diff changeset
1723 else
anatofuz
parents:
diff changeset
1724 this->setstate(ios_base::failbit);
anatofuz
parents:
diff changeset
1725 }
anatofuz
parents:
diff changeset
1726
anatofuz
parents:
diff changeset
1727 #ifdef _LIBCPP_HAS_OPEN_WITH_WCHAR
anatofuz
parents:
diff changeset
1728 template <class _CharT, class _Traits>
anatofuz
parents:
diff changeset
1729 void
anatofuz
parents:
diff changeset
1730 basic_fstream<_CharT, _Traits>::open(const wchar_t* __s, ios_base::openmode __mode)
anatofuz
parents:
diff changeset
1731 {
anatofuz
parents:
diff changeset
1732 if (__sb_.open(__s, __mode))
anatofuz
parents:
diff changeset
1733 this->clear();
anatofuz
parents:
diff changeset
1734 else
anatofuz
parents:
diff changeset
1735 this->setstate(ios_base::failbit);
anatofuz
parents:
diff changeset
1736 }
anatofuz
parents:
diff changeset
1737 #endif
anatofuz
parents:
diff changeset
1738
anatofuz
parents:
diff changeset
1739 template <class _CharT, class _Traits>
anatofuz
parents:
diff changeset
1740 void
anatofuz
parents:
diff changeset
1741 basic_fstream<_CharT, _Traits>::open(const string& __s, ios_base::openmode __mode)
anatofuz
parents:
diff changeset
1742 {
anatofuz
parents:
diff changeset
1743 if (__sb_.open(__s, __mode))
anatofuz
parents:
diff changeset
1744 this->clear();
anatofuz
parents:
diff changeset
1745 else
anatofuz
parents:
diff changeset
1746 this->setstate(ios_base::failbit);
anatofuz
parents:
diff changeset
1747 }
anatofuz
parents:
diff changeset
1748 #endif
anatofuz
parents:
diff changeset
1749
anatofuz
parents:
diff changeset
1750 template <class _CharT, class _Traits>
anatofuz
parents:
diff changeset
1751 inline
anatofuz
parents:
diff changeset
1752 void
anatofuz
parents:
diff changeset
1753 basic_fstream<_CharT, _Traits>::close()
anatofuz
parents:
diff changeset
1754 {
anatofuz
parents:
diff changeset
1755 if (__sb_.close() == 0)
anatofuz
parents:
diff changeset
1756 this->setstate(ios_base::failbit);
anatofuz
parents:
diff changeset
1757 }
anatofuz
parents:
diff changeset
1758
anatofuz
parents:
diff changeset
1759 _LIBCPP_END_NAMESPACE_STD
anatofuz
parents:
diff changeset
1760
anatofuz
parents:
diff changeset
1761 _LIBCPP_POP_MACROS
anatofuz
parents:
diff changeset
1762
anatofuz
parents:
diff changeset
1763 #endif // _LIBCPP_FSTREAM