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_INVERT_HPP_INCLUDED
9 #define BOOST_IOSTREAMS_INVERT_HPP_INCLUDED
10
11 #if defined(_MSC_VER)
12 # pragma once
13 #endif
14
15 #include <algorithm> // copy, min.
16 #include <boost/assert.hpp>
17 #include <boost/config.hpp> // BOOST_DEDUCED_TYPENAME.
18 #include <boost/detail/workaround.hpp> // default_filter_buffer_size.
19 #include <boost/iostreams/char_traits.hpp>
20 #include <boost/iostreams/compose.hpp>
21 #include <boost/iostreams/constants.hpp>
22 #include <boost/iostreams/device/array.hpp>
23 #include <boost/iostreams/detail/buffer.hpp>
24 #include <boost/iostreams/detail/counted_array.hpp>
25 #include <boost/iostreams/detail/execute.hpp>
26 #include <boost/iostreams/detail/functional.hpp> // clear_flags, call_reset
27 #include <boost/mpl/if.hpp>
28 #include <boost/ref.hpp>
29 #include <boost/shared_ptr.hpp>
30 #include <boost/type_traits/is_convertible.hpp>
31
32 // Must come last.
33 #include <boost/iostreams/detail/config/disable_warnings.hpp> // MSVC.
34
35 namespace boost { namespace iostreams {
36
37 //
38 // Template name: inverse.
39 // Template parameters:
40 // Filter - A model of InputFilter or OutputFilter.
41 // Description: Generates an InputFilter from an OutputFilter or
42 // vice versa.
43 //
44 template<typename Filter>
45 class inverse {
46 private:
47 BOOST_STATIC_ASSERT(is_filter<Filter>::value);
48 typedef typename category_of<Filter>::type base_category;
49 typedef reference_wrapper<Filter> filter_ref;
50 public:
51 typedef typename char_type_of<Filter>::type char_type;
52 typedef typename int_type_of<Filter>::type int_type;
53 typedef char_traits<char_type> traits_type;
54 typedef typename
55 mpl::if_<
56 is_convertible<
57 base_category,
58 input
59 >,
60 output,
61 input
62 >::type mode;
63 struct category
64 : mode,
65 filter_tag,
66 multichar_tag,
67 closable_tag
68 { };
inverse(const Filter & filter,std::streamsize buffer_size=default_filter_buffer_size)69 explicit inverse( const Filter& filter,
70 std::streamsize buffer_size =
71 default_filter_buffer_size)
72 : pimpl_(new impl(filter, buffer_size))
73 { }
74
75 template<typename Source>
read(Source & src,char_type * s,std::streamsize n)76 std::streamsize read(Source& src, char_type* s, std::streamsize n)
77 {
78 typedef detail::counted_array_sink<char_type> array_sink;
79 typedef composite<filter_ref, array_sink> filtered_array_sink;
80
81 BOOST_ASSERT((flags() & f_write) == 0);
82 if (flags() == 0) {
83 flags() = f_read;
84 buf().set(0, 0);
85 }
86
87 filtered_array_sink snk(filter(), array_sink(s, n));
88 int_type status;
89 for ( status = traits_type::good();
90 snk.second().count() < n && status == traits_type::good(); )
91 {
92 status = buf().fill(src);
93 buf().flush(snk);
94 }
95 return snk.second().count() == 0 &&
96 status == traits_type::eof()
97 ?
98 -1
99 :
100 snk.second().count();
101 }
102
103 template<typename Sink>
write(Sink & dest,const char_type * s,std::streamsize n)104 std::streamsize write(Sink& dest, const char_type* s, std::streamsize n)
105 {
106 typedef detail::counted_array_source<char_type> array_source;
107 typedef composite<filter_ref, array_source> filtered_array_source;
108
109 BOOST_ASSERT((flags() & f_read) == 0);
110 if (flags() == 0) {
111 flags() = f_write;
112 buf().set(0, 0);
113 }
114
115 filtered_array_source src(filter(), array_source(s, n));
116 for (bool good = true; src.second().count() < n && good; ) {
117 buf().fill(src);
118 good = buf().flush(dest);
119 }
120 return src.second().count();
121 }
122
123 template<typename Device>
close(Device & dev)124 void close(Device& dev)
125 {
126 detail::execute_all(
127 detail::flush_buffer(buf(), dev, (flags() & f_write) != 0),
128 detail::call_close_all(pimpl_->filter_, dev),
129 detail::clear_flags(flags())
130 );
131 }
132 private:
filter()133 filter_ref filter() { return boost::ref(pimpl_->filter_); }
buf()134 detail::buffer<char_type>& buf() { return pimpl_->buf_; }
flags()135 int& flags() { return pimpl_->flags_; }
136
137 enum flags_ {
138 f_read = 1, f_write = 2
139 };
140
141 struct impl {
implboost::iostreams::inverse::impl142 impl(const Filter& filter, std::streamsize n)
143 : filter_(filter), buf_(n), flags_(0)
144 { buf_.set(0, 0); }
145 Filter filter_;
146 detail::buffer<char_type> buf_;
147 int flags_;
148 };
149 shared_ptr<impl> pimpl_;
150 };
151
152 //
153 // Template name: invert.
154 // Template parameters:
155 // Filter - A model of InputFilter or OutputFilter.
156 // Description: Returns an instance of an appropriate specialization of inverse.
157 //
158 template<typename Filter>
invert(const Filter & f)159 inverse<Filter> invert(const Filter& f) { return inverse<Filter>(f); }
160
161 //----------------------------------------------------------------------------//
162
163 } } // End namespaces iostreams, boost.
164
165 #include <boost/iostreams/detail/config/enable_warnings.hpp> // MSVC.
166
167 #endif // #ifndef BOOST_IOSTREAMS_INVERT_HPP_INCLUDED
168