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 | 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(s: 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(s1: lhs.c_wstr(), s2: rhs.c_wstr()) == 0 : |
164 | !rhs.is_wide() && std::strcmp(s1: lhs.c_str(), s2: 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 |
215 | |