DebugOutput.hpp

Go to the documentation of this file.

#ifndef moab_DEBUG_OUTPUT_HPP
#define moab_DEBUG_OUTPUT_HPP

#include <stdarg.h>
#include <stdio.h>
#include <vector>
#include <iosfwd>
#include <string>

#include "moab/Compiler.hpp"

namespace moab {

class Range;
class DebugOutputStream;

class DebugOutput {
  
public:

  DebugOutput( DebugOutputStream* str, unsigned verbosity = 0 );
  DebugOutput( DebugOutputStream* str, int rank, unsigned verbosity = 0 );
  DebugOutput( FILE* str, unsigned verbosity = 0 );
  DebugOutput( FILE* str, int rank, unsigned verbosity = 0 );
  DebugOutput( std::ostream& str, unsigned verbosity = 0 );
  DebugOutput( std::ostream& str, int rank, unsigned verbosity = 0 );

  DebugOutput( const char* pfx, DebugOutputStream* str, unsigned verbosity = 0 );
  DebugOutput( const char* pfx, DebugOutputStream* str, int rank, unsigned verbosity = 0 );
  DebugOutput( const char* pfx, FILE* str, unsigned verbosity = 0 );
  DebugOutput( const char* pfx, FILE* str, int rank, unsigned verbosity = 0 );
  DebugOutput( const char* pfx, std::ostream& str, unsigned verbosity = 0 );
  DebugOutput( const char* pfx, std::ostream& str, int rank, unsigned verbosity = 0 );

  DebugOutput( const DebugOutput& copy );
  DebugOutput& operator=( const DebugOutput& copy );

  ~DebugOutput();
  
  bool have_rank() const    { return mpiRank >= 0; }
  int get_rank() const      { return mpiRank; }
  void set_rank( int rank ) { mpiRank  = rank; }
  void use_world_rank();
  
  void limit_output_to_first_N_procs( int N )
    { if (mpiRank >= N) verbosityLimit = 0; }
  
  unsigned get_verbosity() const      { return verbosityLimit; }
  void set_verbosity( unsigned val )   { verbosityLimit = val; }

  const std::string& get_prefix() const  { return linePfx; }
  void set_prefix(const std::string& str) { linePfx = str; }

  void print( int verbosity, const char* str ) 
    { if (check(verbosity)) print_real(str); }
  
  void print( int verbosity, const std::string& str )
    { if (check(verbosity)) print_real(str); }
    
  inline void printf( int verbosity, const char* fmt, ... ) MB_PRINTF(2);

  void tprint( int verbosity, const char* str ) 
    { if (check(verbosity)) tprint_real(str); }
  
  void tprint( int verbosity, const std::string& str )
    { if (check(verbosity)) tprint_real(str); }
    
  inline void tprintf( int verbosity, const char* fmt, ... ) MB_PRINTF(2);

   
  void print( int verbosity, const char* pfx, const Range& range )
    { if (check(verbosity)) list_range_real( pfx, range ); }
  void print( int verbosity, const Range& range )
    { if (check(verbosity)) list_range_real( 0, range ); }
   
  void print_ints( int verbosity, const char* pfx, const Range& range )
    { if (check(verbosity)) list_ints_real( pfx, range ); }
  void print_ints( int verbosity, const Range& range )
    { if (check(verbosity)) list_ints_real( 0, range ); }

private:
  
  std::string linePfx;
  DebugOutputStream *outputImpl;
  int mpiRank;
  unsigned verbosityLimit;
  double initTime;

  void tprint();

  void list_range_real( const char* pfx, const Range& range );
  void list_ints_real( const char* pfx, const Range& range );
  void print_real( const char* buffer );
  void print_real( const std::string& str );
  void tprint_real( const char* buffer );
  void tprint_real( const std::string& str );
  
  // Function must be passed to copies of the same va_list because
  // a) it might have to call vs(n)printf twice, b) vs(n)printf modifies
  // the va_list such that it cannot be reused, and c) va_copy is not
  // (yet) portable (c99, no c++ standard).
  void print_real( const char* buffer, va_list args1, va_list args2 );
  void tprint_real( const char* buffer, va_list args1, va_list args2 );
  void process_line_buffer();
  
  std::vector<char> lineBuffer;
  
  inline bool check(unsigned verbosity) 
    { return verbosity <= verbosityLimit; }
};


class DebugOutputStream {
protected:
  friend class DebugOutput;
  int referenceCount;
public:
  DebugOutputStream() : referenceCount(1) {}
  virtual ~DebugOutputStream();
  virtual void println( const char* pfx, const char* str ) = 0;
  virtual void println( int rank, const char* pfx, const char* str ) = 0;
};
  
void DebugOutput::printf( int verbosity, const char* fmt, ... )
{
  if (check(verbosity)) {
    va_list args1, args2;
    va_start(args1, fmt);
    va_start(args2, fmt);
    print_real(fmt, args1, args2);
    va_end(args2);
    va_end(args1);
  }
}

void DebugOutput::tprintf( int verbosity, const char* fmt, ... )
{
  if (check(verbosity)) {
    va_list args1, args2;
    va_start(args1, fmt);
    va_start(args2, fmt);
    tprint_real(fmt, args1, args2);
    va_end(args2);
    va_end(args1);
  }
}

} // namespace moab

#endif