---

sglOStream.hpp

/*****************************************************************************
 * SGL: A Scene Graph Library
 *
 * Copyright (C) 1997-2001  Scott McMillan   All Rights Reserved.
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Library General Public
 * License as published by the Free Software Foundation; either
 * version 2 of the License, or (at your option) any later version.
 *
 * This library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Library General Public License for more details.
 *
 * You should have received a copy of the GNU Library General Public
 * License along with this library; if not, write to the Free
 * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
 *****************************************************************************
 *     File: sglOStream.hpp
 *   Author: Tom Stimson
 *  Created: 8 April 2000
 *  Summary: Output stream class with various levels of verbosity.
 *****************************************************************************/

#ifndef __SGL_OSTREAM_HPP
#define __SGL_OSTREAM_HPP

#include <sgl.h>

class sglNullStreamBuf;

//----------------------------------------------------------------------------

class SGL_DLL_API sglOStream
{
public: // Types
   enum PrintLevelEnum
   {
      eALWAYS,   // These messages will always print.
      eWARNING,  // These messages print if threshold => eWARNING.
      eINFO,     // These messages print if threshold => eINFO.
      eDEBUG     // These messages print if threshold = eDEBUG.
   };

   typedef void (*callback)(void);

public: // Static Methods
   static void setStream(ostream* stream);

   static ostream* getStream();

   static void setThreshold(PrintLevelEnum threshold);

   static PrintLevelEnum getThreshold();

   static void setPreFunc(callback func);

   static callback getPreFunc();

   static void setPostFunc(callback func);

   static callback getPostFunc();

#ifdef WIN32

   static string formatWIN32Error(int error_number);
#endif

public: // Instance Methods
   sglOStream(PrintLevelEnum level = eALWAYS)
      : m_print_level(level)
      {
         if (s_pre_func && m_print_level <= s_threshold) (*s_pre_func)();
      }

   virtual ~sglOStream()
      {
         if (s_post_func && m_print_level <= s_threshold) (*s_post_func)();
      }

   ostream& getOStream()
      {
         if (s_stream && m_print_level <= s_threshold)
            return *s_stream;
         else
            return s_null_ostream;
      }

private:
   // Not Implemented.  Do not use.
   sglOStream(const sglOStream &);
   sglOStream& operator=(const sglOStream &);

private:
   static PrintLevelEnum    s_threshold;
   static ostream          *s_stream;
   static callback          s_pre_func;
   static callback          s_post_func;

   static sglNullStreamBuf *s_null_buff;
   static ostream           s_null_ostream;

   PrintLevelEnum           m_print_level;
};


// This is a dummy class designed to allow the optimizer to
// eliminate debug prints.
class SGL_DLL_API sglNullStream
{
public:
   sglNullStream() {};
   ~sglNullStream() {};

   // This is where the voodoo occurs.  The typical print
   // line "sglPrintDebug() << "blah" << endl;" will be expanded
   // to a series of calls to sglNullStream::operator<<(T).
   // These calls don't do anything, so the optimizer should
   // realize that the entire line does nothing (and eliminate it).
   template <class T>
   inline const sglNullStream& operator<<(const T&) const
      {
         return *this;
      }
#ifdef WIN32
   // Windows is stupid.  This is for the endl.
   inline const sglNullStream& operator<<(
      ostream::_Myt& (__cdecl *_F)(ostream::_Myt&)) const
      {
         return *this;
      }
#endif
#if defined(vxw)
   // The compiler that comes with tornado 2 is brain damaged.
   inline const sglNullStream& operator<<(char* rhs) const
      {
         return *this;
      }
#endif
#if (defined(__GNUC__) && (__GNUC__==2) && ((__GNUC_MINOR__<=91) || (__GNUC_MINOR__==96)))
   // Old G++ is stupid.  This is for the endl.
   inline const sglNullStream& operator<<(ostream& (*_F)(ostream&)) const
      {
         return *this;
      }
   // Old G++ is stupid.  This is for the hex, dec, etc...
   inline const sglNullStream& operator<<(ios& (*_F)(ios&)) const
      {
         return *this;
      }
#endif
#if (defined(sgi) && defined(_STANDARD_C_PLUS_PLUS)) || defined(__ghs__)
   inline const sglNullStream& operator<<(ostream& (*_F)(ostream&)) const
      {
         return *this;
      }
#endif

private:  // not implemented
   sglNullStream(const sglNullStream &);
   sglNullStream &operator=(const sglNullStream &);
};


// Initiate a print stream that always prints.
#define sglPrint() (sglOStream(sglOStream::eALWAYS).getOStream())

// Create a global const null stream visible to the optimizer.
const sglNullStream sglNullStreamInst;


// When compiling a debug version, a call to sglPrint??? will return
// a temporary sglOStream.  The constructor will be called at the
// beginning of the stream, and the destructor will mark the end.
// When compiling an optimized version, a call to sglPrint??? will
// return a NullStream that should allow the optimizer to eliminate
// the code.

#ifdef NO_SGL_WARNING_PRINTS
inline const sglNullStream &sglPrintWarning() { return sglNullStreamInst; }
#else
# define sglPrintWarning() (sglOStream(sglOStream::eWARNING).getOStream())
#endif

#ifdef NO_SGL_INFO_PRINTS
inline const sglNullStream &sglPrintInfo() { return sglNullStreamInst; }
#else
# define sglPrintInfo() (sglOStream(sglOStream::eINFO).getOStream())
#endif

#ifdef NO_SGL_DEBUG_PRINTS
inline const sglNullStream &sglPrintDebug() { return sglNullStreamInst; }
#else
# define sglPrintDebug() (sglOStream(sglOStream::eDEBUG).getOStream())
#endif


#endif

---