TestStreamImpl.h

Go to the documentation of this file.

////////////////////////////////////////////////////////////////////////////////
///
/// \file
/// \author Gerald Fahrnholz
/// 
/// \brief
/// Implementation of class TestStream
///
/// All member functions behave analogous to the member functions
/// of class ios. Therefore a description of each routine can be
//  omitted. 
/// 
////////////////////////////////////////////////////////////////////////////////


/************************* include **************************************/

//#include "stdafx.h"
#include "TestStream.h"

///\cond do not document

namespace TestToolBox
{

/************************* macro ****************************************/


/************************************************************************/
//
//      This macro is used as generic implementation of the
//      overloaded TStream::operator <<.
//
//      input:  TYP         any type which is accepted 
//                          by ostream::operator <<.
// 
//      ouput:  Implementation of a TestStream::operator << 
//              that accepts a formal parameter of type TYP.
//
/************************************************************************/

#define TESTSTREAM_OUTPUT_OPERATOR(TYP)                                  \
TTB_INLINE TestStream& TestStream::operator << (TYP in_item)                 \
{                                                                        \
    if (Selected (M_STDOUT))                                             \
        std::cout    << in_item;                                         \
    if (Selected (M_OUTFILE))                                            \
        *m_pOutFile << in_item;                                          \
    if (Selected (M_RPTFILE))                                            \
        *m_pRptFile << in_item;                                          \
    return  *this;                                                       \
}


/************************************************************************/
//
//      This macro is used as generic implementation of the
//      overloaded function TStream::write.
//
//      input:  CHAR_POINTER_TYPE  any kind of char pointer.
// 
//      ouput:  Implementation of TestStream::write.
//
/************************************************************************/

#define TESTSTREAM_WRITE( CHAR_POINTER_TYPE )                            \
TTB_INLINE TestStream& TestStream::write                                     \
    (CHAR_POINTER_TYPE in_pCh,  int in_count)                            \
{                                                                        \
    if (Selected (M_STDOUT))                                             \
        std::cout.write   ((char*)in_pCh, in_count);                     \
    if (Selected (M_OUTFILE))                                            \
        m_pOutFile->write((char*)in_pCh, in_count);                      \
    if (Selected (M_RPTFILE))                                            \
        m_pRptFile->write((char*)in_pCh, in_count);                      \
    return *this;                                                        \
}


/************************* modul code ***********************************/


/************************************************************************/
/************************************************************************/


/************************************************************************/
//                SPECIAL CASE WIN-DLL
/************************************************************************/

// If the class TestStream is used within a DLL the standard input and
// output streams cin, cout, cerr are replaced by dummy streams producing
// no output.

#ifdef _WINDLL

// Define the standard objects cin, cout, cerr
NullStream cin;
NullStream cout;
NullStream cerr;

#endif // ifdef _WINDLL


//************************************************************************
//  M E M B E R   F U N C T I O N   I M P L E M E N T A T I O N
//************************************************************************


TTB_INLINE TestStream::TestStream(
    std::fstream* in_pOutFile,
    std::fstream* in_pRptFile):
        m_pOutFile       (in_pOutFile),
        m_pRptFile       (in_pRptFile),
        m_mode           (0),
        m_baseMode       (M_STDOUT),
        m_allowedStreams (M_STDOUT | M_OUTFILE | M_RPTFILE)
{
    if (m_pOutFile)
    {
        m_baseMode |= M_OUTFILE;
    }

    if (m_pRptFile)
    {
        m_baseMode |= M_RPTFILE;
    }

    // Initially output is dericted to all available devices
    ResetMode();

} // TestStream::TestStream


//************************************************************************
//************************************************************************


TTB_INLINE int TestStream::width(int in_newWidth)
{
    int retVal = 0;
    
    if (Selected (M_STDOUT))
        retVal = std::cout.width(in_newWidth);
                        
    if (Selected (M_OUTFILE))
        retVal = m_pOutFile->width(in_newWidth);
        
    if (Selected (M_RPTFILE))
        retVal = m_pRptFile->width(in_newWidth);
        
    return retVal;

} // TestStream::width (int)


//************************************************************************
//************************************************************************


TTB_INLINE int TestStream::width(void) const
{
    int retVal = 0;
    
    if (Selected (M_STDOUT))
        retVal = std::cout.width();
                        
    if (Selected (M_OUTFILE))
        retVal = m_pOutFile->width();
        
    if (Selected (M_RPTFILE))
        retVal = m_pRptFile->width();
        
    return retVal; 

} // TestStream::width (void)


//************************************************************************
//************************************************************************


TTB_INLINE long TestStream::setf (long in_flags)
{
    long retVal = 0;
    
    if (Selected (M_STDOUT))
        retVal = std::cout.setf(in_flags);
                        
    if (Selected (M_OUTFILE))
        retVal = m_pOutFile->setf(in_flags);
        
    if (Selected (M_RPTFILE))
        retVal = m_pRptFile->setf(in_flags);
        
    return retVal; 

} // TestStream::setf (long)


//************************************************************************
//************************************************************************


TTB_INLINE long TestStream::setf (long in_flags, long in_mask)
{
    long retVal = 0;
    
    if (Selected (M_STDOUT))
        retVal = std::cout.setf(in_flags, in_mask);
                        
    if (Selected (M_OUTFILE))
        retVal = m_pOutFile->setf(in_flags, in_mask);
        
    if (Selected (M_RPTFILE))
        retVal = m_pRptFile->setf(in_flags, in_mask);
        
    return retVal;

} // TestStream::setf (long, long)


//************************************************************************
//************************************************************************


TTB_INLINE long TestStream::unsetf (long in_flags)                    
{
    long retVal = 0;
    
    if (Selected (M_STDOUT))
        std::cout.unsetf(in_flags);
                        
    if (Selected (M_OUTFILE))
        m_pOutFile->unsetf(in_flags);

    if (Selected (M_RPTFILE))
        m_pRptFile->unsetf(in_flags);

    return retVal;

} // TestStream::unsetf


//************************************************************************
// Implemementation of TStream::operator <<
//************************************************************************


TTB_INLINE TestStream& TestStream::operator << (std::string in_str)
{
    if (Selected (M_STDOUT))
        std::cout    << in_str.c_str();
    if (Selected (M_OUTFILE))
        *m_pOutFile << in_str.c_str();
    if (Selected (M_RPTFILE))
        *m_pRptFile << in_str.c_str();
    return  *this;
}


TESTSTREAM_OUTPUT_OPERATOR( unsigned char* )
TESTSTREAM_OUTPUT_OPERATOR( const char*    )
TESTSTREAM_OUTPUT_OPERATOR( char           )
TESTSTREAM_OUTPUT_OPERATOR( unsigned char  )
TESTSTREAM_OUTPUT_OPERATOR( short          )
TESTSTREAM_OUTPUT_OPERATOR( unsigned short )
TESTSTREAM_OUTPUT_OPERATOR( int            )
TESTSTREAM_OUTPUT_OPERATOR( unsigned int   )
TESTSTREAM_OUTPUT_OPERATOR( long           )
TESTSTREAM_OUTPUT_OPERATOR( unsigned long  )
TESTSTREAM_OUTPUT_OPERATOR( float          )
TESTSTREAM_OUTPUT_OPERATOR( double         )
TESTSTREAM_OUTPUT_OPERATOR( long double    )


/************************************************************************/
/************************************************************************/


TTB_INLINE TestStream& TestStream::operator << ( std::ostream& (*f)(std::ostream&) )
{

#ifndef _WINDLL
    if (Selected (M_STDOUT))
        f(std::cout);
#endif
                        
    if (Selected (M_OUTFILE))
        f(*m_pOutFile);

    if (Selected (M_RPTFILE))
        f(*m_pRptFile);

    return *this;
}


/******************************************************************************/
/******************************************************************************/


TTB_INLINE TestStream& TestStream::operator << ( std::ios& (*f)(std::ios&) )
{

#ifndef _WINDLL
    if (Selected (M_STDOUT))
        f(std::cout);
#endif
                        
    if (Selected (M_OUTFILE))
        f(*m_pOutFile);

    if (Selected (M_RPTFILE))
        f(*m_pRptFile);

    return *this;
}


/************************************************************************/
/************************************************************************/

// Implemementation of TStream::write()

TESTSTREAM_WRITE( const unsigned char* )
TESTSTREAM_WRITE( const signed   char* )


/************************************************************************/
/************************************************************************/


}; // namespace TestUtil

///\endcond

// end of file TestStream.cpp

---