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