/*

* Copyright (c) 2007-2008 Nokia Corporation and/or its subsidiary(-ies). 

* All rights reserved.

* This component and the accompanying materials are made available

* under the terms of "Eclipse Public License v1.0"

* which accompanies this distribution, and is available

* at the URL "http://www.eclipse.org/legal/epl-v10.html".

*

* Initial Contributors:

* Nokia Corporation - initial contribution.

*

* Contributors:

*

* Description:  Class header for CWsfModel

*

*/

#ifndef WSFLOGGER_H

#define WSFLOGGER_H

#ifdef _DEBUG

#define USE_WSFLOGGER

#endif

#ifdef USE_WSFLOGGER

// undef this if you want logs into file

#define WSFLOGGER_LOGGING_METHOD_RDEBUG

//  EXTERNAL INCLUDES

#include <flogger.h>

#include <e32debug.h>

//  CONSTANTS

_LIT( KLogDir,                  "Sniffer" );

_LIT( KLogFile,                 "Sniffer.txt" );

_LIT( KLogBanner,               "Sniffer 0.1.0" );

_LIT( KLogEnterFn,              "%04x\t% *S-> %S" );

_LIT( KLogLeaveFn,              "%04x\t% *S<- %S" );

_LIT( KLogExit,                 "Sniffer: Application exit" );

_LIT( KLogFormat,               "%04x\t% *S%S" );

//  CLASS DEFINITION

/**

* Class to log functionentry/exit

*

* Example usage:

*

* @code

* #include "wsflogger.h"

*

* ...

* 

* void MyClass::DoIt() 

*     {

*     LOG_ENTERFN( "MyClass::DoIt" );

*     // doing it...

*     }

*

* @endcode

*

* Since the macros create instances on the stack, the class is destructed when

* the stack is unwound. Thus, if LOG_ENTERFN was called at the highest level 

* within the function then the destructor can detect the exit from the 

* function without the need of an explicit "LOG_LEAVEFN" to each exit point.

*

* Note: the destructor is not called if a leave occurs.

*

* @since S60 5.0

*/

NONSHARABLE_CLASS( CFunctionEntryExit ): public CBase

    {

    public:

        /**

        * Constructor

        * @since S60 5.0

        * @param aFunc Name of the function being entered

        */

        CFunctionEntryExit( TRefByValue<const TDesC> aFunc )

            {

            iFunc.Set( aFunc );

            RThread thread;

            TUint tid = TUint( thread.Id() ) & 0xffff;

#ifndef WSFLOGGER_LOGGING_METHOD_RDEBUG

            RFileLogger::WriteFormat( KLogDir, 

                                      KLogFile, 

                                      EFileLoggingModeAppend, 

                                      KLogEnterFn, 

                                      tid,

                                      4*((tid>>2)&0x3),

                                      &KNullDesC,

                                      &iFunc);

#else

            RDebug::Print( KLogEnterFn, tid,

                           4*((tid>>2)&0x3),

                           &KNullDesC,

                           &iFunc);

#endif

            }

        /**

        * Destructor

        * @since S60 5.0

        */

        ~CFunctionEntryExit()

            {

            RThread thread;

            TUint tid = TUint( thread.Id() ) & 0xffff;

#ifndef WSFLOGGER_LOGGING_METHOD_RDEBUG

            RFileLogger::WriteFormat( KLogDir, 

                                      KLogFile, 

                                      EFileLoggingModeAppend, 

                                      KLogLeaveFn, 

                                      tid,

                                      4*((tid>>2)&0x3),

                                      &KNullDesC,

                                      &iFunc);

#else

            RDebug::Print( KLogLeaveFn, 

                           tid,

                           4*((tid>>2)&0x3),

                           &KNullDesC,

                           &iFunc );

#endif

            }

    public:     // data

        /**

        * Function name

        */

        TPtrC iFunc;

    };

//  LOG MACROS       

