]>
Commit | Line | Data |
---|---|---|
7c673cae FG |
1 | // (C) Copyright 2008 CodeRage, LLC (turkanis at coderage dot com) |
2 | // (C) Copyright 2003-2007 Jonathan Turkanis | |
3 | // Distributed under the Boost Software License, Version 1.0. (See accompanying | |
4 | // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt.) | |
5 | ||
6 | // See http://www.boost.org/libs/iostreams for documentation. | |
7 | ||
8 | // Define BOOST_IOSTREAMS_SOURCE so that <boost/iostreams/detail/config.hpp> | |
9 | // knows that we are building the library (possibly exporting code), rather | |
10 | // than using it (possibly importing code). | |
11 | #define BOOST_IOSTREAMS_SOURCE | |
12 | ||
13 | #include <cassert> | |
14 | #include <cerrno> | |
15 | #include <cstdio> // SEEK_SET, etc. | |
16 | #include <boost/config.hpp> // BOOST_JOIN | |
17 | #include <boost/iostreams/detail/error.hpp> | |
18 | #include <boost/iostreams/detail/config/dyn_link.hpp> | |
19 | #include <boost/iostreams/detail/config/rtl.hpp> // BOOST_IOSTREAMS_FD_XXX | |
20 | #include <boost/iostreams/detail/config/windows_posix.hpp> | |
21 | #include <boost/iostreams/detail/system_failure.hpp> | |
22 | #include <boost/iostreams/detail/ios.hpp> // openmodes, failure. | |
23 | #include <boost/iostreams/device/file_descriptor.hpp> | |
24 | #include <boost/integer_traits.hpp> | |
25 | #include <boost/throw_exception.hpp> | |
26 | ||
27 | // Must come last. | |
28 | #include <boost/iostreams/detail/config/disable_warnings.hpp> | |
29 | ||
30 | // OS-specific headers for low-level i/o. | |
31 | ||
32 | #include <fcntl.h> // file opening flags. | |
33 | #include <sys/stat.h> // file access permissions. | |
34 | #ifdef BOOST_IOSTREAMS_WINDOWS | |
35 | # include <io.h> // low-level file i/o. | |
36 | # define WINDOWS_LEAN_AND_MEAN | |
37 | # include <windows.h> | |
38 | # ifndef INVALID_SET_FILE_POINTER | |
39 | # define INVALID_SET_FILE_POINTER ((DWORD)-1) | |
40 | # endif | |
41 | #else | |
42 | # include <sys/types.h> // mode_t. | |
43 | # include <unistd.h> // low-level file i/o. | |
44 | #endif | |
45 | ||
46 | namespace boost { namespace iostreams { | |
47 | ||
48 | //------------------Definition of file_descriptor_impl------------------------// | |
49 | ||
50 | namespace detail { | |
51 | ||
52 | // Contains the platform dependant implementation | |
53 | struct file_descriptor_impl { | |
54 | // Note: These need to match file_desciptor_flags | |
55 | enum flags { | |
56 | never_close = 0, | |
57 | close_on_exit = 1, | |
58 | close_on_close = 2, | |
59 | close_always = 3 | |
60 | }; | |
61 | ||
62 | file_descriptor_impl(); | |
63 | ~file_descriptor_impl(); | |
64 | void open(file_handle fd, flags); | |
65 | #ifdef BOOST_IOSTREAMS_WINDOWS | |
66 | void open(int fd, flags); | |
67 | #endif | |
68 | void open(const detail::path&, BOOST_IOS::openmode); | |
69 | bool is_open() const; | |
70 | void close(); | |
71 | void close_impl(bool close_flag, bool throw_); | |
72 | std::streamsize read(char* s, std::streamsize n); | |
73 | std::streamsize write(const char* s, std::streamsize n); | |
74 | std::streampos seek(stream_offset off, BOOST_IOS::seekdir way); | |
75 | static file_handle invalid_handle(); | |
76 | file_handle handle_; | |
77 | int flags_; | |
78 | }; | |
79 | ||
80 | //------------------Implementation of file_descriptor_impl--------------------// | |
81 | ||
82 | file_descriptor_impl::file_descriptor_impl() | |
83 | : handle_(invalid_handle()), flags_(0) | |
84 | { } | |
85 | ||
86 | file_descriptor_impl::~file_descriptor_impl() | |
87 | { | |
88 | close_impl(flags_ & close_on_exit, false); | |
89 | } | |
90 | ||
91 | void file_descriptor_impl::open(file_handle fd, flags f) | |
92 | { | |
93 | // Using 'close' to close the existing handle so that it will throw an | |
94 | // exception if it fails. | |
95 | // | |
96 | // Only closing after assigning the new handle, so that the class will | |
97 | // take ownership of the handle regardless of whether close throws. | |
98 | ||
99 | file_descriptor_impl tmp; | |
100 | tmp.handle_ = handle_; | |
101 | tmp.flags_ = flags_ & close_on_exit ? close_on_close : never_close; | |
102 | ||
103 | handle_ = fd; | |
104 | flags_ = f; | |
105 | ||
106 | tmp.close(); | |
107 | } | |
108 | ||
109 | #ifdef BOOST_IOSTREAMS_WINDOWS //---------------------------------------------// | |
110 | ||
111 | void file_descriptor_impl::open(int fd, flags f) | |
112 | { open(reinterpret_cast<file_handle>(_get_osfhandle(fd)), f); } | |
113 | ||
114 | #endif // #ifdef BOOST_IOSTREAMS_WINDOWS //-----------------------------------// | |
115 | ||
116 | void file_descriptor_impl::open(const detail::path& p, BOOST_IOS::openmode mode) | |
117 | { | |
118 | close_impl(flags_ & close_on_exit, true); | |
119 | ||
120 | #ifdef BOOST_IOSTREAMS_WINDOWS //---------------------------------------------// | |
121 | DWORD dwDesiredAccess; | |
122 | DWORD dwCreationDisposition; | |
b32b8144 FG |
123 | |
124 | if ( !(mode & (BOOST_IOS::in | BOOST_IOS::out | BOOST_IOS::app)) || | |
125 | ((mode & BOOST_IOS::trunc) && | |
126 | ((mode & BOOST_IOS::app) || !(mode & BOOST_IOS::out))) ) { | |
127 | boost::throw_exception(BOOST_IOSTREAMS_FAILURE("bad open mode")); | |
128 | } | |
129 | else if ( mode & BOOST_IOS::in ) { | |
130 | if ( mode & BOOST_IOS::app ) | |
131 | { | |
7c673cae FG |
132 | dwCreationDisposition = OPEN_ALWAYS; |
133 | dwDesiredAccess = | |
b32b8144 | 134 | GENERIC_READ | |
7c673cae FG |
135 | FILE_APPEND_DATA | |
136 | FILE_WRITE_ATTRIBUTES | | |
137 | FILE_WRITE_EA | | |
138 | STANDARD_RIGHTS_WRITE | | |
139 | SYNCHRONIZE; | |
b32b8144 FG |
140 | } |
141 | else if ( mode & BOOST_IOS::trunc ) | |
142 | { | |
7c673cae | 143 | dwCreationDisposition = CREATE_ALWAYS; |
b32b8144 FG |
144 | dwDesiredAccess = GENERIC_READ | GENERIC_WRITE; |
145 | } | |
146 | else if ( mode & BOOST_IOS::out ) | |
147 | { | |
148 | dwCreationDisposition = OPEN_EXISTING; | |
149 | dwDesiredAccess = GENERIC_READ | GENERIC_WRITE; | |
150 | } | |
151 | else | |
152 | { | |
153 | dwCreationDisposition = OPEN_EXISTING; | |
154 | dwDesiredAccess = GENERIC_READ; | |
155 | } | |
156 | } | |
157 | else { | |
158 | if ( mode & BOOST_IOS::app ) | |
159 | { | |
160 | dwCreationDisposition = OPEN_ALWAYS; | |
161 | dwDesiredAccess = | |
162 | FILE_APPEND_DATA | | |
163 | FILE_WRITE_ATTRIBUTES | | |
164 | FILE_WRITE_EA | | |
165 | STANDARD_RIGHTS_WRITE | | |
166 | SYNCHRONIZE; | |
167 | } | |
168 | else | |
169 | { | |
170 | dwCreationDisposition = CREATE_ALWAYS; | |
171 | dwDesiredAccess = GENERIC_WRITE; | |
172 | } | |
7c673cae | 173 | } |
b32b8144 | 174 | |
7c673cae FG |
175 | |
176 | HANDLE handle = p.is_wide() ? | |
177 | ::CreateFileW( p.c_wstr(), | |
178 | dwDesiredAccess, | |
179 | FILE_SHARE_READ | FILE_SHARE_WRITE, | |
180 | NULL, // lpSecurityAttributes | |
181 | dwCreationDisposition, | |
182 | FILE_ATTRIBUTE_NORMAL, | |
183 | NULL ) : // hTemplateFile | |
184 | ::CreateFileA( p.c_str(), | |
185 | dwDesiredAccess, | |
186 | FILE_SHARE_READ | FILE_SHARE_WRITE, | |
187 | NULL, // lpSecurityAttributes | |
188 | dwCreationDisposition, | |
189 | FILE_ATTRIBUTE_NORMAL, | |
190 | NULL ); // hTemplateFile | |
191 | if (handle != INVALID_HANDLE_VALUE) { | |
192 | handle_ = handle; | |
193 | flags_ = close_always; | |
194 | } else { | |
195 | flags_ = 0; | |
196 | throw_system_failure("failed opening file"); | |
197 | } | |
198 | #else // #ifdef BOOST_IOSTREAMS_WINDOWS //------------------------------------// | |
199 | ||
200 | // Calculate oflag argument to open. | |
201 | ||
202 | int oflag = 0; | |
b32b8144 FG |
203 | if ( !(mode & (BOOST_IOS::in | BOOST_IOS::out | BOOST_IOS::app)) || |
204 | ((mode & BOOST_IOS::trunc) && | |
205 | ((mode & BOOST_IOS::app) || !(mode & BOOST_IOS::out))) ) { | |
7c673cae FG |
206 | boost::throw_exception(BOOST_IOSTREAMS_FAILURE("bad open mode")); |
207 | } | |
b32b8144 FG |
208 | else if ( mode & BOOST_IOS::in ) { |
209 | if ( mode & BOOST_IOS::app ) | |
210 | oflag |= O_CREAT | O_APPEND | O_RDWR; | |
211 | else if ( mode & BOOST_IOS::trunc ) | |
212 | oflag |= O_CREAT | O_TRUNC | O_RDWR; | |
213 | else if ( mode & BOOST_IOS::out ) | |
214 | oflag |= O_RDWR; | |
215 | else | |
216 | oflag |= O_RDONLY; | |
217 | } | |
218 | else { | |
219 | if ( mode & BOOST_IOS::app ) | |
220 | oflag |= O_CREAT | O_APPEND | O_WRONLY; | |
221 | else | |
222 | oflag |= O_CREAT | O_TRUNC | O_WRONLY; | |
223 | } | |
7c673cae FG |
224 | #ifdef _LARGEFILE64_SOURCE |
225 | oflag |= O_LARGEFILE; | |
226 | #endif | |
227 | ||
228 | // Calculate pmode argument to open. | |
229 | ||
230 | mode_t pmode = S_IRUSR | S_IWUSR | | |
231 | S_IRGRP | S_IWGRP | | |
232 | S_IROTH | S_IWOTH; | |
233 | ||
234 | // Open file. | |
235 | ||
236 | int fd = BOOST_IOSTREAMS_FD_OPEN(p.c_str(), oflag, pmode); | |
237 | if (fd == -1) { | |
238 | boost::throw_exception(system_failure("failed opening file")); | |
239 | } else { | |
b32b8144 FG |
240 | if ( mode & BOOST_IOS::ate ) { |
241 | if (BOOST_IOSTREAMS_FD_SEEK(fd, 0, SEEK_END) == -1) { | |
242 | BOOST_IOSTREAMS_FD_CLOSE(fd); | |
243 | boost::throw_exception(system_failure("failed opening file")); | |
244 | } | |
245 | } | |
7c673cae FG |
246 | handle_ = fd; |
247 | flags_ = close_always; | |
248 | } | |
249 | #endif // #ifndef BOOST_IOSTREAMS_WINDOWS //----------------------------------// | |
250 | } | |
251 | ||
252 | bool file_descriptor_impl::is_open() const | |
253 | { return handle_ != invalid_handle(); } | |
254 | ||
255 | void file_descriptor_impl::close() | |
256 | { | |
257 | close_impl((flags_ & close_on_close) != 0, true); | |
258 | } | |
259 | ||
260 | void file_descriptor_impl::close_impl(bool close_flag, bool throw_) { | |
261 | if (handle_ != invalid_handle()) { | |
262 | if (close_flag) { | |
263 | bool success = | |
264 | #ifdef BOOST_IOSTREAMS_WINDOWS | |
265 | ::CloseHandle(handle_) == 1; | |
266 | #else | |
267 | BOOST_IOSTREAMS_FD_CLOSE(handle_) != -1; | |
268 | #endif | |
269 | if (!success && throw_) | |
270 | throw_system_failure("failed closing file"); | |
271 | } | |
272 | handle_ = invalid_handle(); | |
273 | flags_ = 0; | |
274 | } | |
275 | } | |
276 | ||
277 | std::streamsize file_descriptor_impl::read(char* s, std::streamsize n) | |
278 | { | |
279 | #ifdef BOOST_IOSTREAMS_WINDOWS | |
280 | DWORD result; | |
b32b8144 | 281 | if (!::ReadFile(handle_, s, static_cast<DWORD>(n), &result, NULL)) |
7c673cae FG |
282 | { |
283 | // report EOF if the write-side of a pipe has been closed | |
284 | if (GetLastError() == ERROR_BROKEN_PIPE) | |
285 | { | |
286 | result = 0; | |
287 | } | |
288 | else | |
289 | throw_system_failure("failed reading"); | |
290 | } | |
291 | return result == 0 ? -1 : static_cast<std::streamsize>(result); | |
292 | #else // #ifdef BOOST_IOSTREAMS_WINDOWS | |
293 | errno = 0; | |
294 | std::streamsize result = BOOST_IOSTREAMS_FD_READ(handle_, s, n); | |
295 | if (errno != 0) | |
296 | throw_system_failure("failed reading"); | |
297 | return result == 0 ? -1 : result; | |
298 | #endif // #ifdef BOOST_IOSTREAMS_WINDOWS | |
299 | } | |
300 | ||
301 | std::streamsize file_descriptor_impl::write(const char* s, std::streamsize n) | |
302 | { | |
303 | #ifdef BOOST_IOSTREAMS_WINDOWS | |
304 | DWORD ignore; | |
b32b8144 | 305 | if (!::WriteFile(handle_, s, static_cast<DWORD>(n), &ignore, NULL)) |
7c673cae FG |
306 | throw_system_failure("failed writing"); |
307 | return n; | |
308 | #else // #ifdef BOOST_IOSTREAMS_WINDOWS | |
309 | int amt = BOOST_IOSTREAMS_FD_WRITE(handle_, s, n); | |
310 | if (amt < n) // Handles blocking fd's only. | |
311 | throw_system_failure("failed writing"); | |
312 | return n; | |
313 | #endif // #ifdef BOOST_IOSTREAMS_WINDOWS | |
314 | } | |
315 | ||
316 | std::streampos file_descriptor_impl::seek | |
317 | (stream_offset off, BOOST_IOS::seekdir way) | |
318 | { | |
319 | #ifdef BOOST_IOSTREAMS_WINDOWS | |
320 | LONG lDistanceToMove = static_cast<LONG>(off & 0xffffffff); | |
321 | LONG lDistanceToMoveHigh = static_cast<LONG>(off >> 32); | |
322 | DWORD dwResultLow = | |
323 | ::SetFilePointer( handle_, | |
324 | lDistanceToMove, | |
325 | &lDistanceToMoveHigh, | |
326 | way == BOOST_IOS::beg ? | |
327 | FILE_BEGIN : | |
328 | way == BOOST_IOS::cur ? | |
329 | FILE_CURRENT : | |
330 | FILE_END ); | |
331 | if ( dwResultLow == INVALID_SET_FILE_POINTER && | |
332 | ::GetLastError() != NO_ERROR ) | |
333 | { | |
334 | boost::throw_exception(system_failure("failed seeking")); | |
335 | } else { | |
336 | return offset_to_position( | |
337 | (stream_offset(lDistanceToMoveHigh) << 32) + dwResultLow | |
338 | ); | |
339 | } | |
340 | #else // #ifdef BOOST_IOSTREAMS_WINDOWS | |
341 | if ( off > integer_traits<BOOST_IOSTREAMS_FD_OFFSET>::const_max || | |
342 | off < integer_traits<BOOST_IOSTREAMS_FD_OFFSET>::const_min ) | |
343 | { | |
344 | boost::throw_exception(BOOST_IOSTREAMS_FAILURE("bad offset")); | |
345 | } | |
346 | stream_offset result = | |
347 | BOOST_IOSTREAMS_FD_SEEK( | |
348 | handle_, | |
349 | static_cast<BOOST_IOSTREAMS_FD_OFFSET>(off), | |
350 | ( way == BOOST_IOS::beg ? | |
351 | SEEK_SET : | |
352 | way == BOOST_IOS::cur ? | |
353 | SEEK_CUR : | |
354 | SEEK_END ) | |
355 | ); | |
356 | if (result == -1) | |
357 | boost::throw_exception(system_failure("failed seeking")); | |
358 | return offset_to_position(result); | |
359 | #endif // #ifdef BOOST_IOSTREAMS_WINDOWS | |
360 | } | |
361 | ||
362 | // Returns the value stored in a file_handle variable when no file is open | |
363 | file_handle file_descriptor_impl::invalid_handle() | |
364 | { | |
365 | #ifdef BOOST_IOSTREAMS_WINDOWS | |
366 | return INVALID_HANDLE_VALUE; | |
367 | #else | |
368 | return -1; | |
369 | #endif | |
370 | } | |
371 | ||
372 | } // End namespace detail. | |
373 | ||
374 | //------------------Implementation of file_descriptor-------------------------// | |
375 | ||
376 | file_descriptor::file_descriptor() : pimpl_(new impl_type) { } | |
377 | ||
378 | file_descriptor::file_descriptor(handle_type fd, file_descriptor_flags f) | |
379 | : pimpl_(new impl_type) | |
380 | { open(fd, f); } | |
381 | ||
382 | #if defined(BOOST_IOSTREAMS_USE_DEPRECATED) | |
383 | file_descriptor::file_descriptor(handle_type fd, bool close_on_exit) | |
384 | : pimpl_(new impl_type) | |
385 | { open(fd, close_on_exit); } | |
386 | #endif | |
387 | ||
388 | #ifdef BOOST_IOSTREAMS_WINDOWS //---------------------------------------------// | |
389 | ||
390 | file_descriptor::file_descriptor(int fd, file_descriptor_flags f) | |
391 | : pimpl_(new impl_type) | |
392 | { open(fd, f); } | |
393 | ||
394 | #if defined(BOOST_IOSTREAMS_USE_DEPRECATED) | |
395 | file_descriptor::file_descriptor(int fd, bool close_on_exit) | |
396 | : pimpl_(new impl_type) | |
397 | { open(fd, close_on_exit); } | |
398 | #endif | |
399 | ||
400 | #endif // #ifdef BOOST_IOSTREAMS_WINDOWS //-----------------------------------// | |
401 | ||
402 | file_descriptor::file_descriptor( const std::string& path, | |
403 | BOOST_IOS::openmode mode ) | |
404 | : pimpl_(new impl_type) | |
405 | { open(path, mode); } | |
406 | ||
407 | file_descriptor::file_descriptor( const char* path, | |
408 | BOOST_IOS::openmode mode ) | |
409 | : pimpl_(new impl_type) | |
410 | { open(path, mode); } | |
411 | ||
412 | file_descriptor::file_descriptor(const file_descriptor& other) | |
413 | : pimpl_(other.pimpl_) | |
414 | { } | |
415 | ||
416 | void file_descriptor::open(handle_type fd, file_descriptor_flags f) | |
417 | { pimpl_->open(fd, static_cast<detail::file_descriptor_impl::flags>(f)); } | |
418 | ||
419 | #if defined(BOOST_IOSTREAMS_USE_DEPRECATED) | |
420 | void file_descriptor::open(handle_type fd, bool close_on_exit) | |
421 | { pimpl_->open(fd, close_on_exit ? | |
422 | detail::file_descriptor_impl::close_always : | |
423 | detail::file_descriptor_impl::close_on_close); } | |
424 | #endif | |
425 | ||
426 | #ifdef BOOST_IOSTREAMS_WINDOWS //---------------------------------------------// | |
427 | ||
428 | void file_descriptor::open(int fd, file_descriptor_flags f) | |
429 | { pimpl_->open(fd, static_cast<detail::file_descriptor_impl::flags>(f)); } | |
430 | ||
431 | #if defined(BOOST_IOSTREAMS_USE_DEPRECATED) | |
432 | void file_descriptor::open(int fd, bool close_on_exit) | |
433 | { pimpl_->open(fd, close_on_exit ? | |
434 | detail::file_descriptor_impl::close_always : | |
435 | detail::file_descriptor_impl::close_on_close); } | |
436 | #endif | |
437 | ||
438 | #endif // #ifdef BOOST_IOSTREAMS_WINDOWS //-----------------------------------// | |
439 | ||
440 | void file_descriptor::open(const std::string& path, BOOST_IOS::openmode mode) | |
441 | { open(detail::path(path), mode); } | |
442 | ||
443 | void file_descriptor::open(const char* path, BOOST_IOS::openmode mode) | |
444 | { open(detail::path(path), mode); } | |
445 | ||
446 | bool file_descriptor::is_open() const { return pimpl_->is_open(); } | |
447 | ||
448 | void file_descriptor::close() { pimpl_->close(); } | |
449 | ||
450 | std::streamsize file_descriptor::read(char_type* s, std::streamsize n) | |
451 | { return pimpl_->read(s, n); } | |
452 | ||
453 | std::streamsize file_descriptor::write(const char_type* s, std::streamsize n) | |
454 | { return pimpl_->write(s, n); } | |
455 | ||
456 | std::streampos file_descriptor::seek(stream_offset off, BOOST_IOS::seekdir way) | |
457 | { return pimpl_->seek(off, way); } | |
458 | ||
459 | detail::file_handle file_descriptor::handle() const { return pimpl_->handle_; } | |
460 | ||
461 | void file_descriptor::init() { pimpl_.reset(new impl_type); } | |
462 | ||
463 | void file_descriptor::open( | |
464 | const detail::path& path, | |
465 | BOOST_IOS::openmode mode, | |
466 | BOOST_IOS::openmode base ) | |
467 | { | |
468 | mode |= base; | |
469 | pimpl_->open(path, mode); | |
470 | } | |
471 | ||
472 | //------------------Implementation of file_descriptor_source------------------// | |
473 | ||
474 | file_descriptor_source::file_descriptor_source( | |
475 | handle_type fd, file_descriptor_flags f) | |
476 | { open(fd, f); } | |
477 | ||
478 | #if defined(BOOST_IOSTREAMS_USE_DEPRECATED) | |
479 | file_descriptor_source::file_descriptor_source( | |
480 | handle_type fd, bool close_on_exit) | |
481 | { open(fd, close_on_exit); } | |
482 | #endif | |
483 | ||
484 | #ifdef BOOST_IOSTREAMS_WINDOWS //---------------------------------------------// | |
485 | ||
486 | file_descriptor_source::file_descriptor_source(int fd, file_descriptor_flags f) | |
487 | { open(fd, f); } | |
488 | ||
489 | #if defined(BOOST_IOSTREAMS_USE_DEPRECATED) | |
490 | file_descriptor_source::file_descriptor_source(int fd, bool close_on_exit) | |
491 | { open(fd, close_on_exit); } | |
492 | #endif | |
493 | ||
494 | #endif // #ifdef BOOST_IOSTREAMS_WINDOWS //-----------------------------------// | |
495 | ||
496 | file_descriptor_source::file_descriptor_source( | |
497 | const std::string& path, BOOST_IOS::openmode mode) | |
498 | { open(path, mode); } | |
499 | ||
500 | file_descriptor_source::file_descriptor_source( | |
501 | const char* path, BOOST_IOS::openmode mode) | |
502 | { open(path, mode); } | |
503 | ||
504 | file_descriptor_source::file_descriptor_source( | |
505 | const file_descriptor_source& other) | |
506 | : file_descriptor(static_cast<const file_descriptor&>(other)) | |
507 | { } | |
508 | ||
509 | void file_descriptor_source::open(handle_type fd, file_descriptor_flags f) | |
510 | { file_descriptor::open(fd, f); } | |
511 | ||
512 | #if defined(BOOST_IOSTREAMS_USE_DEPRECATED) | |
513 | void file_descriptor_source::open(handle_type fd, bool close_on_exit) | |
514 | { file_descriptor::open(fd, close_on_exit); } | |
515 | #endif | |
516 | ||
517 | #ifdef BOOST_IOSTREAMS_WINDOWS //---------------------------------------------// | |
518 | ||
519 | void file_descriptor_source::open(int fd, file_descriptor_flags f) | |
520 | { file_descriptor::open(fd, f); } | |
521 | ||
522 | #if defined(BOOST_IOSTREAMS_USE_DEPRECATED) | |
523 | void file_descriptor_source::open(int fd, bool close_on_exit) | |
524 | { file_descriptor::open(fd, close_on_exit); } | |
525 | #endif | |
526 | ||
527 | #endif // #ifdef BOOST_IOSTREAMS_WINDOWS //-----------------------------------// | |
528 | ||
529 | void file_descriptor_source::open( | |
530 | const std::string& path, BOOST_IOS::openmode mode) | |
531 | { open(detail::path(path), mode); } | |
532 | ||
533 | void file_descriptor_source::open( | |
534 | const char* path, BOOST_IOS::openmode mode) | |
535 | { open(detail::path(path), mode); } | |
536 | ||
537 | void file_descriptor_source::open( | |
538 | const detail::path& path, BOOST_IOS::openmode mode) | |
539 | { | |
b32b8144 | 540 | if (mode & (BOOST_IOS::out | BOOST_IOS::trunc)) |
7c673cae FG |
541 | boost::throw_exception(BOOST_IOSTREAMS_FAILURE("invalid mode")); |
542 | file_descriptor::open(path, mode, BOOST_IOS::in); | |
543 | } | |
544 | ||
545 | //------------------Implementation of file_descriptor_sink--------------------// | |
546 | ||
547 | file_descriptor_sink::file_descriptor_sink( | |
548 | handle_type fd, file_descriptor_flags f) | |
549 | { open(fd, f); } | |
550 | ||
551 | #if defined(BOOST_IOSTREAMS_USE_DEPRECATED) | |
552 | file_descriptor_sink::file_descriptor_sink( | |
553 | handle_type fd, bool close_on_exit) | |
554 | { open(fd, close_on_exit); } | |
555 | #endif | |
556 | ||
557 | #ifdef BOOST_IOSTREAMS_WINDOWS //---------------------------------------------// | |
558 | ||
559 | file_descriptor_sink::file_descriptor_sink(int fd, file_descriptor_flags f) | |
560 | { open(fd, f); } | |
561 | ||
562 | #if defined(BOOST_IOSTREAMS_USE_DEPRECATED) | |
563 | file_descriptor_sink::file_descriptor_sink(int fd, bool close_on_exit) | |
564 | { open(fd, close_on_exit); } | |
565 | #endif | |
566 | ||
567 | #endif // #ifdef BOOST_IOSTREAMS_WINDOWS //-----------------------------------// | |
568 | ||
569 | file_descriptor_sink::file_descriptor_sink( | |
570 | const std::string& path, BOOST_IOS::openmode mode) | |
571 | { open(path, mode); } | |
572 | ||
573 | file_descriptor_sink::file_descriptor_sink( | |
574 | const char* path, BOOST_IOS::openmode mode) | |
575 | { open(path, mode); } | |
576 | ||
577 | file_descriptor_sink::file_descriptor_sink(const file_descriptor_sink& other) | |
578 | : file_descriptor(static_cast<const file_descriptor&>(other)) | |
579 | { } | |
580 | ||
581 | void file_descriptor_sink::open(handle_type fd, file_descriptor_flags f) | |
582 | { file_descriptor::open(fd, f); } | |
583 | ||
584 | #if defined(BOOST_IOSTREAMS_USE_DEPRECATED) | |
585 | void file_descriptor_sink::open(handle_type fd, bool close_on_exit) | |
586 | { file_descriptor::open(fd, close_on_exit); } | |
587 | #endif | |
588 | ||
589 | #ifdef BOOST_IOSTREAMS_WINDOWS //---------------------------------------------// | |
590 | ||
591 | void file_descriptor_sink::open(int fd, file_descriptor_flags f) | |
592 | { file_descriptor::open(fd, f); } | |
593 | ||
594 | #if defined(BOOST_IOSTREAMS_USE_DEPRECATED) | |
595 | void file_descriptor_sink::open(int fd, bool close_on_exit) | |
596 | { file_descriptor::open(fd, close_on_exit); } | |
597 | #endif | |
598 | ||
599 | #endif // #ifdef BOOST_IOSTREAMS_WINDOWS //-----------------------------------// | |
600 | ||
601 | void file_descriptor_sink::open( | |
602 | const std::string& path, BOOST_IOS::openmode mode) | |
603 | { open(detail::path(path), mode); } | |
604 | ||
605 | void file_descriptor_sink::open( | |
606 | const char* path, BOOST_IOS::openmode mode) | |
607 | { open(detail::path(path), mode); } | |
608 | ||
609 | void file_descriptor_sink::open( | |
610 | const detail::path& path, BOOST_IOS::openmode mode) | |
611 | { | |
612 | if (mode & BOOST_IOS::in) | |
613 | boost::throw_exception(BOOST_IOSTREAMS_FAILURE("invalid mode")); | |
614 | file_descriptor::open(path, mode, BOOST_IOS::out); | |
615 | } | |
616 | ||
617 | #include <boost/iostreams/detail/config/enable_warnings.hpp> | |
618 | ||
619 | } } // End namespaces iostreams, boost. |