vlPrint.h

Go to the documentation of this file.

/****************************************************************************
 * Copyright (c) 2015 VT MAK
 * All rights reserved.
 ****************************************************************************/


#pragma once

#include <vlutil/vlMachineTypes.h>
#include <vlutil/vlMutex.h>
#include <iostream>
#include <fstream>
#include <vector>
#include <ios>

#ifdef _WIN32
#include <winsock2.h>
#endif


#ifdef DtUSE_UTILITIES_NAMESPACE
namespace DtUSE_UTILITIES_NAMESPACE
{
#endif


extern DT_DLL_VLUTIL int DtNotifyLevel;  


enum DtNotifyLevelType
{
   DtNlFatal     = 0,
   DtNlWarn      = 1,
   DtNlInfo      = 2,
   DtNlVerbose   = 3,
   DtNlDebug     = 4
};


class DT_DLL_VLUTIL DtPrinter
{
public:

   inline DtPrinter();

   inline DtPrinter( const DtPrinter& );

   virtual inline ~DtPrinter();

   virtual void write( const std::string& str, int notify_level, bool newLine ) = 0;

};


class DT_DLL_VLUTIL DtFilePrinter : public DtPrinter
{
public:

   DtFilePrinter();

   DtFilePrinter( const char* filename );

   virtual ~DtFilePrinter();

   virtual void setPrintTimestamps( bool doit );

   virtual void setLogRollingInterval( unsigned int intervalInSeconds );

   virtual void resetFile( const char* filename );

   virtual bool isOpen();

   virtual void write( const std::string& st, int notify_level, bool newLine );

protected:

   virtual void cacheFilename( const std::string& filename );

private:

   DtFilePrinter( const DtFilePrinter& orig );

   DtFilePrinter& operator = ( const DtFilePrinter& orig );

protected:

   DtMutex myFileLock;

   bool myTimestampFlag;

   time_t myLogFileOpenTime;
   unsigned int myLogRollingIndex;
   unsigned int myLogRollingInterval;

   std::string myFilename;
   std::string myFileBase;
   std::string myFileExt;

#ifndef __sgi__
   std::ofstream myFile;
#else
   std::fstream myFile;
#endif

};


class DT_DLL_VLUTIL DtStdoutPrinter : public DtPrinter
{
public:

   inline DtStdoutPrinter();

   virtual inline ~DtStdoutPrinter();

   virtual void write( const std::string& st, int notify_level, bool newLine );

protected:

   DtMutex myLock;

};


class DT_DLL_VLUTIL DtStderrPrinter : public DtPrinter
{
public:

   inline DtStderrPrinter();

   virtual inline ~DtStderrPrinter();

   virtual void write( const std::string& st, int notify_level, bool newLine );

protected:

   DtMutex myLock;

};


#ifdef _WIN32

class DT_DLL_VLUTIL DtWindowsConsolePrinter : public DtPrinter
{
public:

   DtWindowsConsolePrinter( bool disableClose = false );

   virtual ~DtWindowsConsolePrinter();

   virtual void write( const std::string& st, int notify_level, bool newLine );

protected:

   HANDLE myConsoleHandle;
   DtMutex myLock;

};

#endif


class DtOutputStream;

class DT_DLL_VLUTIL DtOutputStreamBuffer : public std::basic_streambuf<char>
{
public:

   DtOutputStreamBuffer();

   virtual ~DtOutputStreamBuffer();

   virtual void setOutputStream( DtOutputStream* stream );

protected:

   virtual int sync();
   virtual int_type overflow( int_type c );

private:

   DtOutputStreamBuffer( const DtOutputStreamBuffer& );

   DtOutputStreamBuffer& operator = ( const DtOutputStreamBuffer& );

protected:

   std::string myBuffer;
   DtMutex myBufferMutex;
   DtOutputStream* myOutputStream;

};


class DT_DLL_VLUTIL DtOutputStream : public std::basic_ostream<char>
{
public:

   DtOutputStream( DtOutputStreamBuffer* buffer, int& globalThresholdRef,
      int threshold = 1, DtPrinter* dflt_printer = 0 );

   virtual ~DtOutputStream();

   virtual void attachPrinter( DtPrinter* sink );

   virtual bool detachPrinter( DtPrinter* sink );

   virtual void detachAllPrinters();

   virtual void write( const std::string& str, bool newLine = false );

   virtual void setThreshold( int level );

   virtual int threshold() const;

   virtual bool okToPrint() const;

   virtual void operator () ( const char* s, ... );


private:

   DtOutputStream( const DtOutputStream& );

   DtOutputStream& operator = ( const DtOutputStream& );

protected:

   typedef std::vector<DtPrinter*> PrinterPtrVec;

   DtOutputStreamBuffer* myStreamBuf;
   DtMutex myStreamBufMutex;
   PrinterPtrVec myPrinters;
   DtMutex myPrintersMutex;
   int myThreshold;

   int& myGlobalThresholdReference;

};


extern DT_DLL_VLUTIL DtStdoutPrinter DtStandardOutConsole;

extern DT_DLL_VLUTIL DtStderrPrinter DtStandardErrorConsole;



extern DT_DLL_VLUTIL DtOutputStream DtFatal;
extern DT_DLL_VLUTIL DtOutputStream DtWarn;
extern DT_DLL_VLUTIL DtOutputStream DtInfo;
extern DT_DLL_VLUTIL DtOutputStream DtVerbose;
extern DT_DLL_VLUTIL DtOutputStream DtDebug;



extern DT_DLL_VLUTIL void DtFatalError( const char* str, ... );
extern DT_DLL_VLUTIL void DtFatalPerror( const char* str, ... );
extern DT_DLL_VLUTIL void DtWarnPerror( const char* str, ... );
extern DT_DLL_VLUTIL void DtFatalNetPerror( const char* str, ... );
extern DT_DLL_VLUTIL void DtWarnNetPerror( const char* str, ... );


DT_DLL_VLUTIL void DtSetVrLinkPrinter( DtPrinter* newPrinter );


#ifdef _WIN32


DT_DLL_VLUTIL void setFileOutput( const char* filename, int con = 0, int son = 0 );
DT_DLL_VLUTIL void closeConsole();

#endif


DT_DLL_VLUTIL void DtAbort();

typedef void (*DtAbortFunc)();

DT_DLL_VLUTIL void DtSetAbortFunc( DtAbortFunc func );

DT_DLL_VLUTIL DtAbortFunc DtGetAbortFunc();

#if DT_NO_VSNPRINTF

DT_DLL_VLUTIL int vsnprintf( char*, size_t, const char*, va_list );
#endif

//-------------------------------------------
//Inline Function Definitions
//-----------------------------------------
inline void DtOutputStream::setThreshold( int level )
{
   myThreshold = level;
}

inline int  DtOutputStream::threshold() const
{
   return myThreshold;
}

inline DtPrinter::DtPrinter()
{
}

inline DtPrinter::DtPrinter( const DtPrinter& )
{
}

inline DtPrinter::~DtPrinter()
{
}

inline DtStdoutPrinter::DtStdoutPrinter()
{
}

inline DtStdoutPrinter::~DtStdoutPrinter()
{
}

inline DtStderrPrinter::DtStderrPrinter()
{
}

inline DtStderrPrinter::~DtStderrPrinter()
{
}


#ifdef DtUSE_UTILITIES_NAMESPACE
}     
#endif