#ifndef WSFLOGGER_LOGGING_METHOD_RDEBUG

// Create/overwrite the log file

#define LOG_CREATE                                                      \

            {                                                           \

            TFileName path( _L( "c:\\logs\\" ) );                       \

            path.Append( KLogDir );                                     \

            path.Append( _L( "\\" ) );                                  \

            RFileLogger::WriteFormat( KLogDir, KLogFile,                \

                           EFileLoggingModeOverwrite, KLogBanner );     \

            }

// Close the log

#define LOG_DELETE                                                      \

            RFileLogger::Write( KLogDir, KLogFile,                      \

                           EFileLoggingModeAppend, KLogExit );          \

// Place a function entry/exit watchdog            

#define LOG_ENTERFN(a)                                                  \

            CFunctionEntryExit entryExit( _L(a) );

// Write a solid string to the log

#define LOG_WRITE(a)                                                    \

            {                                                           \

            _LIT( temp, a );                                            \

            RThread thread;                                             \

            TUint tid = TUint( thread.Id() ) & 0xffff;                  \

            TBuf<5+12+sizeof(L##a)/2-1> buf;                            \

            buf.Format( KLogFormat,                                     \

                        tid, 4*((tid>>2)&0x3), &KNullDesC, &temp );     \

            RFileLogger::Write( KLogDir, KLogFile,                      \

                                EFileLoggingModeAppend, buf );          \

            }

// Write a formatted string to the log

#define LOG_WRITEF(a, s...)                                             \

            {                                                           \

            _LIT( temp, a );                                            \

            RThread thread;                                             \

            TUint tid = TUint( thread.Id() ) & 0xffff;                  \

            TBuf<5+12+sizeof(L##a)/2-1> buf;                            \

            buf.Format( KLogFormat,                                     \

                        tid, 4*((tid>>2)&0x3), &KNullDesC, &temp );     \

            RFileLogger::WriteFormat( KLogDir, KLogFile,                \

                        EFileLoggingModeAppend, buf, s );               \

            }

#else // WSFLOGGER_LOGGING_METHOD_RDEBUG

// Create/overwrite the log file

#define LOG_CREATE                                                      \

            RDebug::Print(_L("%S"), &KLogBanner);

// Close the log

#define LOG_DELETE                                                      \

            RDebug::Print(_L("%S"), &KLogExit);

// Place a function entry/exit watchdog            

#define LOG_ENTERFN(a)                                                  \

            CFunctionEntryExit entryExit( _L(a) );

// Write a solid string to the log

#define LOG_WRITE(a)                                                    \

            {                                                           \

            _LIT( temp, a );                                            \

            RThread thread;                                             \

            TUint tid = TUint( thread.Id() ) & 0xffff;                  \

            TBuf<5+12+sizeof(L##a)/2-1> buf;                            \

            buf.Format( KLogFormat,                                     \

                        tid, 4*((tid>>2)&0x3), &KNullDesC, &temp );     \

            RDebug::Print(buf);                                         \

            }

// Write a formatted string to the log

#define LOG_WRITEF(a, s...)                                             \

            {                                                           \

            _LIT( temp, a );                                            \

            RThread thread;                                             \

            TUint tid = TUint( thread.Id() ) & 0xffff;                  \

            TBuf<5+12+sizeof(L##a)/2-1> buf;                            \

            buf.Format( KLogFormat,                                     \

                        tid, 4*((tid>>2)&0x3), &KNullDesC, &temp );     \

            RDebug::Print( buf, s);                                     \

            }

#endif // WSFLOGGER_LOGGING_METHOD_RDEBUG

#else // _DEBUG

#define LOG_CREATE

#define LOG_DELETE

#define LOG_ENTERFN(a)

#define LOG_WRITE(a)

#define LOG_WRITEF(a, s...)

#endif // _DEBUG

#endif // WSFLOGGER_H

// End of File