diff options
Diffstat (limited to 'misc/uClibc++/include/uClibc++/iterator')
-rw-r--r-- | misc/uClibc++/include/uClibc++/iterator | 229 |
1 files changed, 229 insertions, 0 deletions
diff --git a/misc/uClibc++/include/uClibc++/iterator b/misc/uClibc++/include/uClibc++/iterator new file mode 100644 index 000000000..b3d81b207 --- /dev/null +++ b/misc/uClibc++/include/uClibc++/iterator @@ -0,0 +1,229 @@ +/* Copyright (C) 2004 Garrett A. Kajmowicz + + This file is part of the uClibc++ Library. + + This library is free software; you can redistribute it and/or + modify it under the terms of the GNU Lesser General Public + License as published by the Free Software Foundation; either + version 2.1 of the License, or (at your option) any later version. + + This library is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + Lesser General Public License for more details. + + You should have received a copy of the GNU Lesser General Public + License along with this library; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA +*/ + +#include <basic_definitions> +#include <iosfwd> +#include <cstddef> +#include <char_traits> +#include <iterator_base> + + + +#ifndef __STD_HEADER_ITERATOR +#define __STD_HEADER_ITERATOR 1 + +#pragma GCC visibility push(default) + +namespace std{ + + // subclause _lib.stream.iterators_, stream iterators: + template <class T, class charT = char, class traits = char_traits<charT>, class Distance = ptrdiff_t> class istream_iterator; + template <class T, class charT, class traits, class Distance> bool + operator==(const istream_iterator<T,charT,traits,Distance>& x, const istream_iterator<T,charT,traits,Distance>& y); + template <class T, class charT, class traits, class Distance> bool + operator!=(const istream_iterator<T,charT,traits,Distance>& x, const istream_iterator<T,charT,traits,Distance>& y); + template <class T, class charT = char, class traits = char_traits<charT> > class ostream_iterator; + template<class charT, class traits = char_traits<charT> > class istreambuf_iterator; + template <class charT, class traits> bool + operator==(const istreambuf_iterator<charT,traits>& a, const istreambuf_iterator<charT,traits>& b); + template <class charT, class traits> bool + operator!=(const istreambuf_iterator<charT,traits>& a, const istreambuf_iterator<charT,traits>& b); + template <class charT, class traits = char_traits<charT> > class ostreambuf_iterator; + + + template < class T, class charT, class traits, class Distance > class _UCXXEXPORT istream_iterator + : public iterator<input_iterator_tag,T,Distance,const T*, const T&> + { + public: + typedef charT char_type; + typedef traits traits_type; + typedef basic_istream<charT,traits> istream_type; + istream_iterator() : in_stream(0), value(0) {} + istream_iterator(istream_type& s) : in_stream(&s), value() { + *in_stream >> value; + } + istream_iterator(const istream_iterator<T,charT,traits,Distance>& x) + : in_stream(x.in_stream), value(x.value) + { } + ~istream_iterator() { } + const T& operator*() const{ + return value; + } + const T* operator->() const{ + return &value; + } + istream_iterator<T,charT,traits,Distance>& operator++() { + *in_stream >> value; + return *this; + } + istream_iterator<T,charT,traits,Distance> operator++(int){ + istream_iterator<T,charT,traits,Distance> tmp = *this; + *in_stream >> value; + return (tmp); + } + bool m_equal(const istream_iterator<T,charT,traits,Distance>& x) const{ + return (in_stream == x.in_stream); + } + private: + basic_istream<charT,traits>* in_stream; + T value; + }; + + template <class T, class charT, class traits, class Distance> _UCXXEXPORT + bool operator==(const istream_iterator<T,charT,traits,Distance>& x, + const istream_iterator<T,charT,traits,Distance>& y) + { + return x.m_equal(y); + } + + template <class T, class charT, class traits, class Distance> _UCXXEXPORT + bool operator!=(const istream_iterator<T,charT,traits,Distance>& x, + const istream_iterator<T,charT,traits,Distance>& y) + { + return !(x == y); + } + + template <class T, class charT, class traits> class _UCXXEXPORT ostream_iterator + : public iterator<output_iterator_tag,void,void,void,void> + { + public: + typedef charT char_type; + typedef traits traits_type; + typedef basic_ostream<charT,traits> ostream_type; + + ostream_iterator(ostream_type& s) : out_stream(&s), delim(0) { } + ostream_iterator(ostream_type& s, const charT* delimiter) : out_stream(&s), delim(delimiter) { } + ostream_iterator(const ostream_iterator<T,charT,traits>& x) : out_stream(x.out_stream), delim(x.delim) { } + ~ostream_iterator() { } + ostream_iterator<T,charT,traits>& operator=(const T& value){ + *out_stream << value; + if(delim != 0){ + *out_stream << delim; + } + return (*this); + } + ostream_iterator<T,charT,traits>& operator*(){ return *this; } + ostream_iterator<T,charT,traits>& operator++() { return *this; } + ostream_iterator<T,charT,traits> operator++(int) { return *this; } + private: + basic_ostream<charT,traits>* out_stream; + const char* delim; + }; + + template<class charT, class traits > class _UCXXEXPORT istreambuf_iterator : + public iterator<input_iterator_tag, charT, typename traits::off_type, charT*, charT&> + { + public: + typedef charT char_type; + typedef traits traits_type; + typedef typename traits::int_type int_type; + typedef basic_streambuf<charT,traits> streambuf_type; + typedef basic_istream<charT,traits> istream_type; + + class _UCXXEXPORT proxy{ + charT val; + basic_streambuf<charT, traits> * buf; + + proxy(charT v, basic_streambuf<charT, traits> * b) : val(v), buf(b) { } + public: + charT operator*() { return val; } + }; + + istreambuf_iterator() throw() : sbuf(0) { } + istreambuf_iterator(istream_type& s) throw() : sbuf(s.rdbuf()) { } + istreambuf_iterator(streambuf_type* s) throw() : sbuf(s) { } + istreambuf_iterator(const proxy& p) throw() : sbuf(&p.buf) { } + + charT operator*() const{ + return sbuf->sgetc(); + } + istreambuf_iterator<charT,traits>& operator++(){ + sbuf->sbumpc(); + return *this; + } + proxy operator++(int){ + istreambuf_iterator<charT,traits> tmp = *this; + sbuf->sbumpc(); + return(tmp); + } + + bool equal(const istreambuf_iterator& b) const{ + return sbuf == b.sbuf || is_eof() && b.is_eof(); + } + private: + streambuf_type* sbuf; + inline bool is_eof() const{ + return sbuf == 0 || sbuf->sgetc() == traits_type::eof(); + } + }; + + template <class charT, class traits> _UCXXEXPORT bool + operator==(const istreambuf_iterator<charT,traits>& a, + const istreambuf_iterator<charT,traits>& b) + { + return a.equal(b); + } + + template <class charT, class traits> bool _UCXXEXPORT + operator!=(const istreambuf_iterator<charT,traits>& a, + const istreambuf_iterator<charT,traits>& b) + { + return !a.equal(b); + } + + template <class charT, class traits> class _UCXXEXPORT ostreambuf_iterator + : iterator<output_iterator_tag,void,void,void,void> + { + public: + typedef charT char_type; + typedef traits traits_type; + typedef basic_streambuf<charT,traits> streambuf_type; + typedef basic_ostream<charT,traits> ostream_type; + public: + ostreambuf_iterator(ostream_type& s) throw() : sbuf(s.rdbuf()), f(false) { } + ostreambuf_iterator(streambuf_type* s) throw() : sbuf(s), f(false) { } + ostreambuf_iterator& operator=(charT c){ + if(failed() == false){ + if(sbuf->sputc(c) == traits::eof()){ + f = true; + } + } + return *this; + } + ostreambuf_iterator& operator*(){ + return *this; + } + ostreambuf_iterator& operator++() { return *this; } + ostreambuf_iterator operator++(int) { return *this; } + bool failed() const throw(){ + return f; + } + + private: + streambuf_type* sbuf; + bool f; + }; + +} + +#pragma GCC visibility pop + +#endif + + |