/elec/propeller-clock

To get this branch, use:
bzr branch http://bzr.ed.am/elec/propeller-clock

« back to all changes in this revision

Viewing changes to src/utility/iterator

  • Committer: edam
  • Date: 2012-02-16 00:13:13 UTC
  • Revision ID: edam@waxworlds.org-20120216001313-5w52cnns4cqofb6e
updated arduino.mk

Show diffs side-by-side

added added

removed removed

Lines of Context:
1
 
/*      Copyright (C) 2004 Garrett A. Kajmowicz
2
 
 
3
 
        This file is part of the uClibc++ Library.
4
 
 
5
 
        This library is free software; you can redistribute it and/or
6
 
        modify it under the terms of the GNU Lesser General Public
7
 
        License as published by the Free Software Foundation; either
8
 
        version 2.1 of the License, or (at your option) any later version.
9
 
 
10
 
        This library is distributed in the hope that it will be useful,
11
 
        but WITHOUT ANY WARRANTY; without even the implied warranty of
12
 
        MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
13
 
        Lesser General Public License for more details.
14
 
 
15
 
        You should have received a copy of the GNU Lesser General Public
16
 
        License along with this library; if not, write to the Free Software
17
 
        Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
18
 
*/
19
 
 
20
 
#include <basic_definitions>
21
 
#include <iosfwd>
22
 
#include <cstddef>
23
 
#include <char_traits>
24
 
#include <iterator_base>
25
 
 
26
 
 
27
 
 
28
 
#ifndef __STD_HEADER_ITERATOR
29
 
#define __STD_HEADER_ITERATOR 1
30
 
 
31
 
#pragma GCC visibility push(default)
32
 
 
33
 
namespace std{
34
 
 
35
 
  // subclause _lib.stream.iterators_, stream iterators:
36
 
        template <class T, class charT = char, class traits = char_traits<charT>, class Distance = ptrdiff_t> class istream_iterator;
37
 
        template <class T, class charT, class traits, class Distance> bool 
38
 
                operator==(const istream_iterator<T,charT,traits,Distance>& x, const istream_iterator<T,charT,traits,Distance>& y);
39
 
        template <class T, class charT, class traits, class Distance> bool 
40
 
                operator!=(const istream_iterator<T,charT,traits,Distance>& x, const istream_iterator<T,charT,traits,Distance>& y);
41
 
        template <class T, class charT = char, class traits = char_traits<charT> > class ostream_iterator;
42
 
        template<class charT, class traits = char_traits<charT> > class istreambuf_iterator;
43
 
        template <class charT, class traits> bool 
44
 
                operator==(const istreambuf_iterator<charT,traits>& a, const istreambuf_iterator<charT,traits>& b);
45
 
        template <class charT, class traits> bool 
46
 
                operator!=(const istreambuf_iterator<charT,traits>& a, const istreambuf_iterator<charT,traits>& b);
47
 
        template <class charT, class traits = char_traits<charT> > class ostreambuf_iterator;
48
 
 
49
 
        
50
 
        template < class T, class charT, class traits, class Distance > class _UCXXEXPORT istream_iterator
51
 
                : public iterator<input_iterator_tag,T,Distance,const T*, const T&>
52
 
        {
53
 
        public:
54
 
                typedef charT char_type;
55
 
                typedef traits traits_type;
56
 
                typedef basic_istream<charT,traits> istream_type;
57
 
                istream_iterator() : in_stream(0), value(0) {}
58
 
                istream_iterator(istream_type& s) : in_stream(&s), value() {
59
 
                        *in_stream >> value;
60
 
                }
61
 
                istream_iterator(const istream_iterator<T,charT,traits,Distance>& x)
62
 
                        : in_stream(x.in_stream), value(x.value)
63
 
                { }
64
 
                ~istream_iterator() { }
65
 
                const T& operator*() const{
66
 
                        return value;
67
 
                }
68
 
                const T* operator->() const{
69
 
                        return &value;
70
 
                }
71
 
                istream_iterator<T,charT,traits,Distance>& operator++() {
72
 
                        *in_stream >> value;
73
 
                        return *this;
74
 
                }
75
 
                istream_iterator<T,charT,traits,Distance>  operator++(int){
76
 
                        istream_iterator<T,charT,traits,Distance> tmp = *this;
77
 
                        *in_stream >> value;
78
 
                        return (tmp);
79
 
                }
80
 
                bool m_equal(const istream_iterator<T,charT,traits,Distance>& x) const{
81
 
                        return (in_stream == x.in_stream);
82
 
                }
83
 
        private:
84
 
                basic_istream<charT,traits>* in_stream;
85
 
                T value;
86
 
        };
87
 
 
88
 
        template <class T, class charT, class traits, class Distance> _UCXXEXPORT 
89
 
                bool operator==(const istream_iterator<T,charT,traits,Distance>& x,
90
 
                const istream_iterator<T,charT,traits,Distance>& y)
91
 
        {
92
 
                return x.m_equal(y);
93
 
        }
94
 
 
95
 
        template <class T, class charT, class traits, class Distance> _UCXXEXPORT 
96
 
                bool operator!=(const istream_iterator<T,charT,traits,Distance>& x,
97
 
                const istream_iterator<T,charT,traits,Distance>& y)
98
 
        {
99
 
                return !(x == y);
100
 
        }
101
 
 
102
 
        template <class T, class charT, class traits> class _UCXXEXPORT ostream_iterator
103
 
                : public iterator<output_iterator_tag,void,void,void,void>
104
 
