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
|
// (C) Copyright 2008 CodeRage, LLC (turkanis at coderage dot com)
// (C) Copyright 2003-2007 Jonathan Turkanis
// 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.
#ifndef BOOST_IOSTREAMS_DETAIL_BROKEN_OVERLOAD_RESOLUTION_STREAM_HPP_INCLUDED
#define BOOST_IOSTREAMS_DETAIL_BROKEN_OVERLOAD_RESOLUTION_STREAM_HPP_INCLUDED
#include <boost/iostreams/detail/broken_overload_resolution/forward.hpp>
namespace boost { namespace iostreams {
template< typename Device,
typename Tr =
BOOST_IOSTREAMS_CHAR_TRAITS(
BOOST_DEDUCED_TYPENAME char_type_of<Device>::type
),
typename Alloc =
std::allocator<
BOOST_DEDUCED_TYPENAME char_type_of<Device>::type
> >
struct stream : detail::stream_base<Device, Tr, Alloc> {
public:
typedef typename char_type_of<Device>::type char_type;
struct category
: mode_of<Device>::type,
closable_tag,
detail::stream_traits<Device, Tr>::stream_tag
{ };
BOOST_IOSTREAMS_STREAMBUF_TYPEDEFS(Tr)
private:
typedef typename
detail::stream_traits<
Device, Tr
>::stream_type stream_type;
public:
stream() { }
template<typename U0>
stream(const U0& u0)
{
open_impl(detail::forward<Device, U0>(), u0);
}
template<typename U0, typename U1>
stream(const U0& u0, const U1& u1)
{
open_impl(detail::forward<Device, U0>(), u0, u1);
}
template<typename U0, typename U1, typename U2>
stream(const U0& u0, const U1& u1, const U2& u2)
{
open_impl(detail::forward<Device, U0>(), u0, u1, u2);
}
#if !BOOST_WORKAROUND(BOOST_MSVC, <= 1300) //---------------------------------//
template<typename U0>
stream(U0& u0)
{
open_impl(detail::forward<Device, U0>(), u0);
}
template<typename U0, typename U1>
stream(U0& u0, const U1& u1)
{
open_impl(detail::forward<Device, U0>(), u0, u1);
}
template<typename U0, typename U1, typename U2>
stream(U0& u0, const U1& u1, const U2& u2)
{
open_impl(detail::forward<Device, U0>(), u0, u1, u2);
}
#endif // !BOOST_WORKAROUND(BOOST_MSVC, <= 1300) //---------------------------//
template<typename U0>
void open(const U0& u0)
{
open_impl(detail::forward<Device, U0>(), u0);
}
template<typename U0, typename U1>
void open(const U0& u0, const U1& u1)
{
open_impl(detail::forward<Device, U0>(), u0, u1);
}
template<typename U0, typename U1, typename U2>
void open(const U0& u0, const U1& u1, const U2& u2)
{
open_impl(detail::forward<Device, U0>(), u0, u1, u2);
}
#if !BOOST_WORKAROUND(BOOST_MSVC, <= 1300) //---------------------------------//
template<typename U0>
void open(U0& u0)
{
open_impl(detail::forward<Device, U0>(), u0);
}
template<typename U0, typename U1>
void open(U0& u0, const U1& u1)
{
open_impl(detail::forward<Device, U0>(), u0, u1);
}
template<typename U0, typename U1, typename U2>
void open(U0& u0, const U1& u1, const U2& u2)
{
open_impl(detail::forward<Device, U0>(), u0, u1, u2);
}
#endif // !BOOST_WORKAROUND(BOOST_MSVC, <= 1300) //---------------------------//
bool is_open() const { return this->member.is_open(); }
void close() { this->member.close(); }
bool auto_close() const { return this->member.auto_close(); }
void set_auto_close(bool close) { this->member.set_auto_close(close); }
bool strict_sync() { return this->member.strict_sync(); }
Device& operator*() { return *this->member; }
Device* operator->() { return &*this->member; }
private:
template<typename U0>
void open_impl(mpl::false_, const U0& u0)
{
this->clear();
this->member.open(u0);
}
#if !BOOST_WORKAROUND(BOOST_MSVC, <= 1300) //---------------------------------//
template<typename U0>
void open_impl(mpl::false_, U0& u0)
{
this->clear();
this->member.open(detail::wrap(u0));
}
#endif // !BOOST_WORKAROUND(BOOST_MSVC, <= 1300) //---------------------------//
template<typename U0>
void open_impl(mpl::true_, const U0& u0)
{
this->clear();
this->member.open(Device(const_cast<U0&>(u0)));
}
#if !BOOST_WORKAROUND(BOOST_MSVC, <= 1300) //---------------------------------//
template<typename U0>
void open_impl(mpl::true_, U0& u0)
{
this->clear();
this->member.open(Device(u0));
}
#endif // !BOOST_WORKAROUND(BOOST_MSVC, <= 1300) //---------------------------//
template<typename U0, typename U1>
void open_impl(mpl::false_, const U0& u0, const U1& u1)
{
this->clear();
this->member.open(u0, u1);
}
template<typename U0, typename U1>
void open_impl(mpl::true_, const U0& u0, const U1& u1)
{
this->clear();
this->member.open(Device(const_cast<U0&>(u0), u1));
}
#if !BOOST_WORKAROUND(BOOST_MSVC, <= 1300) //---------------------------------//
template<typename U0, typename U1>
void open_impl(mpl::true_, U0& u0, const U1& u1)
{
this->clear();
this->member.open(Device(u0, u1));
}
#endif // !BOOST_WORKAROUND(BOOST_MSVC, <= 1300) //---------------------------//
template<typename U0, typename U1, typename U2>
void open_impl(mpl::false_, const U0& u0, const U1& u1, const U2& u2)
{
this->clear();
this->member.open(u0, u1, u2);
}
template<typename U0, typename U1, typename U2>
void open_impl(mpl::true_, const U0& u0, const U1& u1, const U2& u2)
{
this->clear();
this->member.open(Device(const_cast<U0&>(u0), u1, u2));
}
#if !BOOST_WORKAROUND(BOOST_MSVC, <= 1300) //---------------------------------//
template<typename U0, typename U1, typename U2>
void open_impl(mpl::true_, U0& u0, const U1& u1, const U2& u2)
{
this->clear();
this->member.open(Device(u0, u1, u2));
}
#endif
};
} } // End namespaces iostreams, boost.
#endif BOOST_IOSTREAMS_DETAIL_BROKEN_OVERLOAD_RESOLUTION_STREAM_HPP_INCLUDED
|
