]> git.proxmox.com Git - ceph.git/blame - ceph/src/boost/libs/iostreams/include/boost/iostreams/detail/resolve.hpp
projects / ceph.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
bump version to 12.2.2-pve1
[ceph.git] / ceph / src / boost / libs / iostreams / include / boost / iostreams / detail / resolve.hpp
CommitLineData
7c673cae
FG		 1// (C) Copyright 2008 CodeRage, LLC (turkanis at coderage dot com)
2// (C) Copyright 2003-2007 Jonathan Turkanis
3// Distributed under the Boost Software License, Version 1.0. (See accompanying
4// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt.)
5
6// See http://www.boost.org/libs/iostreams for documentation.
7
8#ifndef BOOST_IOSTREAMS_DETAIL_RESOLVE_HPP_INCLUDED
9#define BOOST_IOSTREAMS_DETAIL_RESOLVE_HPP_INCLUDED
10
11#if defined(_MSC_VER)
12# pragma once
13#endif
14
15#include <boost/config.hpp> // partial spec, put size_t in std.
16#include <cstddef> // std::size_t.
17#include <boost/detail/is_incrementable.hpp>
18#include <boost/detail/workaround.hpp>
19#include <boost/iostreams/detail/adapter/mode_adapter.hpp>
20#include <boost/iostreams/detail/adapter/output_iterator_adapter.hpp>
21#include <boost/iostreams/detail/adapter/range_adapter.hpp>
22#include <boost/iostreams/detail/config/gcc.hpp>
23#include <boost/iostreams/detail/config/overload_resolution.hpp>
24#include <boost/iostreams/detail/config/wide_streams.hpp>
25#include <boost/iostreams/detail/enable_if_stream.hpp>
26#include <boost/iostreams/detail/is_dereferenceable.hpp>
27#include <boost/iostreams/detail/is_iterator_range.hpp>
28#include <boost/iostreams/detail/select.hpp>
29#include <boost/iostreams/detail/wrap_unwrap.hpp>
30#include <boost/iostreams/device/array.hpp>
31#include <boost/iostreams/traits.hpp>
32#include <boost/mpl/and.hpp>
33#include <boost/mpl/bool.hpp> // true_.
34#include <boost/mpl/if.hpp>
35#include <boost/range/iterator_range.hpp>
36#include <boost/type_traits/is_array.hpp>
37
38// Must come last.
39#include <boost/iostreams/detail/config/disable_warnings.hpp> // VC7.1 C4224.
40
41namespace boost { namespace iostreams { namespace detail {
42
43//------------------Definition of resolve-------------------------------------//
44
45#ifndef BOOST_IOSTREAMS_BROKEN_OVERLOAD_RESOLUTION //-------------------------//
46
47template<typename Mode, typename Ch, typename T>
48struct resolve_traits {
49 typedef typename
50 mpl::if_<
51 boost::detail::is_incrementable<T>,
52 output_iterator_adapter<Mode, Ch, T>,
53 const T&
54 >::type type;
55};
56
57# ifndef BOOST_IOSTREAMS_NO_STREAM_TEMPLATES //-------------------------------//
58
59template<typename Mode, typename Ch, typename T>
60typename resolve_traits<Mode, Ch, T>::type
61resolve( const T& t
62 BOOST_IOSTREAMS_DISABLE_IF_STREAM(T)
63
64 // I suspect that the compilers which require this workaround may
65 // be correct, but I'm not sure why :(
66 #if BOOST_WORKAROUND(BOOST_INTEL_CXX_VERSION, BOOST_TESTED_AT(810)) ||\
67 BOOST_WORKAROUND(__MWERKS__, BOOST_TESTED_AT(0x3205)) || \
68 BOOST_WORKAROUND(BOOST_IOSTREAMS_GCC, BOOST_TESTED_AT(400)) ||\
69 BOOST_WORKAROUND(__IBMCPP__, BOOST_TESTED_AT(1110))
70 /**/
71 , typename disable_if< is_iterator_range<T> >::type* = 0
72 #endif
73 )
74{
75 typedef typename resolve_traits<Mode, Ch, T>::type return_type;
76 return return_type(t);
77}
78
79template<typename Mode, typename Ch, typename Tr>
80mode_adapter< Mode, std::basic_streambuf<Ch, Tr> >
81resolve(std::basic_streambuf<Ch, Tr>& sb)
82{ return mode_adapter< Mode, std::basic_streambuf<Ch, Tr> >(wrap(sb)); }
83
84template<typename Mode, typename Ch, typename Tr>
85mode_adapter< Mode, std::basic_istream<Ch, Tr> >
86resolve(std::basic_istream<Ch, Tr>& is)
87{ return mode_adapter< Mode, std::basic_istream<Ch, Tr> >(wrap(is)); }
88
89template<typename Mode, typename Ch, typename Tr>
90mode_adapter< Mode, std::basic_ostream<Ch, Tr> >
91resolve(std::basic_ostream<Ch, Tr>& os)
92{ return mode_adapter< Mode, std::basic_ostream<Ch, Tr> >(wrap(os)); }
93
94template<typename Mode, typename Ch, typename Tr>
95mode_adapter< Mode, std::basic_iostream<Ch, Tr> >
96resolve(std::basic_iostream<Ch, Tr>& io)
97{ return mode_adapter< Mode, std::basic_iostream<Ch, Tr> >(wrap(io)); }
98
99template<typename Mode, typename Ch, std::size_t N>
100array_adapter<Mode, Ch> resolve(Ch (&array)[N])
101{ return array_adapter<Mode, Ch>(array); }
102
103template<typename Mode, typename Ch, typename Iter>
104range_adapter< Mode, boost::iterator_range<Iter> >
105resolve(const boost::iterator_range<Iter>& rng)
106{ return range_adapter< Mode, boost::iterator_range<Iter> >(rng); }
107
108# else // # ifndef BOOST_IOSTREAMS_NO_STREAM_TEMPLATES //---------------------//
109
110template<typename Mode, typename Ch, typename T>
111typename resolve_traits<Mode, Ch, T>::type
112resolve( const T& t
113 BOOST_IOSTREAMS_DISABLE_IF_STREAM(T)
114 #if defined(__GNUC__)
115 , typename disable_if< is_iterator_range<T> >::type* = 0
116 #endif
117 )
118{
119 typedef typename resolve_traits<Mode, Ch, T>::type return_type;
120 return return_type(t);
121}
122
123template<typename Mode, typename Ch>
124mode_adapter<Mode, std::streambuf>
125resolve(std::streambuf& sb)
126{ return mode_adapter<Mode, std::streambuf>(wrap(sb)); }
127
128template<typename Mode, typename Ch>
129mode_adapter<Mode, std::istream>
130resolve(std::istream& is)
131{ return mode_adapter<Mode, std::istream>(wrap(is)); }
132
133template<typename Mode, typename Ch>
134mode_adapter<Mode, std::ostream>
135resolve(std::ostream& os)
136{ return mode_adapter<Mode, std::ostream>(wrap(os)); }
137
138template<typename Mode, typename Ch>
139mode_adapter<Mode, std::iostream>
140resolve(std::iostream& io)
141{ return mode_adapter<Mode, std::iostream>(wrap(io)); }
142
143template<typename Mode, typename Ch, std::size_t N>
144array_adapter<Mode, Ch> resolve(Ch (&array)[N])
145{ return array_adapter<Mode, Ch>(array); }
146
147template<typename Mode, typename Ch, typename Iter>
148range_adapter< Mode, boost::iterator_range<Iter> >
149resolve(const boost::iterator_range<Iter>& rng)
150{ return range_adapter< Mode, boost::iterator_range<Iter> >(rng); }
151
152# endif // # ifndef BOOST_IOSTREAMS_NO_STREAM_TEMPLATES //--------------------//
153#else // #ifndef BOOST_IOSTREAMS_BROKEN_OVERLOAD_RESOLUTION //----------------//
154
155template<typename Mode, typename Ch, typename T>
156struct resolve_traits {
157 // Note: test for is_iterator_range must come before test for output
158 // iterator.
159 typedef typename
160 iostreams::select< // Disambiguation for Tru64.
161 is_std_io<T>,
162 mode_adapter<Mode, T>,
163 is_iterator_range<T>,
164 range_adapter<Mode, T>,
165 is_dereferenceable<T>,
166 output_iterator_adapter<Mode, Ch, T>,
167 is_array<T>,
168 array_adapter<Mode, T>,
169 else_,
170 #if !BOOST_WORKAROUND(__BORLANDC__, < 0x600)
171 const T&
172 #else
173 T
174 #endif
175 >::type type;
176};
177
178template<typename Mode, typename Ch, typename T>
179typename resolve_traits<Mode, Ch, T>::type
180resolve(const T& t, mpl::true_)
181{ // Bad overload resolution.
182 typedef typename resolve_traits<Mode, Ch, T>::type return_type;
183 return return_type(wrap(const_cast<T&>(t)));
184}
185
186template<typename Mode, typename Ch, typename T>
187typename resolve_traits<Mode, Ch, T>::type
188resolve(const T& t, mpl::false_)
189{
190 typedef typename resolve_traits<Mode, Ch, T>::type return_type;
191 return return_type(t);
192}
193
194template<typename Mode, typename Ch, typename T>
195typename resolve_traits<Mode, Ch, T>::type
196resolve(const T& t BOOST_IOSTREAMS_DISABLE_IF_STREAM(T))
197{ return resolve<Mode, Ch>(t, is_std_io<T>()); }
198
199# if !BOOST_WORKAROUND(__BORLANDC__, < 0x600) && \
200 !defined(__GNUC__) // ---------------------------------------------------//
201
202template<typename Mode, typename Ch, typename T>
203typename resolve_traits<Mode, Ch, T>::type
204resolve(T& t, mpl::true_)
205{
206 typedef typename resolve_traits<Mode, Ch, T>::type return_type;
207 return return_type(wrap(t));
208}
209
210template<typename Mode, typename Ch, typename T>
211typename resolve_traits<Mode, Ch, T>::type
212resolve(T& t, mpl::false_)
213{
214 typedef typename resolve_traits<Mode, Ch, T>::type return_type;
215 return return_type(t);
216}
217
218template<typename Mode, typename Ch, typename T>
219typename resolve_traits<Mode, Ch, T>::type
220resolve(T& t BOOST_IOSTREAMS_ENABLE_IF_STREAM(T))
221{ return resolve<Mode, Ch>(t, is_std_io<T>()); }
222
223# endif // Borland 5.x or GCC //--------------------------------//
224#endif // #ifndef BOOST_IOSTREAMS_BROKEN_OVERLOAD_RESOLUTION //---------------//
225
226} } } // End namespaces detail, iostreams, boost.
227
228#include <boost/iostreams/detail/config/enable_warnings.hpp> // VC7.1 4224.
229
230#endif // BOOST_IOSTREAMS_DETAIL_RESOLVE_HPP_INCLUDED
Ceph