Planet
navi homePPSaboutscreenshotsdownloaddevelopmentforum

source: downloads/boost_1_34_1/boost/filesystem/fstream.hpp @ 56

Last change on this file since 56 was 29, checked in by landauf, 17 years ago

updated boost from 1_33_1 to 1_34_1
File size: 22.4 KB
RevLine 
[29]1//  boost/filesystem/fstream.hpp  --------------------------------------------//
2
3//  Copyright Beman Dawes 2002.
4//  Use, modification, and distribution is subject to the Boost Software
5//  License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
6//  http://www.boost.org/LICENSE_1_0.txt)
7
8//  See library home page at http://www.boost.org/libs/filesystem
9
10//----------------------------------------------------------------------------//
11
12#ifndef BOOST_FILESYSTEM_FSTREAM_HPP
13#define BOOST_FILESYSTEM_FSTREAM_HPP
14
15#include <boost/filesystem/operations.hpp> // for 8.3 hack (see below)
16#include <boost/utility/enable_if.hpp>
17#include <boost/detail/workaround.hpp>
18
19#include <iosfwd>
20#include <fstream>
21
22#include <boost/config/abi_prefix.hpp> // must be the last #include
23
24// NOTE: fstream.hpp for Boost 1.32.0 and earlier supplied workarounds for
25// various compiler problems. They have been removed to ease development of the
26// basic i18n functionality. Once the new interface is stable, the workarounds
27// will be reinstated for any compilers that otherwise can support the rest of
28// the library after internationalization.
29
30namespace boost
31{
32  namespace filesystem
33  {
34    namespace detail
35    {
36#   if defined(BOOST_WINDOWS_API) && !defined(BOOST_FILESYSTEM_NARROW_ONLY)
37#     if !defined(BOOST_DINKUMWARE_STDLIB) || BOOST_DINKUMWARE_STDLIB < 405
38      // The 8.3 hack:
39      // C++98 does not supply a wchar_t open, so try to get an equivalent
40      // narrow char name based on the short, so-called 8.3, name.
41      // Not needed for Dinkumware 405 and later as they do supply wchar_t open.
42      BOOST_FILESYSTEM_DECL bool create_file_api( const std::wstring & ph,
43        std::ios_base::openmode mode ); // true if succeeds
44      BOOST_FILESYSTEM_DECL std::string narrow_path_api(
45        const std::wstring & ph ); // return is empty if fails
46
47      inline std::string path_proxy( const std::wstring & file_ph,
48        std::ios_base::openmode mode )
49      // Return a non-existant path if cannot supply narrow short path.
50      // An empty path doesn't work because some Dinkumware versions
51      // assert the path is non-empty. 
52      {
53        std::string narrow_ph;
54        bool created_file( false );
55        if ( !exists( file_ph )
56          && (mode & std::ios_base::out) != 0
57          && create_file_api( file_ph, mode ) )
58        {
59          created_file = true;
60        }
61        narrow_ph = narrow_path_api( file_ph );
62        if ( narrow_ph.empty() )
63        {
64          if ( created_file ) remove_api( file_ph );
65          narrow_ph = "\x01";
66        }
67        return narrow_ph;
68      }
69#     else
70      // Dinkumware 405 and later does supply wchar_t functions
71      inline const std::wstring & path_proxy( const std::wstring & file_ph,
72        std::ios_base::openmode )
73        { return file_ph; }
74#     endif
75#   endif
76
77      inline const std::string & path_proxy( const std::string & file_ph,
78        std::ios_base::openmode )
79        { return file_ph; }
80
81    } // namespace detail
82
83    template < class charT, class traits = std::char_traits<charT> >
84    class basic_filebuf : public std::basic_filebuf<charT,traits>
85    {
86    private: // disallow copying
87      basic_filebuf( const basic_filebuf & );
88      const basic_filebuf & operator=( const basic_filebuf & ); 
89    public:
90      basic_filebuf() {}
91      virtual ~basic_filebuf() {}
92
93#   ifndef BOOST_FILESYSTEM_NARROW_ONLY
94      template<class Path>
95      typename boost::enable_if<is_basic_path<Path>,
96        basic_filebuf<charT,traits> *>::type
97      open( const Path & file_ph, std::ios_base::openmode mode );
98
99      basic_filebuf<charT,traits> *
100      open( const wpath & file_ph, std::ios_base::openmode mode );
101#   endif
102
103#   if !BOOST_WORKAROUND( BOOST_MSVC, <= 1200 ) // VC++ 6.0 can't handle this
104      basic_filebuf<charT,traits> *
105      open( const path & file_ph, std::ios_base::openmode mode );
106#   endif
107    };
108
109    template < class charT, class traits = std::char_traits<charT> >
110    class basic_ifstream : public std::basic_ifstream<charT,traits>
111    {
112    private: // disallow copying
113      basic_ifstream( const basic_ifstream & );
114      const basic_ifstream & operator=( const basic_ifstream & ); 
115    public:
116      basic_ifstream() {}
117
118      // use two signatures, rather than one signature with default second
119      // argument, to workaround VC++ 7.1 bug (ID VSWhidbey 38416)
120
121#   ifndef BOOST_FILESYSTEM_NARROW_ONLY
122      template<class Path>
123      explicit basic_ifstream( const Path & file_ph,
124        typename boost::enable_if<is_basic_path<Path> >::type* dummy = 0 );
125
126      template<class Path>
127      basic_ifstream( const Path & file_ph, std::ios_base::openmode mode,
128        typename boost::enable_if<is_basic_path<Path> >::type* dummy = 0 );
129
130      template<class Path>
131      typename boost::enable_if<is_basic_path<Path>, void>::type
132      open( const Path & file_ph );
133
134      template<class Path>
135      typename boost::enable_if<is_basic_path<Path>, void>::type
136      open( const Path & file_ph, std::ios_base::openmode mode );
137
138      explicit basic_ifstream( const wpath & file_ph );
139      basic_ifstream( const wpath & file_ph, std::ios_base::openmode mode );
140      void open( const wpath & file_ph );
141      void open( const wpath & file_ph, std::ios_base::openmode mode );
142#   endif
143
144      explicit basic_ifstream( const path & file_ph );
145      basic_ifstream( const path & file_ph, std::ios_base::openmode mode );
146#   if !BOOST_WORKAROUND( BOOST_MSVC, <= 1200 ) // VC++ 6.0 can't handle this
147      void open( const path & file_ph );
148      void open( const path & file_ph, std::ios_base::openmode mode );
149#   endif
150      virtual ~basic_ifstream() {}
151    };
152
153    template < class charT, class traits = std::char_traits<charT> >
154    class basic_ofstream : public std::basic_ofstream<charT,traits>
155    {
156    private: // disallow copying
157      basic_ofstream( const basic_ofstream & );
158      const basic_ofstream & operator=( const basic_ofstream & ); 
159    public:
160      basic_ofstream() {}
161
162      // use two signatures, rather than one signature with default second
163      // argument, to workaround VC++ 7.1 bug (ID VSWhidbey 38416)
164
165#   ifndef BOOST_FILESYSTEM_NARROW_ONLY
166
167      template<class Path>
168      explicit basic_ofstream( const Path & file_ph,
169        typename boost::enable_if<is_basic_path<Path> >::type* dummy = 0 );
170      explicit basic_ofstream( const wpath & file_ph );
171
172      template<class Path>
173      basic_ofstream( const Path & file_ph, std::ios_base::openmode mode,
174        typename boost::enable_if<is_basic_path<Path> >::type* dummy = 0 );
175      basic_ofstream( const wpath & file_ph, std::ios_base::openmode mode );
176
177      template<class Path>
178      typename boost::enable_if<is_basic_path<Path>, void>::type
179      open( const Path & file_ph );
180      void open( const wpath & file_ph );
181
182      template<class Path>
183      typename boost::enable_if<is_basic_path<Path>, void>::type
184      open( const Path & file_ph, std::ios_base::openmode mode );
185      void open( const wpath & file_ph, std::ios_base::openmode mode );
186
187#   endif
188
189      explicit basic_ofstream( const path & file_ph );
190      basic_ofstream( const path & file_ph, std::ios_base::openmode mode );
191#   if !BOOST_WORKAROUND( BOOST_MSVC, <= 1200 ) // VC++ 6.0 can't handle this
192      void open( const path & file_ph );
193      void open( const path & file_ph, std::ios_base::openmode mode );
194#   endif
195      virtual ~basic_ofstream() {}
196    };
197
198    template < class charT, class traits = std::char_traits<charT> >
199    class basic_fstream : public std::basic_fstream<charT,traits>
200    {
201    private: // disallow copying
202      basic_fstream( const basic_fstream & );
203      const basic_fstream & operator=( const basic_fstream & ); 
204    public:
205      basic_fstream() {}
206
207      // use two signatures, rather than one signature with default second
208      // argument, to workaround VC++ 7.1 bug (ID VSWhidbey 38416)
209
210#   ifndef BOOST_FILESYSTEM_NARROW_ONLY
211
212      template<class Path>
213      explicit basic_fstream( const Path & file_ph,
214        typename boost::enable_if<is_basic_path<Path> >::type* dummy = 0 );
215      explicit basic_fstream( const wpath & file_ph );
216
217      template<class Path>
218      basic_fstream( const Path & file_ph, std::ios_base::openmode mode,
219        typename boost::enable_if<is_basic_path<Path> >::type* dummy = 0 );
220      basic_fstream( const wpath & file_ph, std::ios_base::openmode mode );
221
222      template<class Path>
223      typename boost::enable_if<is_basic_path<Path>, void>::type
224      open( const Path & file_ph );
225      void open( const wpath & file_ph );
226
227      template<class Path>
228      typename boost::enable_if<is_basic_path<Path>, void>::type
229      open( const Path & file_ph, std::ios_base::openmode mode );
230      void open( const wpath & file_ph, std::ios_base::openmode mode );
231
232#   endif
233
234      explicit basic_fstream( const path & file_ph );
235      basic_fstream( const path & file_ph, std::ios_base::openmode mode );
236#   if !BOOST_WORKAROUND( BOOST_MSVC, <= 1200 ) // VC++ 6.0 can't handle this
237      void open( const path & file_ph );
238      void open( const path & file_ph, std::ios_base::openmode mode );
239#   endif
240      virtual ~basic_fstream() {}
241
242    };
243 
244    typedef basic_filebuf<char> filebuf;
245    typedef basic_ifstream<char> ifstream;
246    typedef basic_ofstream<char> ofstream;
247    typedef basic_fstream<char> fstream;
248
249# ifndef BOOST_FILESYSTEM_NARROW_ONLY
250    typedef basic_filebuf<wchar_t> wfilebuf;
251    typedef basic_ifstream<wchar_t> wifstream;
252    typedef basic_fstream<wchar_t> wfstream;
253    typedef basic_ofstream<wchar_t> wofstream;
254# endif
255   
256# ifndef BOOST_FILESYSTEM_NARROW_ONLY
257
258//  basic_filebuf definitions  -----------------------------------------------//
259
260    template <class charT, class traits>
261    template<class Path>
262    typename boost::enable_if<is_basic_path<Path>,
263      basic_filebuf<charT,traits> *>::type
264    basic_filebuf<charT,traits>::open( const Path & file_ph,
265      std::ios_base::openmode mode )
266    {
267      return (std::basic_filebuf<charT,traits>::open( detail::path_proxy(
268        file_ph.external_file_string(), mode ).c_str(), mode )
269          == 0) ? 0 : this;
270    }
271
272    template <class charT, class traits>
273    basic_filebuf<charT,traits> *
274    basic_filebuf<charT, traits>::open( const wpath & file_ph,
275      std::ios_base::openmode mode )
276    {
277      return this->BOOST_NESTED_TEMPLATE open<wpath>( file_ph, mode );
278    }
279
280//  basic_ifstream definitions  ----------------------------------------------//
281
282    template <class charT, class traits> template<class Path>
283    basic_ifstream<charT,traits>::basic_ifstream(const Path & file_ph,
284      typename boost::enable_if<is_basic_path<Path> >::type* )
285      : std::basic_ifstream<charT,traits>(
286        detail::path_proxy( file_ph.external_file_string(),
287          std::ios_base::in ).c_str(), std::ios_base::in ) {}
288
289    template <class charT, class traits>
290    basic_ifstream<charT,traits>::basic_ifstream( const wpath & file_ph )
291      : std::basic_ifstream<charT,traits>(
292        detail::path_proxy( file_ph.external_file_string(),
293          std::ios_base::in ).c_str(), std::ios_base::in ) {}
294   
295    template <class charT, class traits> template<class Path>
296    basic_ifstream<charT,traits>::basic_ifstream( const Path & file_ph,
297      std::ios_base::openmode mode,
298      typename boost::enable_if<is_basic_path<Path> >::type* )
299      : std::basic_ifstream<charT,traits>(
300        detail::path_proxy( file_ph.external_file_string(),
301          mode ).c_str(), mode | std::ios_base::in ) {}
302
303    template <class charT, class traits>
304    basic_ifstream<charT,traits>::basic_ifstream( const wpath & file_ph,
305      std::ios_base::openmode mode )
306      : std::basic_ifstream<charT,traits>(
307        detail::path_proxy( file_ph.external_file_string(),
308          mode ).c_str(), mode | std::ios_base::in ) {}
309
310    template <class charT, class traits> template<class Path>
311    typename boost::enable_if<is_basic_path<Path>, void>::type
312    basic_ifstream<charT,traits>::open( const Path & file_ph )
313    {
314      std::basic_ifstream<charT,traits>::open(
315        detail::path_proxy( file_ph.external_file_string(),
316          std::ios_base::in ).c_str(), std::ios_base::in );
317    }
318
319    template <class charT, class traits>
320    void basic_ifstream<charT,traits>::open( const wpath & file_ph )
321    {
322      std::basic_ifstream<charT,traits>::open(
323        detail::path_proxy( file_ph.external_file_string(),
324          std::ios_base::in ).c_str(), std::ios_base::in );
325    }
326   
327    template <class charT, class traits> template<class Path>
328    typename boost::enable_if<is_basic_path<Path>, void>::type
329    basic_ifstream<charT,traits>::open( const Path & file_ph,
330      std::ios_base::openmode mode )
331    {
332      std::basic_ifstream<charT,traits>::open(
333        detail::path_proxy( file_ph.external_file_string(),
334          mode ).c_str(), mode | std::ios_base::in );
335    }
336   
337    template <class charT, class traits>
338    void basic_ifstream<charT,traits>::open( const wpath & file_ph,
339      std::ios_base::openmode mode )
340    {
341      std::basic_ifstream<charT,traits>::open(
342        detail::path_proxy( file_ph.external_file_string(),
343          mode ).c_str(), mode | std::ios_base::in );
344    }
345
346//  basic_ofstream definitions  ----------------------------------------------//
347
348    template <class charT, class traits> template<class Path>
349    basic_ofstream<charT,traits>::basic_ofstream(const Path & file_ph,
350      typename boost::enable_if<is_basic_path<Path> >::type* )
351      : std::basic_ofstream<charT,traits>(
352        detail::path_proxy( file_ph.external_file_string(),
353          std::ios_base::out ).c_str(), std::ios_base::out ) {}
354
355    template <class charT, class traits>
356    basic_ofstream<charT,traits>::basic_ofstream( const wpath & file_ph )
357      : std::basic_ofstream<charT,traits>(
358        detail::path_proxy( file_ph.external_file_string(),
359          std::ios_base::out ).c_str(), std::ios_base::out ) {}
360
361    template <class charT, class traits> template<class Path>
362    basic_ofstream<charT,traits>::basic_ofstream( const Path & file_ph,
363      std::ios_base::openmode mode,
364      typename boost::enable_if<is_basic_path<Path> >::type* )
365      : std::basic_ofstream<charT,traits>(
366        detail::path_proxy( file_ph.external_file_string(),
367          mode ).c_str(), mode | std::ios_base::out ) {}
368
369    template <class charT, class traits>
370    basic_ofstream<charT,traits>::basic_ofstream( const wpath & file_ph,
371      std::ios_base::openmode mode )
372      : std::basic_ofstream<charT,traits>(
373        detail::path_proxy( file_ph.external_file_string(),
374          mode ).c_str(), mode | std::ios_base::out ) {}
375   
376    template <class charT, class traits> template<class Path>
377    typename boost::enable_if<is_basic_path<Path>, void>::type
378    basic_ofstream<charT,traits>::open( const Path & file_ph )
379    {
380      std::basic_ofstream<charT,traits>::open(
381        detail::path_proxy( file_ph.external_file_string(),
382          std::ios_base::out ).c_str(), std::ios_base::out );
383    }
384   
385    template <class charT, class traits>
386    void basic_ofstream<charT,traits>::open( const wpath & file_ph )
387    {
388      std::basic_ofstream<charT,traits>::open(
389        detail::path_proxy( file_ph.external_file_string(),
390          std::ios_base::out ).c_str(), std::ios_base::out );
391    }
392   
393    template <class charT, class traits> template<class Path>
394    typename boost::enable_if<is_basic_path<Path>, void>::type
395    basic_ofstream<charT,traits>::open( const Path & file_ph,
396      std::ios_base::openmode mode )
397    {
398      std::basic_ofstream<charT,traits>::open(
399        detail::path_proxy( file_ph.external_file_string(),
400          mode ).c_str(), mode | std::ios_base::out );
401    }
402
403    template <class charT, class traits>
404    void basic_ofstream<charT,traits>::open( const wpath & file_ph,
405      std::ios_base::openmode mode )
406    {
407      std::basic_ofstream<charT,traits>::open(
408        detail::path_proxy( file_ph.external_file_string(),
409          mode ).c_str(), mode | std::ios_base::out );
410    }
411
412//  basic_fstream definitions  -----------------------------------------------//
413
414    template <class charT, class traits> template<class Path>
415    basic_fstream<charT,traits>::basic_fstream(const Path & file_ph,
416      typename boost::enable_if<is_basic_path<Path> >::type* )
417      : std::basic_fstream<charT,traits>(
418        detail::path_proxy( file_ph.external_file_string(),
419          std::ios_base::in|std::ios_base::out ).c_str(),
420          std::ios_base::in|std::ios_base::out ) {}
421
422    template <class charT, class traits>
423    basic_fstream<charT,traits>::basic_fstream( const wpath & file_ph )
424      : std::basic_fstream<charT,traits>(
425        detail::path_proxy( file_ph.external_file_string(),
426          std::ios_base::in|std::ios_base::out ).c_str(),
427          std::ios_base::in|std::ios_base::out ) {}
428
429    template <class charT, class traits> template<class Path>
430    basic_fstream<charT,traits>::basic_fstream( const Path & file_ph,
431      std::ios_base::openmode mode,
432      typename boost::enable_if<is_basic_path<Path> >::type* )
433      : std::basic_fstream<charT,traits>(
434        detail::path_proxy( file_ph.external_file_string(),
435          mode ).c_str(), mode | std::ios_base::in | std::ios_base::out ) {}
436   
437    template <class charT, class traits>
438    basic_fstream<charT,traits>::basic_fstream( const wpath & file_ph,
439      std::ios_base::openmode mode )
440      : std::basic_fstream<charT,traits>(
441        detail::path_proxy( file_ph.external_file_string(),
442          mode ).c_str(), mode | std::ios_base::in | std::ios_base::out ) {}
443     
444    template <class charT, class traits> template<class Path>
445    typename boost::enable_if<is_basic_path<Path>, void>::type
446    basic_fstream<charT,traits>::open( const Path & file_ph )
447    {
448      std::basic_fstream<charT,traits>::open(
449        detail::path_proxy( file_ph.external_file_string(),
450          std::ios_base::in|std::ios_base::out ).c_str(),
451          std::ios_base::in|std::ios_base::out );
452    }
453
454    template <class charT, class traits>
455    void basic_fstream<charT,traits>::open( const wpath & file_ph )
456    {
457      std::basic_fstream<charT,traits>::open(
458        detail::path_proxy( file_ph.external_file_string(),
459          std::ios_base::in|std::ios_base::out ).c_str(),
460          std::ios_base::in|std::ios_base::out );
461    }
462   
463    template <class charT, class traits> template<class Path>
464    typename boost::enable_if<is_basic_path<Path>, void>::type
465    basic_fstream<charT,traits>::open( const Path & file_ph,
466      std::ios_base::openmode mode )
467    {
468      std::basic_fstream<charT,traits>::open(
469        detail::path_proxy( file_ph.external_file_string(),
470          mode ).c_str(), mode | std::ios_base::in | std::ios_base::out );
471    }
472
473    template <class charT, class traits>
474    void basic_fstream<charT,traits>::open( const wpath & file_ph,
475      std::ios_base::openmode mode )
476    {
477      std::basic_fstream<charT,traits>::open(
478        detail::path_proxy( file_ph.external_file_string(),
479          mode ).c_str(), mode | std::ios_base::in | std::ios_base::out );
480    }
481
482# endif
483
484#  if !BOOST_WORKAROUND( BOOST_MSVC, <= 1200 ) // VC++ 6.0 can't handle this
485    template <class charT, class traits>
486    basic_filebuf<charT,traits> *
487    basic_filebuf<charT, traits>::open( const path & file_ph,
488      std::ios_base::openmode mode )
489    {
490      return std::basic_filebuf<charT,traits>::open(
491        file_ph.file_string().c_str(), mode ) == 0 ? 0 : this;
492    }
493#  endif
494
495    template <class charT, class traits>
496    basic_ifstream<charT,traits>::basic_ifstream( const path & file_ph )
497      : std::basic_ifstream<charT,traits>(
498          file_ph.file_string().c_str(), std::ios_base::in ) {}
499
500    template <class charT, class traits>
501    basic_ifstream<charT,traits>::basic_ifstream( const path & file_ph,
502      std::ios_base::openmode mode )
503      : std::basic_ifstream<charT,traits>(
504          file_ph.file_string().c_str(), mode ) {}
505   
506#   if !BOOST_WORKAROUND( BOOST_MSVC, <= 1200 ) // VC++ 6.0 can't handle this
507    template <class charT, class traits>
508    void basic_ifstream<charT,traits>::open( const path & file_ph )
509    {
510      std::basic_ifstream<charT,traits>::open(
511        file_ph.file_string().c_str(), std::ios_base::in );
512    }
513   
514    template <class charT, class traits>
515    void basic_ifstream<charT,traits>::open( const path & file_ph,
516      std::ios_base::openmode mode )
517    {
518      std::basic_ifstream<charT,traits>::open(
519        file_ph.file_string().c_str(), mode );
520    }
521#   endif
522
523    template <class charT, class traits>
524    basic_ofstream<charT,traits>::basic_ofstream( const path & file_ph )
525      : std::basic_ofstream<charT,traits>(
526          file_ph.file_string().c_str(), std::ios_base::out ) {}
527
528    template <class charT, class traits>
529    basic_ofstream<charT,traits>::basic_ofstream( const path & file_ph,
530      std::ios_base::openmode mode )
531      : std::basic_ofstream<charT,traits>(
532          file_ph.file_string().c_str(), mode ) {}
533   
534#   if !BOOST_WORKAROUND( BOOST_MSVC, <= 1200 ) // VC++ 6.0 can't handle this
535    template <class charT, class traits>
536    void basic_ofstream<charT,traits>::open( const path & file_ph )
537    {
538      std::basic_ofstream<charT,traits>::open(
539        file_ph.file_string().c_str(), std::ios_base::out );
540    }
541   
542    template <class charT, class traits>
543    void basic_ofstream<charT,traits>::open( const path & file_ph,
544      std::ios_base::openmode mode )
545    {
546      std::basic_ofstream<charT,traits>::open(
547        file_ph.file_string().c_str(), mode );
548    }
549#   endif
550
551    template <class charT, class traits>
552    basic_fstream<charT,traits>::basic_fstream( const path & file_ph )
553      : std::basic_fstream<charT,traits>(
554          file_ph.file_string().c_str(),
555          std::ios_base::in|std::ios_base::out ) {}
556
557
558    template <class charT, class traits>
559    basic_fstream<charT,traits>::basic_fstream( const path & file_ph,
560      std::ios_base::openmode mode )
561      : std::basic_fstream<charT,traits>(
562          file_ph.file_string().c_str(), mode ) {}
563
564#   if !BOOST_WORKAROUND( BOOST_MSVC, <= 1200 ) // VC++ 6.0 can't handle this
565    template <class charT, class traits>
566    void basic_fstream<charT,traits>::open( const path & file_ph )
567    {
568      std::basic_fstream<charT,traits>::open(
569        file_ph.file_string().c_str(), std::ios_base::in|std::ios_base::out );
570    }
571
572    template <class charT, class traits>
573    void basic_fstream<charT,traits>::open( const path & file_ph,
574      std::ios_base::openmode mode )
575    {
576      std::basic_fstream<charT,traits>::open(
577        file_ph.file_string().c_str(), mode );
578    }
579#   endif
580  } // namespace filesystem
581} // namespace boost
582
583#include <boost/config/abi_suffix.hpp> // pops abi_prefix.hpp pragmas
584#endif  // BOOST_FILESYSTEM_FSTREAM_HPP
Note: See TracBrowser for help on using the repository browser.