Line data    Source code

       1             : /*
       2             :  * Distributed under the Boost Software License, Version 1.0.(See accompanying 
       3             :  * file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt.)
       4             :  * 
       5             :  * See http://www.boost.org/libs/iostreams for documentation.
       6             :  *
       7             :  * File:        boost/iostreams/detail/path.hpp
       8             :  * Date:        Sat Jun 21 21:24:05 MDT 2008
       9             :  * Copyright:   2008 CodeRage, LLC
      10             :  * Author:      Jonathan Turkanis
      11             :  * Contact:     turkanis at coderage dot com
      12             :  *
      13             :  * Defines the class boost::iostreams::detail::path, for storing a 
      14             :  * a std::string or std::wstring.
      15             :  *
      16             :  * This class allows interoperability with Boost.Filesystem without
      17             :  * creating a dependence on Boost.Filesystem headers or implementation.
      18             :  */
      19             : 
      20             : #ifndef BOOST_IOSTREAMS_DETAIL_PATH_HPP_INCLUDED
      21             : #define BOOST_IOSTREAMS_DETAIL_PATH_HPP_INCLUDED
      22             : 
      23             : #include <cstring>
      24             : #include <string>
      25             : #include <boost/iostreams/detail/config/wide_streams.hpp>
      26             : #ifndef BOOST_IOSTREAMS_NO_WIDE_STREAMS
      27             : # include <cwchar>
      28             : #endif
      29             : #include <boost/static_assert.hpp>
      30             : #include <boost/type.hpp>
      31             : #include <boost/type_traits/is_same.hpp>
      32             : 
      33             : namespace boost { namespace iostreams { namespace detail {
      34             : 
      35             : #ifndef BOOST_IOSTREAMS_NO_WIDE_STREAMS //------------------------------------//
      36             : 
      37             : class path {
      38             :     template<typename T, typename V>
      39             :     struct sfinae
      40             :     {
      41             :         typedef V type;
      42             :     };
      43             : public:
      44             : 
      45             :     // Default constructor
      46             :     path() : narrow_(), wide_(), is_wide_(false) { }
      47             : 
      48             :     // Constructor taking a std::string
      49           0 :     path(const std::string& p) : narrow_(p), wide_(), is_wide_(false) { }
      50             : 
      51             :     // Constructor taking a C-style string
      52             :     path(const char* p) : narrow_(p), wide_(), is_wide_(false) { }
      53             : 
      54             :     // Constructor taking a boost::filesystem2::path or
      55             :     // boost::filesystem2::wpath
      56             :     template<typename Path>
      57             :     explicit path(const Path& p, typename Path::external_string_type* = 0)
      58             :     {
      59             :         init(p.external_file_string());
      60             :     }
      61             : 
      62             :     // Constructor taking a boost::filesystem3::path (boost filesystem v3)
      63             :     template<typename Path>
      64             :     explicit path(const Path& p, typename Path::codecvt_type* = 0)
      65             :     {
      66             :         init(p.native());
      67             :     }
      68             : 
      69             :     // Copy constructor
      70             :     path(const path& p) 
      71             :         : narrow_(p.narrow_), wide_(p.wide_), is_wide_(p.is_wide_) 
      72             :         { }
      73             : 
      74             :     // Assignment operator taking another path
      75             :     path& operator=(const path& p)
      76             :     {
      77             :         narrow_ = p.narrow_;
      78             :         wide_ = p.wide_;
      79             :         is_wide_ = p.is_wide_;
      80             :         return *this;
      81             :     }
      82             : 
      83             :     // Assignment operator taking a std::string
      84             :     path& operator=(const std::string& p)
      85             :     {
      86             :         narrow_ = p;
      87             :         wide_.clear();
      88             :         is_wide_ = false;
      89             :         return *this;
      90             :     }
      91             : 
      92             :     // Assignment operator taking a C-style string
      93             :     path& operator=(const char* p)
      94             :     {
      95             :         narrow_.assign(p);
      96             :         wide_.clear();
      97             :         is_wide_ = false;
      98             :         return *this;
      99             :     }
     100             : 
     101             : #if !BOOST_WORKAROUND(BOOST_MSVC, <= 1400)
     102             :     // Assignment operator taking a boost::filesystem2::path or
     103             :     // boost::filesystem2::wpath
     104             :     // (not on Visual C++ 7.1/8.0, as it seems to have problems with
     105             :     // SFINAE functions with the same parameters, doesn't seem
     106             :     // worth working around).
     107             :     template<typename Path>
     108             :     typename sfinae<typename Path::external_string_type, path&>::type
     109             :         operator=(const Path& p)
     110             :     {
     111             :         init(p.external_file_string());
     112             :         return *this;
     113             :     }
     114             : #endif
     115             : 
     116             :     // Assignment operator taking a boost::filesystem3::path
     117             :     template<typename Path>
     118             :     typename sfinae<typename Path::codecvt_type, path&>::type
     119             :         operator=(const Path& p)
     120             :     {
     121             :         init(p.native());
     122             :         return *this;
     123             :     }
     124             : 
     125             :     bool is_wide() const { return is_wide_; }
     126             : 
     127             :     // Returns a representation of the underlying path as a std::string
     128             :     // Requires: is_wide() returns false
     129             :     const char* c_str() const { return narrow_.c_str(); }
     130             : 
     131             :     // Returns a representation of the underlying path as a std::wstring
     132             :     // Requires: is_wide() returns true
     133             :     const wchar_t* c_wstr() const { return wide_.c_str(); }
     134             : private:
     135             :     
     136             :     // For wide-character paths, use a boost::filesystem::wpath instead of a
     137             :     // std::wstring
     138             :     path(const std::wstring&);
     139             :     path& operator=(const std::wstring&);
     140             : 
     141             :     void init(std::string const& file_path)
     142             :     {
     143             :         narrow_ = file_path;
     144             :         wide_.clear();
     145             :         is_wide_ = false;
     146             :     }
     147             : 
     148             :     void init(std::wstring const& file_path)
     149             :     {
     150             :         narrow_.clear();
     151             :         wide_ = file_path;
     152             :         is_wide_ = true;
     153             :     }
     154             : 
     155             :     std::string   narrow_;
     156             :     std::wstring  wide_;
     157             :     bool          is_wide_;
     158             : };
     159             : 
     160             : inline bool operator==(const path& lhs, const path& rhs)
     161             : {
     162             :     return lhs.is_wide() ?
     163             :         rhs.is_wide() && std::wcscmp(lhs.c_wstr(), rhs.c_wstr()) == 0 :
     164             :         !rhs.is_wide() && std::strcmp(lhs.c_str(), rhs.c_str()) == 0;
     165             : }
     166             : 
     167             : #else // #ifndef BOOST_IOSTREAMS_NO_WIDE_STREAMS //---------------------------//
     168             : 
     169             : class path {
     170             : public:
     171             :     path() { }
     172             :     path(const std::string& p) : path_(p) { }
     173             :     path(const char* p) : path_(p) { }
     174             :     template<typename Path>
     175             :         path(const Path& p) : path_(p.external_file_string()) { }
     176             :     path(const path& p) : path_(p.path_) { }
     177             :     path& operator=(const path& other) 
     178             :     {
     179             :         path_ = other.path_;
     180             :         return *this;
     181             :     }
     182             :     path& operator=(const std::string& p) 
     183             :     {
     184             :         path_ = p;
     185             :         return *this;
     186             :     }
     187             :     path& operator=(const char* p) 
     188             :     {
     189             :         path_ = p;
     190             :         return *this;
     191             :     }
     192             :     template<typename Path>
     193             :         path& operator=(const Path& p)
     194             :         {
     195             :             path_ = p.external_file_string();
     196             :             return *this;
     197             :         }
     198             :     bool is_wide() const { return false; }
     199             :     const char* c_str() const { return path_.c_str(); }
     200             :     const wchar_t* c_wstr() const { return 0; }
     201             : private:
     202             :     std::string path_;
     203             : };
     204             : 
     205             : inline bool operator==(const path& lhs, const path& rhs)
     206             : {
     207             :     return std::strcmp(lhs.c_str(), rhs.c_str()) == 0 ;
     208             : }
     209             : 
     210             : #endif // #ifndef BOOST_IOSTREAMS_NO_WIDE_STREAMS //--------------------------//
     211             : 
     212             : } } } // End namespaces detail, iostreams, boost.
     213             : 
     214             : #endif // #ifndef BOOST_IOSTREAMS_DETAIL_PATH_HPP_INCLUDED