include/rw/_streamiter.h

/***************************************************************************
 *
 * _streamiter.h - Definitions of stream iterator templates
 *
 * This is an internal header file used to implement the C++ Standard
 * Library. It should never be #included directly by a program.
 *
 * $Id$
 *
 ***************************************************************************
 *
 * Copyright 2005-2006 The Apache Software Foundation or its licensors,
 * as applicable.
 *
 * Copyright 1994-2006 Rogue Wave Software.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 * 
 **************************************************************************/

#ifndef _RWSTD_RW_STREAMITER_H_INCLUDED
#define _RWSTD_RW_STREAMITER_H_INCLUDED

#ifndef _RWSTD_RW_ITERBASE_H_INCLUDED
#  include <rw/_iterbase.h>
#endif   // _RWSTD_RW_ITERBASE_H_INCLUDED

#include <iosfwd>


_RWSTD_NAMESPACE (std) { 


template <class _TypeT, class _CharT, class _Traits, class _Distance>
class istream_iterator;

template <class _TypeT, class _CharT, class _Traits, class _Distance>
bool operator== (const istream_iterator<_TypeT, _CharT, _Traits, _Distance>&,
                 const istream_iterator<_TypeT, _CharT, _Traits, _Distance>&);

// 24.5.1
#if !defined (_MSC_VER) || _MSC_VER > 1300

template <class _TypeT, class _CharT = char,
          class _Traits = char_traits<_CharT>,
          class _Distance = _RWSTD_PTRDIFF_T>
#else

// prevent MSVC 6.0 ICE
template <class _TypeT, class _CharT, class _Traits, class _Distance>

#endif

class istream_iterator
    : public iterator<input_iterator_tag, _TypeT, _Distance,
                      const _TypeT*, const _TypeT&>
{
    friend bool _RWSTD_SPECIALIZED_FRIEND (operator==)
        (const istream_iterator&, const istream_iterator&);

    typedef iterator<input_iterator_tag, _TypeT, _Distance,
                     const _TypeT*, const _TypeT&> _C_base;

public: 

    typedef _CharT                                char_type;
    typedef _Traits                               traits_type;
    typedef basic_istream<char_type, traits_type> istream_type;

    // for convenience
    typedef _TYPENAME _C_base::value_type         value_type;

    // 24.5.1.1, p1
    istream_iterator (): _C_strm (0) { }

    // 24.5.1.1, p2
    istream_iterator (istream_type& __s)
        : _C_strm (&__s) {
        ++*this;
    }

    // 24.5.1.2, p1
    const value_type& operator* () const {
        return _C_val;
    }

    // 24.5.1.2, p2
    _RWSTD_OPERATOR_ARROW (const value_type* operator->() const);

    // 24.5.1.2, p3
    istream_iterator& operator++ () {
        return _C_strm && !!*_C_strm && (*_C_strm >> _C_val), *this;
    }

    // 24.5.1.2, p5
    istream_iterator operator++ (int) {
        istream_iterator __tmp = *this;
        return ++*this, __tmp;
    }
      
protected:

    istream_type *_C_strm;   // associated stream
    value_type    _C_val;    // last extracted value
};


// 24.5.1.2, p6
template <class _TypeT, class _CharT, class _Traits, class _Distance>
inline bool
operator== (const istream_iterator<_TypeT, _CharT, _Traits, _Distance>& __x,
            const istream_iterator<_TypeT, _CharT, _Traits, _Distance>& __y)
{
    return (__x._C_strm && !!*__x._C_strm) == (__y._C_strm && !!*__y._C_strm);
}


template <class _TypeT, class _CharT, class _Traits, class _Distance>
inline bool
operator!= (const istream_iterator<_TypeT, _CharT, _Traits, _Distance>& __x,
            const istream_iterator<_TypeT, _CharT, _Traits, _Distance>& __y)
{
    return !(__x == __y);
}


// 24.5.2
template <class _TypeT, class _CharT = char,
          class _Traits = char_traits<_CharT> >
struct ostream_iterator: iterator<output_iterator_tag, void, void, void, void>
{
    typedef _CharT                                char_type;
    typedef _Traits                               traits_type;
    typedef basic_ostream<char_type, traits_type> ostream_type;

    // 24.5.2.1, p1, p2
    ostream_iterator (ostream_type& __strm, const char_type* __s = 0) 
      : _C_strm (&__strm), _C_str (__s) { }

    // 24.5.2.2, p1
    ostream_iterator& operator= (const _TypeT &__val) { 
        *_C_strm << __val;
        if (_C_str)
            *_C_strm << _C_str;
        return *this;
    }

    // 24.5.2.2, p2
    ostream_iterator& operator* () {
        return *this;
    }

    // 24.5.2.2, p3
    ostream_iterator& operator++ () {
        return *this;
    }
 
    ostream_iterator& operator++ (int) {
        return *this;
    }

private:

    ostream_type    *_C_strm;   // associated stream
    const char_type *_C_str;    // string to separate values with
};


}   // namespace std


#endif   // _RWSTD_RW_STREAMITER_H_INCLUDED