source: NonGTP/Boost/boost/iostreams/detail/vc6/write.hpp @ 857

Revision 857, 4.6 KB checked in by igarcia, 18 years ago (diff)
Line 
1// (C) Copyright Jonathan Turkanis 2005.
2// Distributed under the Boost Software License, Version 1.0. (See accompanying
3// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt.)
4
5// See http://www.boost.org/libs/iostreams for documentation.
6
7namespace boost { namespace iostreams {
8
9namespace detail {
10
11template<typename T>
12struct write_device_impl;
13
14template<typename T>
15struct write_filter_impl;
16
17} // End namespace detail.
18
19template<typename T>
20bool put(T& t, typename char_type_of<T>::type c)
21{
22    typedef typename detail::unwrapped_type<T>::type unwrapped;
23    return detail::write_device_impl<T>::inner<unwrapped>::put(detail::unwrap(t), c);
24}
25
26template<typename T>
27inline std::streamsize write
28    (T& t, const typename char_type_of<T>::type* s, std::streamsize n)
29{
30    typedef typename detail::unwrapped_type<T>::type unwrapped;
31    return detail::write_device_impl<T>::inner<unwrapped>::write(detail::unwrap(t), s, n);
32}
33
34template<typename T, typename Sink>
35inline std::streamsize
36write( T& t, Sink& snk, const typename char_type_of<T>::type* s,
37       std::streamsize n )
38{
39    typedef typename detail::unwrapped_type<T>::type unwrapped;
40    return detail::write_filter_impl<T>::inner<unwrapped>::write(detail::unwrap(t), snk, s, n);
41}
42
43namespace detail {
44
45//------------------Definition of write_device_impl---------------------------//
46
47template<typename T>
48struct write_device_impl
49    : mpl::if_<
50          is_custom<T>,
51          operations<T>,
52          write_device_impl<
53              BOOST_DEDUCED_TYPENAME
54              dispatch<
55                  T, ostream_tag, streambuf_tag, output
56              >::type
57          >
58      >::type
59    { };
60
61template<>
62struct write_device_impl<ostream_tag> {
63    template<typename T>
64    struct inner {
65        static bool put(T& t, typename char_type_of<T>::type c)
66        {
67            typedef typename char_type_of<T>::type          char_type;
68            typedef BOOST_IOSTREAMS_CHAR_TRAITS(char_type)  traits_type;
69            return !traits_type::eq_int_type( t.rdbuf()->s.sputc(),
70                                            traits_type::eof() );
71        }
72
73        static std::streamsize write
74            (T& t, const typename char_type_of<T>::type* s, std::streamsize n)
75        { return t.rdbuf()->sputn(s, n); }
76    };
77};
78
79template<>
80struct write_device_impl<streambuf_tag> {
81    template<typename T>
82    struct inner {
83        static bool put(T& t, typename char_type_of<T>::type c)
84        {
85            typedef typename char_type_of<T>::type          char_type;
86            typedef BOOST_IOSTREAMS_CHAR_TRAITS(char_type)  traits_type;
87            return !traits_type::eq_int_type(t.sputc(c), traits_type::eof());
88        }
89
90        template<typename T>
91        static std::streamsize write
92            (T& t, const typename char_type_of<T>::type* s, std::streamsize n)
93        { return t.sputn(s, n); }
94    };
95};
96
97template<>
98struct write_device_impl<output> {
99    template<typename T>
100    struct inner {
101        static bool put(T& t, typename char_type_of<T>::type c)
102        { return t.write(&c, 1) == 1; }
103
104        template<typename T>
105        static std::streamsize
106        write(T& t, const typename char_type_of<T>::type* s, std::streamsize n)
107        { return t.write(s, n); }
108    };
109};
110
111//------------------Definition of write_filter_impl---------------------------//
112
113template<typename T>
114struct write_filter_impl
115    : mpl::if_<
116          is_custom<T>,
117          operations<T>,
118          write_filter_impl<
119              BOOST_DEDUCED_TYPENAME
120              dispatch<
121                  T, multichar_tag, any_tag
122              >::type
123          >
124      >::type
125    { };
126
127template<>
128struct write_filter_impl<multichar_tag> {
129    template<typename T>
130    struct inner {
131        template<typename Sink>
132        static std::streamsize
133        write( T& t, Sink& snk, const typename char_type_of<T>::type* s,
134               std::streamsize n )
135        { return t.write(snk, s, n); }
136    };
137};
138
139template<>
140struct write_filter_impl<any_tag> {
141    template<typename T>
142    struct inner {
143        template<typename Sink>
144        static std::streamsize
145        write( T& t, Sink& snk, const typename char_type_of<T>::type* s,
146               std::streamsize n )
147        {
148            for (std::streamsize off = 0; off < n; ++off)
149                if (!t.put(snk, s[off]))
150                    return off;
151            return n;
152        }
153    };
154};
155
156} // End namespace detail.
157
158} } // End namespaces iostreams, boost.
Note: See TracBrowser for help on using the repository browser.