CommonIO.h

Go to the documentation of this file.

/*  _________________________________________________________________________
 *
 *  UTILIB: A utility library for developing portable C++ codes.
 *  Copyright (c) 2001, Sandia National Laboratories.
 *  This software is distributed under the GNU Lesser General Public License.
 *  For more information, see the README file in the top UTILIB directory.
 *  _________________________________________________________________________
 */

#ifndef __CommonIO_h
#define __CommonIO_h

#ifdef __GNUC__
#pragma interface
#endif

#define USING_COMMONIO
#ifdef USING_COMMONIO

#ifdef  NON_ANSI
#include <iostream.h>
#include <fstream.h>
#include <iomanip.h>
#else
#include <iostream>
#include <fstream>
#include <iomanip>
using namespace std;
#endif
#include "_generic.h"

#ifdef _MSC_VER
#include <strstrea.h>
#else
#ifdef NON_ANSI
#include <strstream.h>
#else
#include <strstream>
#endif // NON_ANSI
#endif // _MSC_VER
#include "utilib_dll.h"


extern "C" {
void cout_print(const char* str);
void cerr_print(const char* str);
};

#define DEBUG_COMMONIO

#ifndef SWIG

//
// Macros for overriding the C++ streams
//
class CommonIO;
extern CommonIO global_CommonIO;
#define ucout    (**CommonIO::MapCout)

#define ucerr    (**CommonIO::MapCerr)

#define ucin    (**CommonIO::MapCin)

#define stdcout (*CommonIO::std_cout)

#define stdcerr (*CommonIO::std_cerr)

#define stdcin  (*CommonIO::std_cin)


//
// Used for syncronizing output on MIMD machines
//
UTILIB_API void clear_print_marker_queue();
UTILIB_API void set_sync_print(const int flag);
UTILIB_API void get_print_marker();
UTILIB_API void return_print_marker();


#ifdef  DEBUGGING
  #ifdef DEBUGPR
  #undef DEBUGPR
  #endif

  #define DEBUGPR(dlevel,cmd)  if (verbosity(dlevel)) {cmd; CommonIO::flush();}

  #define DEBUGPRP(dlevel,cmd) if (verbosity(dlevel)) { cmd; }

  #define DEBUGPRX(dlevel,ptr,stuff) \
     if (ptr->verbosity(dlevel)) { ucout << stuff; CommonIO::flush(); }

  #define DEBUGPRXP(dlevel,ptr,stuff) \
     if (ptr->verbosity(dlevel)) { ucout << stuff; }

  #define REFER_DEBUG(pointer) \
    virtual int verbosity(int level) { return pointer->verbosity(level); };
#else
  #define DEBUGPR(dlevel,cmd)          /* Nothing */
  #define DEBUGPRP(dlevel,cmd)         /* Nothing */
  #define DEBUGPRX(ptr,dlevel,stuff)   /* Nothing */
  #define DEBUGPRXP(ptr,dlevel,stuff)  /* Nothing */
  #define REFER_DEBUG(pointer)         /* Nothing */
#endif

#endif // SWIG


#ifndef SWIG
class UTILIB_API CommonIO {
#else
class CommonIO {
#endif

  friend void cppMessage_abort();
  friend UTILIB_API ostream& Flush(ostream& outstr);

public:

  CommonIO();
  virtual ~CommonIO();
  static void begin();
  static void begin_buffered();
  static void end();

  static void map_off()
                {flush(); io_mapping = OFF; reset_map();}
  static void map_on()
                { io_mapping = ON; reset_map();}

  static void reset();

  int debug;
  static int numDigits;

  virtual int  verbosity(const int level)
                {
                if ((IO_Rank != -1) && (IO_Rank != Rank))
                   return 0;
                else
                   return (debug >= level);
                }

  void  setDebug(int level)             { debug = level; }
  static void  setIORank(int Rank_)     { IO_Rank = Rank_; }
  static void  setIOFlush(int flush_)   { flush_flag = flush_; };

  static int rank()     { return Rank; };
  static int io_rank()     { return IO_Rank; };
  static int numProcs() { return Size; };

  static ostream& outs()
                {return o_stream(0);}
  static ostream& errs()
                {return o_stream(1);}
  static istream& ins()
                {return (*common_cin);}
  static void set_streams(ostream* cout_, ostream* cerr_, istream* cin_)
                {
                if (cout_) common_cout = cout_; 
                if (cerr_) common_cerr = cerr_; 
                if (cin_) common_cin = cin_;
                }
  static void set_cout(ostream* cout_)
                { if (cout_) common_cout = cout_; }
  static void set_cerr(ostream* cerr_)
                { if (cerr_) common_cerr = cerr_; }
  static void set_cin(istream* cin_)
                { if (cin_) common_cin = cin_; }
  static void set_ofile(const char* ofile);

  static void begin_tagging()
                {IOflush(); tagging=ON;}
  static void begin_tagging(const int numDigits_)
                {IOflush(); numDigits = numDigits_; tagging=ON;}
  static void end_tagging()
                {IOflush(); tagging=OFF;}
  static void flush()
                {IOflush(); common_cout->flush(); common_cerr->flush();}

  static void sync_stdio()
                {
#ifndef COUGAR
                ios::sync_with_stdio();
#endif
                }

  static ostream* std_cout;
  static ostream* std_cerr;
  static istream* std_cin;

  static ostream** MapCout;
  static ostream** MapCerr;
  static istream** MapCin;

protected:
  static void end_all();

private:

  static int io_mapping;
  static int io_buffering;
  static int begin_end_counter;

  static int IO_Rank;
  static int tagging;
  static int nref;
  static int flush_flag;
  static int seqNum;

  static int Rank;
  static int Size;

  static ostream& o_stream(const int flag);
  static int stream_flag;
  static int header_flag;
  static void IOflush();
  static void flush_stream(strstream& stream, ostream* tmp);
#ifdef SGI
  static std::ofstream* common_ofstr;
#else
  static ofstream* common_ofstr;
#endif

  static void reset_map();
  static ostream* common_cout;
  static ostream* common_cerr;
  static istream* common_cin;

  static strstream* pStrCout;
  static strstream* pStrCerr;
};



#ifndef SWIG

inline UTILIB_API ostream& Flush(ostream& outstr)
{
CommonIO::flush();
if ((&outstr != CommonIO::pStrCout) && (&outstr != CommonIO::pStrCerr))
   outstr.flush();
return outstr;
}
#endif


#else   // COMMONIO

#define ucout cout
#define ucerr cerr
#define ucin  cin
#define Flush flush

class CommonIO
{
public:

  CommonIO() {debug=0;}
  int debug;
};
#endif // COMMONIO

#endif