TestStream.h

Go to the documentation of this file.

////////////////////////////////////////////////////////////////////////////////
///
/// \file
/// \author Gerald Fahrnholz
/// 
/// \defgroup GrpTestStream Using TestStream
/// @{
/// \ingroup GrpTestUtils 
/// \brief
/// Class TestStream allows directing of textual output to multiple devices
///
/// \sa TestStream.h (File documentation)
/// \sa TestToolBox::TestStream (class documentation)
/// 
////////////////////////////////////////////////////////////////////////////////

#pragma once

#pragma warning(push)
#pragma warning( disable : 4610)
#pragma warning( disable : 4512)


namespace TestToolBox
{

/**************************** definitions *******************************/


// typedef unsigned char byte;

// The following values can be used to select output devices.
const unsigned char M_NULL    = 0x00;  // no output
const unsigned char M_STDOUT  = 0x01;  // output to standard out
const unsigned char M_OUTFILE = 0x02;  // output to protocol file
const unsigned char M_RPTFILE = 0x04;  // output to report file
const unsigned char M_ALL = M_STDOUT | M_OUTFILE | M_RPTFILE;

/************************* typedef **************************************/


/// \brief This class allows directing of textual output to multiple devices
///
/// Definition of the class TestStream which performs handling of
/// test output.
/// With this class it is possible to direct test output to
/// standard out, to protocol and report file.
/// With calling member function setMode any of the output
/// devices can be switched on or off.
///
/// \nosubgrouping 
/// \sa TestStream.h (File documentation)
/// \sa GrpTestStream (Usage documentation)
class TestStream {

    public:

        /// Constructs an object of class TestStream.
        /// The given parameters point to the streams to be used for
        /// output. A null pointer means that this device is not available.
        TestStream(
            std::fstream* in_pOutFile = 0,  // out file (protocol file)
            std::fstream* in_pRptFile = 0); // rpt file (test report)

        /// Selects streams for output.
        /// Possible values for mode are M_NULL, M_STDOUT, M_OUTFILE,
        /// M_RPTFILE.
        /// To select more than one device use | operator.
        void SetMode (unsigned char in_newMode);

        /// Reset mode to default (i.e. all available output devices are
        /// selected).
        void ResetMode (void);

        /// Get current output mode
        unsigned char GetMode (void);

        /// Completely activate the streams via bit mask
        /// Streams not contained within bitmask will be switched off completely
        void SetStreamActivation (
            unsigned char in_streamsToActivate);
        /// Get current sream activation status
        unsigned char GetStreamActivation (void);

        /// Returns field width in characters. See ios::width() (C++ standard).
        int width(int in_newWidth);                          
        int width(void) const;

        /// Set TStream format flags. See ios::setf()
        long setf   (long in_flags);
        long setf   (long in_flags, long in_mask);
        long unsetf (long in_flags);

        /// Insert arguments in TestStream. The output operator << is
        /// defined and overloaded similar to ostream.
        TestStream& TestStream::operator << (std::string      in_item);
        TestStream& TestStream::operator << (unsigned char*   in_item);
        TestStream& TestStream::operator << (const char*      in_item);
        TestStream& TestStream::operator << (char             in_item);
        TestStream& TestStream::operator << (unsigned char    in_item);
        TestStream& TestStream::operator << (short            in_item);
        TestStream& TestStream::operator << (unsigned short   in_item);
        TestStream& TestStream::operator << (int              in_item);
        TestStream& TestStream::operator << (unsigned int     in_item);
        TestStream& TestStream::operator << (long             in_item);
        TestStream& TestStream::operator << (unsigned long    in_item);
        TestStream& TestStream::operator << (float            in_item);
        TestStream& TestStream::operator << (double           in_item);
        TestStream& TestStream::operator << (long double      in_item);
        
        /// The overloaded operator << accepts ostream (ios)
        /// manipulators.
        TestStream& operator << ( std::ostream& (*f) (std::ostream&) );
        TestStream& operator << ( std::ios&     (*f) (std::ios&) );

