/elec/propeller-clock

To get this branch, use:
bzr branch http://bzr.ed.am/elec/propeller-clock
57 by edam
added ulibc
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