vlPrint.h

Go to the documentation of this file.

/*******************************************************************************
** Copyright (c) 1992-2010 VT MAK
** All rights reserved.
*******************************************************************************/
#pragma once

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


#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) =0;

};

class DT_DLL_VLUTIL DtFilePrinter : public DtPrinter
{
public:
   DtFilePrinter(const char* filename);

   DtFilePrinter();

   virtual ~DtFilePrinter();

   virtual void resetFile(const char* filename);

   virtual bool isOpen();

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

protected:
   DtFilePrinter(const DtFilePrinter& orig);
   DtFilePrinter& operator=(const DtFilePrinter& orig);

protected:
  DtMutex myFileLock;
#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 );
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 );
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 );

protected:

   HANDLE myConsoleHandle;
   DtMutex myLock;
   
};
#endif

class DtOutputStream;

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

public:

   DtOutputStreamBuffer();
   virtual ~DtOutputStreamBuffer();

private:

   DtOutputStreamBuffer(const DtOutputStreamBuffer&);
   DtOutputStreamBuffer & operator=(const DtOutputStreamBuffer &);

public:

   virtual void setOutputStream( DtOutputStream *stream );

protected:

   virtual int_type  overflow( int_type c );
   virtual int sync();
   
   std::string        myBuffer;
   DtMutex            myBufferMutex;
   DtOutputStream    *myOutputStream;

};

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

public:

   //Constructor takes a pointer to a variable to use to check against a
   //global threshold. Each DtOutputStreamBuffer needs to also have a 
   //unique DtOutputStreamBuffer which should be created before 
   //the DtOutputStream that uses it is created.
   DtOutputStream(DtOutputStreamBuffer *b,
                  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 );

   virtual void setThreshold( int level );
   virtual int  threshold() const;


#ifdef _WIN32
   bool okToPrint() const;
#else
   virtual bool okToPrint() const;
#endif

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


protected:

   typedef std::vector<DtPrinter*> PrinterPtrVec;

protected:

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

   int                        &myGlobalThresholdReference;

private:
   DtOutputStream(const DtOutputStream &);

   DtOutputStream & operator=(const DtOutputStream &);

};


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 _WIN32
inline bool DtOutputStream::okToPrint() const
{
   return (threshold() <= myGlobalThresholdReference);
}
#endif

#ifdef DtUSE_UTILITIES_NAMESPACE
}     
#endif