ErrorOutput.cpp

Go to the documentation of this file.

#include "ErrorOutput.hpp"
#include "moab/MOABConfig.h"
 
#include <iostream>
#include <cstring>
#include <algorithm>
#include <cassert>
 
#ifdef MOAB_HAVE_MPI
#include "moab_mpi.h"
#endif
 
namespace moab
{
 
class FILEErrorStream : public ErrorOutputStream
{
  private:
    FILE* filePtr;
 
  public:
    FILEErrorStream( FILE* filep ) : filePtr( filep ) {}
    void println( int rank, const char* str );
    void println( const char* str );
};
 
void FILEErrorStream::println( int rank, const char* str )
{
    fprintf( filePtr, "[%d]MOAB ERROR: %s\n", rank, str );
    fflush( filePtr );
}
 
void FILEErrorStream::println( const char* str )
{
    fprintf( filePtr, "MOAB ERROR: %s\n", str );
    fflush( filePtr );
}
 
class CxxErrorStream : public ErrorOutputStream
{
  private:
    std::ostream& outStr;
 
  public:
    CxxErrorStream( std::ostream& str ) : outStr( str ) {}
    void println( int rank, const char* str );
    void println( const char* str );
};
 
void CxxErrorStream::println( int rank, const char* str )
{
    outStr << "[" << rank << "]MOAB ERROR: " << str << std::endl;
    outStr.flush();
}
 
void CxxErrorStream::println( const char* str )
{
    outStr << "MOAB ERROR: " << str << std::endl;
    outStr.flush();
}
 
ErrorOutput::ErrorOutput( FILE* impl ) : outputImpl( new FILEErrorStream( impl ) ), mpiRank( -1 )
{
    lineBuffer.reserve( 1024 );
}
 
ErrorOutput::ErrorOutput( std::ostream& str ) : outputImpl( new CxxErrorStream( str ) ), mpiRank( -1 )
{
    lineBuffer.reserve( 1024 );
}
 
ErrorOutput::~ErrorOutput()
{
    if( !lineBuffer.empty() )
    {
        lineBuffer.push_back( '\n' );
        process_line_buffer();
    }
 
    if( NULL != outputImpl )
    {
        delete outputImpl;
        outputImpl = NULL;
    }
}
 
void ErrorOutput::use_world_rank()
{
#ifdef MOAB_HAVE_MPI
    int flag1;
    MPI_Initialized( &flag1 );
    int flag2;
    MPI_Finalized( &flag2 );
    if( flag1 && !flag2 ) MPI_Comm_rank( MPI_COMM_WORLD, &mpiRank );
#endif
}
 
void ErrorOutput::print_real( const char* buffer )
{
    lineBuffer.insert( lineBuffer.end(), buffer, buffer + strlen( buffer ) );
    process_line_buffer();
}
 
void ErrorOutput::print_real( const std::string& str )
{
    lineBuffer.insert( lineBuffer.end(), str.begin(), str.end() );
    process_line_buffer();
}
 
void ErrorOutput::print_real( const char* fmt, va_list args1, va_list args2 )
{
    size_t idx = lineBuffer.size();
    // try once with remaining space in buffer
    lineBuffer.resize( lineBuffer.capacity() );
    unsigned size = vsnprintf( &lineBuffer[idx], lineBuffer.size() - idx, fmt, args1 );
    ++size;  // trailing null
    // if necessary, increase buffer size and retry
    if( size > ( lineBuffer.size() - idx ) )
    {
        lineBuffer.resize( idx + size );
        size = vsnprintf( &lineBuffer[idx], lineBuffer.size() - idx, fmt, args2 );
        ++size;  // trailing null
    }
 
    // less one because we don't want the trailing '\0'
    lineBuffer.resize( idx + size - 1 );
    process_line_buffer();
}
 
void ErrorOutput::process_line_buffer()
{
    size_t last_idx = 0;
    std::vector< char >::iterator i;
    for( i = std::find( lineBuffer.begin(), lineBuffer.end(), '\n' ); i != lineBuffer.end();
         i = std::find( i, lineBuffer.end(), '\n' ) )
    {
        *i = '\0';
        if( have_rank() )
            outputImpl->println( get_rank(), &lineBuffer[last_idx] );
        else
            outputImpl->println( &lineBuffer[last_idx] );
        ++i;
        last_idx = i - lineBuffer.begin();
    }
 
    if( last_idx )
    {
        i = std::copy( lineBuffer.begin() + last_idx, lineBuffer.end(), lineBuffer.begin() );
        lineBuffer.erase( i, lineBuffer.end() );
    }
}
 
}  // namespace moab