        /// Write the contents of a buffer like ostream::write()
        /// The only difference is that the output is directed to
        /// several devices according to mode value.
        TestStream& write  (const signed char*   in_pCh,  int in_count);
        TestStream& write  (const unsigned char* in_pCh,  int in_count);
        TestStream& write  (const char*          in_pCh,  int in_count)
                {return write ((const signed char*) in_pCh, in_count);}

    private:
///\cond do not document

        // Pointer to output stream to test protocol
        std::fstream* m_pOutFile;

        // Pointer to output stream to test report
        std::fstream* m_pRptFile;

        // Current mode defining the output devices.
        unsigned char m_mode;

        // Base mode.
        // Set according to availability of output devices.
        unsigned char m_baseMode;

        // allowed streams
        unsigned char m_allowedStreams;

    private:

        // Checks if the given output device is selected for output.
        bool Selected (
            unsigned char in_mode) const; 
///\endcond

};  // class TestStream



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

///\cond

inline void TestStream::SetMode (
    unsigned char in_newMode)
    {m_mode = in_newMode;};

inline void TestStream::ResetMode (void)
    {m_mode = m_baseMode;};

inline void TestStream::SetStreamActivation (
    unsigned char in_allowedStreams)
{m_allowedStreams = in_allowedStreams;}

inline unsigned char TestStream::GetStreamActivation (void)
{return m_allowedStreams;}

inline unsigned char TestStream::GetMode (void)
    {return m_mode;};

inline bool TestStream::Selected (
    unsigned char in_mode) const
    {return (m_allowedStreams & m_baseMode & m_mode & in_mode) != 0;};
///\endcond


/******************************************************************************/
/******************************************************************************/
//                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


class NullStream : public iostream
{
    public:
        void setMode (byte /*in_newMode*/) {/* do nothing */};
        int width(int /*in_newWidth*/){return 0;};                          
        int width(void) const {return 0;};
        long setf   (long /*in_flags*/){return 0;};
        long setf   (long /*in_flags*/, long /*in_mask*/){return 0;};
        long unsetf (long /*in_flags*/){return 0;};
        NullStream& NullStream::operator << (char*            /*in_item*/)
            { return  *this;};
        NullStream& NullStream::operator << (unsigned char*   /*in_item*/)
            { return  *this;};
        NullStream& NullStream::operator << (const char*      /*in_item*/)
            { return  *this;};
        NullStream& NullStream::operator << (char             /*in_item*/)
            { return  *this;};
        NullStream& NullStream::operator << (unsigned char    /*in_item*/)
            { return  *this;};
        NullStream& NullStream::operator << (short            /*in_item*/)
            { return  *this;};
        NullStream& NullStream::operator << (unsigned short   /*in_item*/)
            { return  *this;};
        NullStream& NullStream::operator << (int              /*in_item*/)
            { return  *this;};
        NullStream& NullStream::operator << (unsigned int     /*in_item*/)
            { return  *this;};
        NullStream& NullStream::operator << (long             /*in_item*/)
            { return  *this;};
        NullStream& NullStream::operator << (unsigned long    /*in_item*/)
            { return  *this;};
        NullStream& NullStream::operator << (float            /*in_item*/)
            { return  *this;};
        NullStream& NullStream::operator << (double           /*in_item*/)
            { return  *this;};
        NullStream& NullStream::operator << (long double      /*in_item*/)
            { return  *this;};
        NullStream& operator << ( ostream& (* /*f*/) (ostream&) )
            { return  *this;};
        NullStream& operator << ( ios&     (* /*f*/) (ios&) )
            { return  *this;};
        NullStream& write  (const char*          /*in_pCh*/,  int /*in_count*/)
            { return  *this;};
        NullStream& write  (const unsigned char* /*in_pCh*/,  int /*in_count*/)
            { return  *this;};
        NullStream& write  (const signed char*   /*in_pCh*/,  int /*in_count*/)
            { return  *this;};

}; // end of class TestStream

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

#endif // ifdef _WINDLL


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



}; // namespace TestToolBox


#pragma warning(pop)

///@} // GrpTestStream

---