        {
105
 
        public:
106
 
                typedef charT char_type;
107
 
                typedef traits traits_type;
108
 
                typedef basic_ostream<charT,traits> ostream_type;
109
 
 
110
 
                ostream_iterator(ostream_type& s) : out_stream(&s), delim(0) { }
111
 
                ostream_iterator(ostream_type& s, const charT* delimiter) : out_stream(&s), delim(delimiter) { }
112
 
                ostream_iterator(const ostream_iterator<T,charT,traits>& x) : out_stream(x.out_stream), delim(x.delim) { }
113
 
                ~ostream_iterator() { }
114
 
                ostream_iterator<T,charT,traits>& operator=(const T& value){
115
 
                        *out_stream << value;
116
 
                        if(delim != 0){
117
 
                                *out_stream << delim;
118
 
                        }
119
 
                        return (*this);
120
 
                }
121
 
                ostream_iterator<T,charT,traits>& operator*(){ return *this; }
122
 
                ostream_iterator<T,charT,traits>& operator++() { return *this; }
123
 
                ostream_iterator<T,charT,traits> operator++(int) { return *this; }
124
 
        private:
125
 
                basic_ostream<charT,traits>* out_stream;
126
 
                const char* delim;
127
 
        };
128
 
 
129
 
        template<class charT, class traits > class _UCXXEXPORT istreambuf_iterator : 
130
 
                public iterator<input_iterator_tag, charT, typename traits::off_type, charT*, charT&>
131
 
        {
132
 
        public:
133
 
                typedef charT                           char_type;
134
 
                typedef traits                          traits_type;
135
 
                typedef typename traits::int_type       int_type;
136
 
                typedef basic_streambuf<charT,traits>   streambuf_type;
137
 
                typedef basic_istream<charT,traits>     istream_type;
138
 
 
139
 
                class _UCXXEXPORT proxy{
140
 
                        charT val;
141
 
                        basic_streambuf<charT, traits> * buf;
142
 
                        
143
 
                        proxy(charT v, basic_streambuf<charT, traits> * b) : val(v), buf(b) { }
144
 
                public:
145
 
                        charT operator*() { return val; }
146
 
                };
147
 
 
148
 
                istreambuf_iterator() throw() : sbuf(0) { }
149
 
                istreambuf_iterator(istream_type& s) throw() : sbuf(s.rdbuf()) { }
150
 
                istreambuf_iterator(streambuf_type* s) throw() : sbuf(s) { }
151
 
                istreambuf_iterator(const proxy& p) throw() : sbuf(&p.buf) { }
152
 
 
153
 
                charT operator*() const{
154
 
                        return sbuf->sgetc();
155
 
                }
156
 
                istreambuf_iterator<charT,traits>& operator++(){
157
 
                        sbuf->sbumpc();
158
 
                        return *this;
159
 
                }
160
 
                proxy operator++(int){
161
 
                        istreambuf_iterator<charT,traits> tmp = *this;
162
 
                        sbuf->sbumpc();
163
 
                        return(tmp);
164
 
                }
165
 
 
166
 
                bool equal(const istreambuf_iterator& b) const{
167
 
                        return sbuf == b.sbuf || is_eof() && b.is_eof();
168
 
                }
169
 
        private:
170
 
                streambuf_type* sbuf;
171
 
                inline bool is_eof() const{
172
 
                        return sbuf == 0 || sbuf->sgetc() == traits_type::eof();
173
 
                }
174
 
        };
175
 
 
176
 
        template <class charT, class traits> _UCXXEXPORT bool
177
 
                operator==(const istreambuf_iterator<charT,traits>& a,
178
 
                const istreambuf_iterator<charT,traits>& b)
179
 
        {
180
 
                return a.equal(b);
181
 
        }
182
 
 
183
 
        template <class charT, class traits> bool _UCXXEXPORT 
184
 
                operator!=(const istreambuf_iterator<charT,traits>& a,
185
 
                const istreambuf_iterator<charT,traits>& b)
186
 
        {
187
 
                return !a.equal(b);
188
 
        }
189
 
 
190
 
        template <class charT, class traits> class _UCXXEXPORT ostreambuf_iterator
191
 
                : iterator<output_iterator_tag,void,void,void,void>
192
 
        {
193
 
        public:
194
 
                typedef charT                         char_type;
195
 
                typedef traits                        traits_type;
196
 
                typedef basic_streambuf<charT,traits> streambuf_type;
197
 
                typedef basic_ostream<charT,traits>   ostream_type;
198
 
        public:
199
 
                ostreambuf_iterator(ostream_type& s) throw() : sbuf(s.rdbuf()), f(false) { }
200
 
                ostreambuf_iterator(streambuf_type* s) throw() : sbuf(s), f(false) { }
201
 
                ostreambuf_iterator& operator=(charT c){
202
 
                        if(failed() == false){
203
 
                                if(sbuf->sputc(c) == traits::eof()){
204
 
                                        f = true;
205
 
                                }
206
 
                        }
207
 
                        return *this;
208
 
                }
209
 
                ostreambuf_iterator& operator*(){
210
 
                        return *this;
211
 
                }
212
 
                ostreambuf_iterator& operator++() { return *this; }
213
 
                ostreambuf_iterator operator++(int) { return *this; }
214
 
                bool failed() const throw(){
215
 
                        return f;
216
 
                }
217
 
 
218
 
        private:
219
 
                streambuf_type* sbuf;
220
 
                bool f;
221
 
        };
222
 
 
223
 
}
224
 
 
225
 
#pragma GCC visibility pop
226
 
 
227
 
#endif
228
 
 
229