blob: 99eebf973f4cd33b8f47f7c450c8418a6c54a7a1 [file] [log] [blame]
Jeff Thompson86b6d642013-10-17 15:01:56 -07001// (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 NDNBOOST_IOSTREAMS_DETAIL_DIRECT_ADAPTER_HPP_INCLUDED
9#define NDNBOOST_IOSTREAMS_DETAIL_DIRECT_ADAPTER_HPP_INCLUDED
10
11#if defined(_MSC_VER) && (_MSC_VER >= 1020)
12# pragma once
13#endif
14
15#include <ndnboost/config.hpp> // SFINAE, MSVC, put ptrdiff_t in std.
16#include <algorithm> // copy, min.
17#include <cstddef> // ptrdiff_t.
18#include <ndnboost/detail/workaround.hpp>
19#include <ndnboost/iostreams/categories.hpp>
20#include <ndnboost/iostreams/detail/config/limits.hpp> // forwarding.
21#include <ndnboost/iostreams/detail/config/wide_streams.hpp> // locale.
22#include <ndnboost/iostreams/detail/double_object.hpp>
23#include <ndnboost/iostreams/detail/error.hpp>
24#include <ndnboost/iostreams/detail/ios.hpp> // openmode, seekdir, int types.
25#include <ndnboost/iostreams/traits.hpp> // mode_of, is_direct.
26#include <ndnboost/iostreams/operations.hpp>
27#include <ndnboost/mpl/bool.hpp>
28#include <ndnboost/mpl/or.hpp>
29#include <ndnboost/preprocessor/iteration/local.hpp>
30#include <ndnboost/preprocessor/repetition/enum_binary_params.hpp>
31#include <ndnboost/preprocessor/repetition/enum_params.hpp>
32#include <ndnboost/static_assert.hpp>
33#include <ndnboost/throw_exception.hpp>
34#include <ndnboost/type_traits/is_convertible.hpp>
35
36// Must come last.
37#include <ndnboost/iostreams/detail/config/disable_warnings.hpp> // VC7.1
38
39namespace ndnboost { namespace iostreams { namespace detail {
40
41//------------------Definition of direct_adapter_base-------------------------//
42
43// Put all initialization in base class to faciliate forwarding.
44template<typename Direct>
45class direct_adapter_base {
46public:
47 typedef typename char_type_of<Direct>::type char_type;
48 typedef typename mode_of<Direct>::type mode_type;
49 struct category
50 : mode_type,
51 device_tag,
52 closable_tag
53 #ifndef NDNBOOST_IOSTREAMS_NO_LOCALE
54 , localizable_tag
55 #endif
56 { };
57protected:
58 explicit direct_adapter_base(const Direct& d);
59 typedef is_convertible<category, two_sequence> is_double;
60 struct pointers {
61 char_type *beg, *ptr, *end;
62 };
63 void init_input(mpl::true_);
64 void init_input(mpl::false_) { }
65 void init_output(mpl::true_);
66 void init_output(mpl::false_) { }
67 double_object<pointers, is_double> ptrs_;
68 Direct d_;
69};
70
71template<typename Direct>
72class direct_adapter : private direct_adapter_base<Direct> {
73private:
74 typedef direct_adapter_base<Direct> base_type;
75 typedef typename base_type::pointers pointers;
76 typedef typename base_type::is_double is_double;
77 using base_type::ptrs_;
78 using base_type::d_;
79public:
80 typedef typename base_type::char_type char_type;
81 typedef typename base_type::category category;
82
83 // Constructors
84
85#if !NDNBOOST_WORKAROUND(NDNBOOST_MSVC, <= 1310)
86 direct_adapter(const Direct& d) : base_type(d) { }
87 direct_adapter(const direct_adapter& d) : base_type(d) { }
88# define NDNBOOST_PP_LOCAL_LIMITS (1, NDNBOOST_IOSTREAMS_MAX_FORWARDING_ARITY)
89#else
90 template<typename U>
91 struct is_direct
92 : mpl::or_<
93 is_same<U, direct_adapter<Direct> >,
94 is_same<U, Direct>
95 >
96 { };
97 template<typename U>
98 direct_adapter(const U& u)
99 : base_type(forward(u, is_direct<U>()))
100 { }
101# define NDNBOOST_PP_LOCAL_LIMITS (2, NDNBOOST_IOSTREAMS_MAX_FORWARDING_ARITY)
102#endif
103
104#define NDNBOOST_PP_LOCAL_MACRO(n) \
105 template<NDNBOOST_PP_ENUM_PARAMS(n, typename P)> \
106 direct_adapter(NDNBOOST_PP_ENUM_BINARY_PARAMS(n, const P, &p)) \
107 : base_type(Direct(NDNBOOST_PP_ENUM_PARAMS(n, p))) \
108 { } \
109 /**/
110#include NDNBOOST_PP_LOCAL_ITERATE()
111#undef NDNBOOST_PP_LOCAL_MACRO
112
113 // Device interface.
114
115 std::streamsize read(char_type* s, std::streamsize n);
116 std::streamsize write(const char_type* s, std::streamsize n);
117 std::streampos seek( stream_offset, NDNBOOST_IOS::seekdir,
118 NDNBOOST_IOS::openmode = NDNBOOST_IOS::in | NDNBOOST_IOS::out );
119 void close();
120 void close(NDNBOOST_IOS::openmode which);
121#ifndef NDNBOOST_IOSTREAMS_NO_LOCALE
122 void imbue(const std::locale&);
123#endif
124
125 // Direct device access.
126
127 Direct& operator*() { return d_; }
128 Direct* operator->() { return &d_; }
129#if NDNBOOST_WORKAROUND(NDNBOOST_MSVC, <= 1310)
130private:
131 template<typename U>
132 static Direct forward(const U& u, mpl::true_) { return u; }
133 template<typename U>
134 static Direct forward(const U& u, mpl::false_) { return Direct(u); }
135#endif
136};
137
138//--------------Definition of wrap_direct and unwrap_direct-------------------//
139
140template<typename Device>
141struct wrap_direct_traits
142 : mpl::if_<
143 is_direct<Device>,
144 direct_adapter<Device>,
145 Device
146 >
147 { };
148
149template<typename Device>
150typename wrap_direct_traits<Device>::type
151inline wrap_direct(Device dev)
152{
153 typedef typename wrap_direct_traits<Device>::type type;
154 return type(dev);
155}
156
157template<typename Device>
158inline Device& unwrap_direct(Device& d) { return d; }
159
160template<typename Device>
161inline Device& unwrap_direct(direct_adapter<Device>& d) { return *d; }
162
163//--------------Implementation of direct_adapter_base-------------------------//
164
165template<typename Direct>
166direct_adapter_base<Direct>::direct_adapter_base(const Direct& d) : d_(d)
167{
168 init_input(is_convertible<category, input>());
169 init_output(is_convertible<category, output>());
170}
171
172template<typename Direct>
173void direct_adapter_base<Direct>::init_input(mpl::true_)
174{
175 std::pair<char_type*, char_type*> seq = iostreams::input_sequence(d_);
176 ptrs_.first().beg = seq.first;
177 ptrs_.first().ptr = seq.first;
178 ptrs_.first().end = seq.second;
179}
180
181template<typename Direct>
182void direct_adapter_base<Direct>::init_output(mpl::true_)
183{
184 std::pair<char_type*, char_type*> seq = iostreams::output_sequence(d_);
185 ptrs_.second().beg = seq.first;
186 ptrs_.second().ptr = seq.first;
187 ptrs_.second().end = seq.second;
188}
189
190//--------------Implementation of direct_adapter------------------------------//
191
192template<typename Direct>
193inline std::streamsize direct_adapter<Direct>::read
194 (char_type* s, std::streamsize n)
195{
196 using namespace std;
197 pointers& get = ptrs_.first();
198 std::streamsize avail =
199 static_cast<std::streamsize>(get.end - get.ptr);
200 std::streamsize result = (std::min)(n, avail);
201 std::copy(get.ptr, get.ptr + result, s);
202 get.ptr += result;
203 return result != 0 ? result : -1;
204}
205
206template<typename Direct>
207inline std::streamsize direct_adapter<Direct>::write
208 (const char_type* s, std::streamsize n)
209{
210 using namespace std;
211 pointers& put = ptrs_.second();
212 if (n > static_cast<std::streamsize>(put.end - put.ptr))
213 ndnboost::throw_exception(write_area_exhausted());
214 std::copy(s, s + n, put.ptr);
215 put.ptr += n;
216 return n;
217}
218
219template<typename Direct>
220inline std::streampos direct_adapter<Direct>::seek
221 ( stream_offset off, NDNBOOST_IOS::seekdir way,
222 NDNBOOST_IOS::openmode which )
223{
224 using namespace std;
225 pointers& get = ptrs_.first();
226 pointers& put = ptrs_.second();
227 if (way == NDNBOOST_IOS::cur && get.ptr != put.ptr)
228 ndnboost::throw_exception(bad_seek());
229 ptrdiff_t next = 0;
230 if ((which & NDNBOOST_IOS::in) || !is_double::value) {
231 if (way == NDNBOOST_IOS::beg)
232 next = off;
233 else if (way == NDNBOOST_IOS::cur)
234 next = get.ptr - get.beg + off;
235 else
236 next = get.end - get.beg + off;
237 if (next >= 0 && next <= get.end - get.beg)
238 get.ptr = get.beg + next;
239 else
240 ndnboost::throw_exception(bad_seek());
241 }
242 if ((which & NDNBOOST_IOS::out) && is_double::value) {
243 if (way == NDNBOOST_IOS::beg)
244 next = off;
245 else if (way == NDNBOOST_IOS::cur)
246 next = put.ptr - put.beg + off;
247 else
248 next = put.end - put.beg + off;
249 if (next >= 0 && next <= put.end - put.beg)
250 put.ptr = put.beg + next;
251 else
252 ndnboost::throw_exception(bad_seek());
253 }
254 return offset_to_position(next);
255}
256
257template<typename Direct>
258void direct_adapter<Direct>::close()
259{
260 NDNBOOST_STATIC_ASSERT((!is_convertible<category, two_sequence>::value));
261 detail::close_all(d_);
262}
263
264template<typename Direct>
265void direct_adapter<Direct>::close(NDNBOOST_IOS::openmode which)
266{
267 NDNBOOST_STATIC_ASSERT((is_convertible<category, two_sequence>::value));
268 ndnboost::iostreams::close(d_, which);
269}
270
271#ifndef NDNBOOST_IOSTREAMS_NO_LOCALE
272 template<typename Direct>
273 void direct_adapter<Direct>::imbue(const std::locale& loc)
274 { ndnboost::iostreams::imbue(d_, loc); }
275#endif
276
277} } } // End namespaces detail, iostreams, boost.
278
279#include <ndnboost/iostreams/detail/config/enable_warnings.hpp>
280
281#endif // #ifndef NDNBOOST_IOSTREAMS_DETAIL_DIRECT_ADAPTER_HPP_INCLUDED