#ifndef _STLP_STRING_IO_C

#define _STLP_STRING_IO_C

#ifndef _STLP_STRING_IO_H

#  include <stl/_string_io.h>

#endif

#ifndef _STLP_INTERNAL_CTYPE_H

#  include <stl/_ctype.h>

#endif

_STLP_BEGIN_NAMESPACE

template <class _CharT, class _Traits>

bool _STLP_CALL

__stlp_string_fill(basic_ostream<_CharT, _Traits>& __os,

                   basic_streambuf<_CharT, _Traits>* __buf,

                   streamsize __n) {

  _CharT __f = __os.fill();

  for (streamsize __i = 0; __i < __n; ++__i) {

    if (_Traits::eq_int_type(__buf->sputc(__f), _Traits::eof()))

      return false;

  }

  return true;

}

template <class _CharT, class _Traits, class _Alloc>

basic_ostream<_CharT, _Traits>& _STLP_CALL

operator << (basic_ostream<_CharT, _Traits>& __os,

             const basic_string<_CharT,_Traits,_Alloc>& __s) {

  typedef basic_ostream<_CharT, _Traits> __ostream;

  typedef typename basic_string<_CharT, _Traits, _Alloc>::size_type size_type;

  // The hypothesis of this implementation is that size_type is unsigned:

  _STLP_STATIC_ASSERT(__STATIC_CAST(size_type, -1) > 0)

  typename __ostream::sentry __sentry(__os);

  bool __ok = false;

  if (__sentry) {

    __ok = true;

    size_type __n = __s.size();

    const bool __left = (__os.flags() & __ostream::left) != 0;

    const streamsize __w = __os.width(0);

    basic_streambuf<_CharT, _Traits>* __buf = __os.rdbuf();

    const bool __need_pad = (((sizeof(streamsize) > sizeof(size_t)) && (__STATIC_CAST(streamsize, __n) < __w)) ||

                             ((sizeof(streamsize) <= sizeof(size_t)) && (__n < __STATIC_CAST(size_t, __w))));

    streamsize __pad_len = __need_pad ? __w - __n : 0;

    if (!__left)

      __ok = __stlp_string_fill(__os, __buf, __pad_len);

    __ok = __ok && (__buf->sputn(__s.data(), streamsize(__n)) == streamsize(__n));

    if (__left)

      __ok = __ok && __stlp_string_fill(__os, __buf, __pad_len);

  }

  if (!__ok)

    __os.setstate(__ostream::failbit);

  return __os;

}

template <class _CharT, class _Traits, class _Alloc>

basic_istream<_CharT, _Traits>& _STLP_CALL

operator >> (basic_istream<_CharT, _Traits>& __is,

             basic_string<_CharT,_Traits, _Alloc>& __s) {

  typedef basic_istream<_CharT, _Traits> __istream;

  typedef typename basic_string<_CharT, _Traits, _Alloc>::size_type size_type;

  // The hypothesis of this implementation is that size_type is unsigned:

  _STLP_STATIC_ASSERT(__STATIC_CAST(size_type, -1) > 0)

  typename __istream::sentry __sentry(__is);

  if (__sentry) {

    basic_streambuf<_CharT, _Traits>* __buf = __is.rdbuf();

    typedef ctype<_CharT> _C_type;

    const locale& __loc = __is.getloc();

    const _C_type& _Ctype = use_facet<_C_type>(__loc);

    __s.clear();

    streamsize __width = __is.width(0);

    size_type __n;

    if (__width <= 0)

      __n = __s.max_size();

    /* __width can only overflow size_type if sizeof(streamsize) > sizeof(size_type)

     * because here we know that __width is positive and the stattic assertion check

     * that size_type is unsigned.

     */

    else if (sizeof(streamsize) > sizeof(size_type) &&

             (__width > __STATIC_CAST(streamsize, __s.max_size())))

      __n = 0;

    else {

      __n = __STATIC_CAST(size_type, __width);

      __s.reserve(__n);

    }

    while (__n-- > 0) {

      typename _Traits::int_type __c1 = __buf->sbumpc();

      if (_Traits::eq_int_type(__c1, _Traits::eof())) {

        __is.setstate(__istream::eofbit);

        break;

      }

      else {

        _CharT __c = _Traits::to_char_type(__c1);

        if (_Ctype.is(_C_type::space, __c)) {

          if (_Traits::eq_int_type(__buf->sputbackc(__c), _Traits::eof()))

            __is.setstate(__istream::failbit);

          break;

        }

        else

          __s.push_back(__c);

      }

    }

    // If we have read no characters, then set failbit.

    if (__s.empty())

      __is.setstate(__istream::failbit);

  }

  else

    __is.setstate(__istream::failbit);

  return __is;

}

template <class _CharT, class _Traits, class _Alloc>

basic_istream<_CharT, _Traits>& _STLP_CALL

getline(basic_istream<_CharT, _Traits>& __is,

        basic_string<_CharT,_Traits,_Alloc>& __s,

        _CharT __delim) {

  typedef basic_istream<_CharT, _Traits> __istream;

  typedef typename basic_string<_CharT, _Traits, _Alloc>::size_type size_type;

  size_type __nread = 0;

  typename basic_istream<_CharT, _Traits>::sentry __sentry(__is, true);

  if (__sentry) {

    basic_streambuf<_CharT, _Traits>* __buf = __is.rdbuf();

    __s.clear();

    while (__nread < __s.max_size()) {

      int __c1 = __buf->sbumpc();

      if (_Traits::eq_int_type(__c1, _Traits::eof())) {

        __is.setstate(__istream::eofbit);

        break;

      }

      else {

        ++__nread;

        _CharT __c = _Traits::to_char_type(__c1);

        if (!_Traits::eq(__c, __delim))

          __s.push_back(__c);

        else

          break;              // Character is extracted but not appended.

      }

    }

  }

  if (__nread == 0 || __nread >= __s.max_size())

    __is.setstate(__istream::failbit);

  return __is;

}

_STLP_END_NAMESPACE

#endif

// Local Variables:

// mode:C++

// End: