boost/boost/filesystem/fstream.hpp

   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
  30 namespace 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