// nulloutbuf.h ---------------------------------------


#include <streambuf> 

#include <locale>

namespace KyloSTL
{
    // MSVC 6 (or at least, my version of it) will NOT allow you to specify

    // these explicitly, but will compile happily with these using statements.

    // Hopefully this namespace pollution is confined to this namespace,

    // but who knows what MSVC decides.

    using std::char_traits;
    using std::basic_streambuf;
    using std::basic_ostream;

    // Null output stream buffer -----------------------------------------

    template <class charT, class traits = char_traits<charT> >
    class basic_nulloutbuf : public basic_streambuf<charT, traits>
    {
    protected:
        virtual int_type overflow(int_type c)
        {
            // Return not_eof, as we never need to stop writing

            return traits::not_eof(c);
        }
    };

    typedef basic_nulloutbuf<char>    nulloutbuf;
    typedef basic_nulloutbuf<wchar_t> wnulloutbuf;

    // Null output stream ----------------------------------------------------

    template <class charT, class traits = char_traits<charT> >
    class basic_nullostream : public basic_ostream<charT, traits>
    {
    protected:
        basic_nulloutbuf<charT, traits> buf;
    public:
        basic_nullostream() : basic_ostream<charT, traits>(&buf) {}
    };

    typedef basic_nullostream<char>    nullostream;
    typedef basic_nullostream<wchar_t> wnullostream;

} // end KyloSTL namespace





// nullinbuf.h ------------------------------------


#include <streambuf>

#include <locale>

namespace KyloSTL
{
    // MSVC 6 (or at least, my version of it) will NOT allow you to specify

    // these explicitly, but will compile happily with these using statements.

    // Hopefully this namespace pollution is confined to this namespace,

    // but who knows what MSVC decides.

    using std::char_traits;
    using std::basic_streambuf;
    using std::basic_istream;

    // Null input stream buffer ------------------------------------------

    template <class charT, class traits = char_traits<charT> >
    class basic_nullinbuf : public basic_streambuf<charT, traits>
    {
    private:
        // This is what will be ''read'' each time

        int_type theValue;

    protected:
        // Always the same character...

        virtual int_type underflow()
        { return theValue; }

        // No buffer, so we get this direct from underflow and don''t

        // need all the traits conversion trickery to change it to an

        // int_type

        virtual int_type uflow()
        { return underflow(); }

    public:
        basic_nullinbuf(int_type v) : theValue(v) {}
    };

    typedef basic_nullinbuf<char>    nullinbuf;
    typedef basic_nullinbuf<wchar_t> wnullinbuf;


    // Null input stream -----------------------------------------------------

    template <class charT, class traits = char_traits<charT> >
    class basic_nullistream : public basic_istream<charT, traits>
    {
    protected:
        basic_nullinbuf<charT, traits> buf;
    public:
        // Hmm... initialisation order issue? Dunno...

        basic_nullistream(int_type v = 0) : buf(v), basic_istream<charT, traits>(&buf) {};
    };

    typedef basic_nullistream<char>    nullistream;
    typedef basic_nullistream<wchar_t> wnullistream;

} // end KyloSTL namespace

  

  //using std::char_traits;//using std::basic_streambuf;using std::basic_ostream;// Null output stream buffer -----------------------------------------template <class charT, class traits = std::char_traits<charT> >class basic_nulloutbuf : public std::basic_streambuf<charT, traits>  

  template <class T>basic_nullistream<charT, traits>& operator>> (T& val){    val = T();    return *this;}