source: GTP/trunk/Lib/Vis/Preprocessing/src/Timer/merror.cpp @ 2015

 /* ========================================================================
  * (C) 2000 Vienna University of Technology
  * ========================================================================
  * PROJECT: Urban Viz
  * ========================================================================*/
/** several error checking/log facilities.
  *
  * for char-strings, 'String' is typedef'd for convenience
  * This library can be used with old style iostreams 
  * (define \c OLDSTREAM for that)
  *
  * $Header: /usr/local/cvsyare/cvsyamp/src/yareutils/merror.cpp,v 1.1 2002/11/14 15:22:58 wimmer Exp $
  * @author      Michael Wimmer
  * @file                                                                   */
 /* ========================================================================*/

#include "merror.h"

// The following is to allow this to be compiled with new and old style 
// iostreams. Special care has to be taken because in ms iostreams, 
// strstream has a different name and behaves differently!
#ifndef OLDSTREAM
# include <fstream>
# include <strstream>
# define ERRSTD std
#else
# include <fstream.h>
# if defined(_MSC_VER) && !defined(__SGI_STL)
#  define MS_STRSTREAM
#  include <strstrea.h>
# else
#  include <strstream.h>
# endif
# define ERRSTD
#endif




// ---------------------------------------------------------------------------
//  PrivateErrHandler class definition
// ---------------------------------------------------------------------------


// a few functions encapsulated in a class so initialization is easier
class PrivateErrHandler
{
public:
        /// constructor
        PrivateErrHandler();
        
        /// will be forwarded to outside macros
        inline ERRSTD::ostream &GetCurrentLogStream();

        /// output the current logstream
        inline void PrintLogStream(bool overrideconsole);

        /// init the logstream (especially the logfile)
        void InitLogStream(const char *filename, bool _logtoconsole);

        /// who handles the console stream
        void SetConsoleStreamHandler(LogStreamToConsoleFunc handler);

        /// console only on/off
        bool SetLogStream(bool _logtoconsole);

        /// whether to log to file or not
        void SetLogToFile(bool yesno);

private:
        // the logfile
        ERRSTD::ofstream log_ofstream;

        // the logstring (i.e., the primary logging target)
        ERRSTD::strstream log_ostrstream;

        // log only to console?
        bool logtoconsole;

        // log to file also?
        bool logtofile;

        LogStreamToConsoleFunc CurrentLogStreamToConsoleFunc;

        /// just goes to cout
        inline static void DefaultLogStreamToConsoleFunc(
                const char *consolestring);

        // shoudn't be used
        PrivateErrHandler(const PrivateErrHandler &) {}
        PrivateErrHandler &operator=(const PrivateErrHandler &) { return *this; }
};

// ---------------------------------------------------------------------------
//  PrivateErrHandler class implementation
// ---------------------------------------------------------------------------


PrivateErrHandler::PrivateErrHandler()
        :CurrentLogStreamToConsoleFunc(DefaultLogStreamToConsoleFunc),
         logtoconsole(false), logtofile(true)
{
}


void PrivateErrHandler::SetLogToFile(bool yesno)
{
        logtofile = yesno;
}


inline ERRSTD::ostream &PrivateErrHandler::GetCurrentLogStream()
{
        return log_ostrstream;
}

inline void PrivateErrHandler::PrintLogStream(bool overrideconsole)
{
        // Note: this is only used with the old strstream, not with ostringstream
        log_ostrstream << ERRSTD::ends;

        if (log_ofstream && (logtofile || !logtoconsole))
                log_ofstream << log_ostrstream.str() << ERRSTD::flush;

        if (logtoconsole || overrideconsole || !log_ofstream)
                CurrentLogStreamToConsoleFunc(log_ostrstream.str());
        
        // Note: this was used with ostringstream, but not compatible 
        // with old iostreams
        //log_ostringstream.str("");
        
        log_ostrstream.rdbuf()->freeze(false);
        log_ostrstream.seekp(0);
}


