Protocol.h

Go to the documentation of this file.

////////////////////////////////////////////////////////////////////////////////
///
/// \file
/// \author Gerald Fahrnholz
/// 
/// \defgroup GrpProtocol Using Protocol
/// @{
/// \ingroup GrpTestUtils 
/// \brief
/// Class Protocol represents a simple text protcol used for logging test activities
///
/// \sa Protocol.h (File documentation)
/// \sa TestToolBox::Protocol (class documentation)
/// 
////////////////////////////////////////////////////////////////////////////////

#pragma once

//#include "TestToolBox/CommonSources/ObjectLock.h"
#include "TestToolBox/IProtocol.h"
#include <fstream>

#ifdef USE_TEST_INSTANCE_DLL
#    include "TestToolBox/TestInstanceDll.h"
#endif

namespace TestToolBox
{
struct IProtocol;
class TestStream;


/// \brief This class represents a textual log file
///
/// \nosubgrouping 
/// \sa Protocol.h (File documentation)
/// \sa GrpProtocol (Usage documentation)
class Protocol :
    public AutoCriticalSection,
    public IProtocol
{
private:
///\cond

    /// Constructor
    explicit Protocol(
        unsigned int      in_allowedStreams,
        OutputLevel::Enum in_outputLevel);
///\endcond

public:
///\cond
    std::string const S_SEPARATOR_LINE;

    // Destructor
    ~Protocol();

    // Get the pointer to the only instance of this class
#ifdef USE_TEST_INSTANCE_DLL
    static Protocol* CreateNewInstanceForUsageInDll(void){return new Protocol;};
    static Protocol* Get (void)
    {return TTB_GetInstance_Protocol();}
    static void Cleanup (void)
    {TTB_CleanupInstance_Protocol();}
#else
    static Protocol* Get (
        unsigned int in_allowedStreams = OutputMode::M_STDOUT | OutputMode::M_OUTFILE | OutputMode::M_RPTFILE,
        OutputLevel::Enum in_outputLevel = OutputLevel::eREGULAR)
    {if (!s_pProtocol) s_pProtocol = new Protocol(in_allowedStreams, in_outputLevel);
     return s_pProtocol;}
    static Protocol* s_pProtocol;
    static void Cleanup (void)
    {delete s_pProtocol; s_pProtocol = 0;}
#endif

///\endcond

    //---------------------------------------------------------------
    /// \name Interface IProtocol
    /// \{

        /// \brief Write arbitrary text (with or without newline chars)
        /// to protocol file.
        virtual void Write(
            std::string const & in_text);

        /// \brief Write arbitrary text (preferable without newline chars)
        /// to protocol file.
        virtual void Writeln(
            std::string const & in_text);

        /// \brief Write arbitrary text (with or without newline chars)
        /// to protocol file.
        virtual void Write(
            OutputLevel::Enum   in_outputLevel,
            unsigned char       in_outputMode,
            std::string const & in_text);

        /// \brief Write arbitrary text (preferable without newline chars)
        /// to protocol file.
        virtual void Writeln(
            OutputLevel::Enum in_outputLevel,
            unsigned char       in_outputMode,
            std::string const & in_text);

        /// \brief Write footer info to test protocol.
        virtual void WriteFooter(unsigned char m = TestToolBox::OutputMode::M_ALL);

        /// \brief Select output devices
        void SetMode (
            unsigned char in_newMode);

        /// \brief Redirect output to all existing devices
        void ResetMode (void);

        /// \brief Select output devices
        void SetOutputLevelForStdOut (
            OutputLevel::Enum in_outputLevel);

    /// \}

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

    // Close current logfiles and open new ones
    // This function may be usefuk in context of long time
    // test with repeated execution.
    void SwitchLogfiles (
        std::string const & in_postFixNewFileName,
        std::string const & in_msgClose,
        std::string const & in_msgOpen);

private:

    // Stream to test protocol file
    std::fstream m_outF;

    // Stream to test report file
    std::fstream m_rptF;

    /// Test output stream which can write to several selected streams.
    TestStream* m_pTestStream;

    // Flag indicating whether the footer info has already been written to file
    bool m_footerAlreadyWritten;

        OutputLevel::Enum m_activeOutputLevelForStdOut;

private:

    void WriteHeader(void);

    // Access to TestStream
    TestStream& TS (void);

    // Adjust output mode according to current level of output.
    // The returned level is the previous level which has to be restored
    // after output is finished
    unsigned char AdjustOutputMode(
        OutputLevel::Enum in_outputLevel,
        unsigned char     in_outputMode);

}; // class Protocol

static Protocol* TheProtocol (void)
{return Protocol::Get();}

///\cond do not document
#ifndef USE_TEST_INSTANCE_DLL
__declspec(selectany) Protocol* Protocol::s_pProtocol = 0;
#endif
///\endcond

}; // namespace TestToolBox

/// @} // endGrpProtocol

---