DebugExtBuf.h

#ifndef DEBUGEXTBUF_H
#define DEBUGEXTBUF_H

// Created by Lars Gullik Bj�nnes
// Copyright 1999 Lars Gullik Bj�nnes (larsbj@lyx.org)
// Released into the public domain.

// Primarily developed for use in the LyX Project http://www.lyx.org/
// but should be adaptable to any project.

// (c) 2002 adapted for UniSet by Lav, GNU GPL license

//#define TEST_DEBUGSTREAM


#ifdef __GNUG__
#pragma implementation
#endif

//#include "DebugStream.h"
#include "Debug.h"
#include "Mutex.h"

//�Since the current C++ lib in egcs does not have a standard implementation
// of basic_streambuf and basic_filebuf we don't have to include this
// header.
//#define MODERN_STL_STREAMS
#ifdef MODERN_STL_STREAMS
#include <fstream>
#endif
#include <iostream>
#include <sstream>
#include <iomanip>
#include <time.h>
#include <iomanip>

using std::ostream;
using std::streambuf;
using std::streamsize;
using std::filebuf;
using std::stringbuf;
using std::cerr;
using std::ios;

/*
ostream & operator<<(ostream & o, Debug::type t)
{
    return o << int(t);
}
*/

class nullbuf : public streambuf
{
    protected:
#ifndef MODERN_STL_STREAMS
        typedef char char_type;
        typedef int int_type;
        virtual int sync()
        {
            return 0;
        }
#endif

        virtual streamsize xsputn(char_type const*, streamsize n)
        {
            // fakes a purge of the buffer by returning n
            return n;
        }
#ifdef MODERN_STL_STREAMS

        virtual int_type overflow(int_type c = traits_type::eof())
        {
            // fakes success by returning c
            return c == traits_type::eof() ? ' ' : c;
        }
#else

        virtual int_type overflow(int_type c = EOF)
        {
            // fakes success by returning c
            return c == EOF ? ' ' : c;
        }
#endif
};

class teebuf : public streambuf
{
    public:
        teebuf(streambuf* b1, streambuf* b2)
            : streambuf(), sb1(b1), sb2(b2) {}
    protected:
#ifdef MODERN_STL_STREAMS

        virtual int sync()
        {
            sb2->pubsync();
            return sb1->pubsync();
        }
        virtual streamsize xsputn(char_type const* p, streamsize n)
        {
            sb2->sputn(p, n);
            return sb1->sputn(p, n);
        }
        virtual int_type overflow(int_type c = traits_type::eof())
        {
            sb2->sputc(c);
            return sb1->sputc(c);
        }
#else
        typedef char char_type;
        typedef int int_type;
        virtual int sync()
        {
            sb2->sync();
            return sb1->sync();
        }
        virtual streamsize xsputn(char_type const* p, streamsize n)
        {
            sb2->xsputn(p, n);
            return sb1->xsputn(p, n);
        }
        virtual int_type overflow(int_type c = EOF)
        {
            sb2->overflow(c);
            return sb1->overflow(c);
        }
#endif
    private:
        streambuf* sb1;
        streambuf* sb2;
};

class threebuf : public streambuf
{
    public:
        threebuf(streambuf* b1, streambuf* b2, streambuf* b3)
            : streambuf(), sb1(b1), sb2(b2), sb3(b3) {}
    protected:
#ifdef MODERN_STL_STREAMS

        virtual int sync()
        {
            sb2->pubsync();
            return sb1->pubsync();
        }
        virtual streamsize xsputn(char_type const* p, streamsize n)
        {
            sb2->sputn(p, n);
            sb3->sputn(p, n);
            return sb1->sputn(p, n);
        }
        virtual int_type overflow(int_type c = traits_type::eof())
        {
            sb2->sputc(c);
            sb3->sputc(c);
            return sb1->sputc(c);
        }
#else
        typedef char char_type;
        typedef int int_type;
        virtual int sync()
        {
            sb2->sync();
            sb3->sync();
            return sb1->sync();
        }
        virtual streamsize xsputn(char_type const* p, streamsize n)
        {
            sb2->xsputn(p, n);
            sb2->xsputn(p, n);
            return sb1->xsputn(p, n);
        }
        virtual int_type overflow(int_type c = EOF)
        {
            sb2->overflow(c);
            sb3->owerflow(c);
            return sb1->overflow(c);
        }
#endif
    private:
        streambuf* sb1;
        streambuf* sb2;
        streambuf* sb3;
};

class debugbuf : public streambuf
{
    public:
        explicit debugbuf(streambuf* b)
            : streambuf(), sb(b) {}
    protected:
#ifdef MODERN_STL_STREAMS

        virtual int sync()
        {
            return sb->pubsync();
        }
        virtual streamsize xsputn(char_type const* p, streamsize n)
        {
            return sb->sputn(p, n);
        }
        virtual int_type overflow(int_type c = traits_type::eof())
        {
            return sb->sputc(c);
        }
#else
        typedef char char_type;
        typedef int int_type;
        virtual int sync()
        {
            return sb->sync();
        }
        virtual streamsize xsputn(char_type const* p, streamsize n)
        {
            return sb->xsputn(p, n);
        }
        virtual int_type overflow(int_type c = EOF)
        {
            return sb->overflow(c);
        }
#endif
    private:
        streambuf* sb;
};

class stringsigbuf : public streambuf
{
    public:
        stringsigbuf(): sb(new stringbuf())
        {
        }

        ~stringsigbuf()
        {
            if( sb )
            {
                delete sb;
                sb = 0;
            }
        }

        explicit stringsigbuf( stringbuf* b )
            : streambuf(), sb(b) {}

        typedef sigc::signal<void, const std::string&> StrBufOverflow_Signal;
        inline StrBufOverflow_Signal signal_overflow()
        {
            return s_overflow;
        }

    protected:
#ifdef MODERN_STL_STREAMS

        virtual int sync()
        {
            UniSetTypes::uniset_rwmutex_wrlock l(mut);
            return sb->pubsync();
        }

        virtual streamsize xsputn(char_type const* p, streamsize n)
        {
            UniSetTypes::uniset_rwmutex_wrlock l(mut);
            streamsize r = sb->sputn(p, n);
            s_overflow.emit( sb->str() );
            sb->str("");
            return r;
        }
        virtual int_type overflow(int_type c = traits_type::eof())
        {
            int_type r = sb->sputc(c);

            if( r == '\n' )
            {
                UniSetTypes::uniset_rwmutex_wrlock l(mut);
                s_overflow.emit( sb->str() );
                sb->str("");
            }

            return r;
        }
#else
        typedef char char_type;
        typedef int int_type;
        virtual int sync()
        {
            return sb->sync();
        }
        virtual streamsize xsputn(char_type const* p, streamsize n)
        {
            return sb->xsputn(p, n);
        }

        virtual int_type overflow(int_type c = EOF)
        {
            int_type r = sb->overflow(c);

            if( r == '\n' )
            {
                UniSetTypes::uniset_rwmutex_wrlock l(mut);
                s_overflow.emit( sb->str() );
                sb->str("");
            }

            return r;
        }
#endif
    private:
        StrBufOverflow_Signal s_overflow;
        stringbuf* sb;
        UniSetTypes::uniset_rwmutex mut;
};
//--------------------------------------------------------------------------
struct DebugStream::debugstream_internal
{
    filebuf fbuf;
    stringsigbuf sbuf;
    nullbuf nbuf;
};
//--------------------------------------------------------------------------
#endif