void PrivateErrHandler::InitLogStream(const char *filename, 
                                                                          bool _logtoconsole)
{
        // Note: only works on new iostreams!
#ifdef MS_STRSTREAM
        log_ofstream.rdbuf()->setbuf(NULL, 0);
#else
        log_ofstream.rdbuf()->pubsetbuf(NULL, 0);
#endif
                
        // SGI bug: ios::in assumed!
        log_ofstream.open(filename,ERRSTD::ios::out|ERRSTD::ios::trunc);
        
        if (!log_ofstream)
        {
                EOUT("Could not open logfile!");
        }

        SetLogStream(_logtoconsole);

        OUT0("Logfile opened\n");
}

void PrivateErrHandler::SetConsoleStreamHandler(
                                                        LogStreamToConsoleFunc handler)
{
        if (handler == NULL)
                CurrentLogStreamToConsoleFunc = DefaultLogStreamToConsoleFunc;
        else
                CurrentLogStreamToConsoleFunc = handler;
}

bool PrivateErrHandler::SetLogStream(bool _logtoconsole)
{
        bool x = logtoconsole;
        logtoconsole = _logtoconsole;
        return x;
}

void PrivateErrHandler::DefaultLogStreamToConsoleFunc(
                                                                const char *consolestring)
{
        ERRSTD::cout << consolestring;
}


// ---------------------------------------------------------------------------
//  Private C-access functions
// ---------------------------------------------------------------------------

static PrivateErrHandler *theErrHandler = NULL;

inline static void _ErrInitDefault()
{
        static bool initialized = false;
        if (!initialized)
        {
                theErrHandler = new PrivateErrHandler;
                initialized = true;
        }
}

// ---------------------------------------------------------------------------
//  Public interface - exposed to macros
// ---------------------------------------------------------------------------

// logstream used by macros - this is necessary so that logstreams don't 
// give an error if used in global constructors (which are constructed 
// prior to the logfile)
ERRSTD::ostream &_GetLogStream()
{
        _ErrInitDefault();
        
        return theErrHandler->GetCurrentLogStream();
}

ERRSTD::ostream &_LogStreamDone(ERRSTD::ostream &os, bool overrideconsole)
{
        _ErrInitDefault();
        theErrHandler->PrintLogStream(overrideconsole);

        return os;
}


// ---------------------------------------------------------------------------
//  Public interface - exposed directly to application
// ---------------------------------------------------------------------------

void SetConsoleStreamHandler(LogStreamToConsoleFunc handler)
{
        _ErrInitDefault();

        theErrHandler->SetConsoleStreamHandler(handler);
}

void InitLogStream(const char *filename, bool logtofile)
{
        _ErrInitDefault();
        
        theErrHandler->InitLogStream(filename, !logtofile);
}

bool SetLogStream(bool logtofile)
{
        _ErrInitDefault();

        return !theErrHandler->SetLogStream(!logtofile);
}

void SetLogToFile(bool yesno)
{
        _ErrInitDefault();

        theErrHandler->SetLogToFile(yesno);
}


// ---------------------------------------------------------------------------
//  Win32-stuff
// ---------------------------------------------------------------------------

#ifdef WIN32

#define WIN32_LEAN_AND_MEAN
#define NOMINMAX
#include <windows.h>    // for MessageBox and stuff

void Msg(const char *msg, const char *title) 
{
  //    MessageBox(NULL, msg, title, MB_OK);
}

/// gets WIN32 API error message (used by CHKMS-macros)
char *GetErrorStringMS(DWORD errorValue)
{
        LPVOID lpMsgBuf;

        FormatMessage( 
                FORMAT_MESSAGE_ALLOCATE_BUFFER | 
                FORMAT_MESSAGE_FROM_SYSTEM|FORMAT_MESSAGE_MAX_WIDTH_MASK,
                NULL,
                errorValue,
                MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), // Default language
                (LPTSTR) &lpMsgBuf,
                0,
                NULL 
        );

        //String message;
        char *message;
        if (lpMsgBuf)
        {
                message = (char *)lpMsgBuf;

                // Free the buffer.
                LocalFree( lpMsgBuf );
        }
        else
        {
                message = "No error message returned";
        }

        return message;
}

#else
// nop functions for non-Win32 systems
void Msg(const char *msg, const char *title) {}
char *GetErrorStringMS(unsigned long errorValue) { return ""; }
#endif