DebugRouter.h

Go to the documentation of this file.

//Luke Lenhart, 2007
//See /docs/License.txt for details on how this code may be used.
/*
This system allows you to hook up chains of outputs systems.
The actual output occurs in a different thread, minimizing overhead on the caller thread.

For example:
One might create a DebugRouter for errors and a DebugRouter for informational messages.
The errors router could output everything to an error file.
The informational router could output everything to an informational file.
They both could also output to a third router instance, which in turns outputs everything to a debug window.
[Output Error File]<-----------------+--------[error Input]<-----------
                                    /                                  \
[Output Debug Window]<-------[merged Input]                        [Program]
                                    \                                  /
[Output Info File]<------------------+--------[info Input]<------------

*/

#pragma once

#include "Locks.h"
#include "Vary.h"
#include "Thread.h"
#include "File.h" //for Filename
#include <string>
#include <list>
#include "Setup.h"

namespace MPMA
{
    // -- Router system

    class RouterOutput
    {
    public:
        inline RouterOutput(): bufferedDataProcessing(true) {}
        virtual ~RouterOutput();

        virtual void Output(const uint8 *data, uint dataLen);

        inline bool IsBufferProcessing() {return bufferedDataProcessing;}

        //Flushes all output from all sources that connect to this output.
        //It is recemmonded that your derived classes's destructor call this first thing, to ensure that all buffered output makes it through.
        virtual void FlushInputSources();

    protected:
        //your derived class can choose to change this from the default (true) during construction to disable buffered output
        bool bufferedDataProcessing;

    private:
        SpinLock feedLock;
        std::list<class RouterInput*> reportFeeds;
        void DetachFeed(RouterInput *feed);

        friend class RouterInput;

        //you cannot duplicate this
        RouterOutput(const RouterOutput&);
        const RouterOutput& operator=(const RouterOutput&);
    };

#ifdef DEBUGROUTER_ENABLED
    class RouterInput: public RouterOutput
    {
    public:
        //
        RouterInput();
        ~RouterInput();

        inline RouterInput& operator<<(const Vary &v) {const std::string &s=v; Output((const uint8*)&s[0], s.size()); return *this;}
        inline friend RouterInput& operator<<(RouterInput &db, RouterInput &db2) {return db;}

        void Output(const uint8 *data, uint dataLen);
        inline void Output(const Vary &v) {*this<<v;}

        void AddOutputMethod(RouterOutput *outputter);

        void RemoveOutputMethod(RouterOutput *outputter, bool flushOutputFirst=true, bool removeChildLink=true);

    private:
        bool IsBufferProcessing();
        void FlushOutput();
        virtual void FlushInputSources();

        std::list<RouterOutput*> outputs;
        MutexLock outputLock;

        //data marshelling
        Thread *dataMover;
        static void ThreadProc(Thread &thread, ThreadParam param);
        volatile bool destructing;
        BlockingObject workerWaiter;
        BlockingObject routerWaiter;
        volatile uint8 *buffer;
        volatile uint bufferLen;
        SpinLock dataLock;
        MutexLock addDataLock;
        SpinLock threadWorkingLock;

        uint numNonbufferedOutputs;
        bool alive;

        friend class RouterOutput;

        //you cannot duplicate this
        RouterInput(const RouterInput&);
        const RouterInput& operator=(const RouterInput&);
    };
#else //dummy do-nothing implementation - when reporder is disabled
    class RouterInput: public RouterOutput
    {
    public:
        inline RouterInput& operator<<(const Vary &v) {return *this;}
        inline friend RouterInput& operator<<(RouterInput &db, RouterInput &db2) {return db;}

        inline void Output(const uint8 *data, uint dataLen) {}
        inline void Output(const Vary &v) {}
        inline void AddOutputMethod(RouterOutput *outputter) {}
        inline void RemoveOutputMethod(RouterOutput *outputter, bool flushOutputFirst=true, bool removeChildLink=true) {}

        friend class RouterOutput;
    };
#endif


    // -- Some useful output implementations

    class RouterOutputFile: public RouterOutput
    {
    public:
        RouterOutputFile(const Filename &fileName, bool textMode=true);
        ~RouterOutputFile();

        void Output(const uint8 *data, uint dataLen);
    private:
#ifdef DEBUGROUTER_ENABLED
        FILE *f;
        MutexLock lock;
#endif

        //you cannot duplicate this
        RouterOutputFile(const RouterOutputFile&);
        const RouterOutputFile& operator=(const RouterOutputFile&);
    };

    class RouterOutputStdout: public RouterOutput
    {
    public:
        ~RouterOutputStdout();
        void Output(const uint8 *data, uint dataLen);
    };


    // -- framework error reporter
    //After you initialize the framework, you should add a destination to "MPMA::ErrorReport()".

    //Use "MPMA::ErrorReport()" for anything that happens that should never happen within the framework.
    extern RouterInput *errorReportPointer;

    inline RouterInput& ErrorReport()
    {
#ifdef _DEBUG
        if (errorReportPointer==0) throw "Error RouterInput pointer is null.  Maybe you need to Initialize the framework before using it.";
#endif
        return *errorReportPointer;
    }


} //namespace MPMA