/*
* Copyright (c) 2006 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:  Declaration of logger
*
*/

#ifndef CONNECTIONMETHODLOGGER_H
#define CONNECTIONMETHODLOGGER_H

// INCLUDE FILES
#include <e32svr.h>

#ifdef _DEBUG

#define __CONNECTION_METHOD_LOG__
#include <flogger.h>

// CONSTANTS

class CFunctionEntryExit;

//Logging to file in THUMB UDEB
class TLogger
    {
    public: // methods

        static void CreateLogger( TAny* aOwner );
        static void CloseLogger( TAny* aOwner );

        static void AttachLogger( const TAny* aOwner, 
                                   const TAny* aAttach1,
                                   const TAny* aAttach2 );
       
        static void NameIt( const TAny* aOwner, 
                            TRefByValue<const TDesC> aNameFmt, 
                            ... );
        
        static void LogIt( const TAny* aOwner, 
                           TRefByValue<const TDesC> aFmt, 
                           ... );
        static void LogIt( const TAny* aOwner, 
                           TRefByValue<const TDesC8> aFmt, 
                           ... );
        static void LogIt( const TAny* aOwner, 
                           TRefByValue<const TDesC> aFmt, 
                           VA_LIST aList );
        static void LogIt( const TAny* aOwner, 
                           TRefByValue<const TDesC8> aFmt, 
                           VA_LIST aList );

    private:       

        TBuf<2048>      iLogBuf;
        TBuf8<2048>     iLogBuf8;
        TInt            iRefCounter;
        TAny*           iOwner;
    };

NONSHARABLE_CLASS( CFunctionEntryExit ): public CBase
    {
    public:

        CFunctionEntryExit( const TAny* aOwner, 
                            TRefByValue<const TDesC> aFunc );
        ~CFunctionEntryExit();

    public:
    
        TPtrC       iFunc;  // function name
        const TAny* iOwner;
        TTime       iEntryTime;
    };

#define LOGGER_ENTERFN( a )     CFunctionEntryExit entryExit( this, _L(a) );
#define CLOG_ENTERFN_PTR( a )   CFunctionEntryExit entryExit( NULL, _L(a) );

#define CLOG_CREATE             TLogger::CreateLogger( this );
#define CLOG_CREATE_PTR         TLogger::CreateLogger( NULL );
#define CLOG_ATTACH( attach1, attach2 )  TLogger::AttachLogger( this, \
                                                                   attach1, \
                                                                   attach2 );
#define CLOG_NAME( a )           TLogger::NameIt( this, a );
#define CLOG_NAME_1( a, b )      TLogger::NameIt( this, a, b );
#define CLOG_NAME_2( a, b, c )   TLogger::NameIt( this, a, b, c );
#define CLOG_NAME_3( a, b, c, d )   TLogger::NameIt( this, a, b, c, d );
#define CLOG_CLOSE               TLogger::CloseLogger( this );
#define CLOG_WRITE( a )          TLogger::LogIt( this, _L(a) );
#define CLOG_WRITE_FORMAT( a, b )   TLogger::LogIt( this, _L(a), b );
#define CLOG_WRITE_1( a, b )     TLogger::LogIt( this, _L(a), b );
#define CLOG_WRITE_2( a, b, c )  TLogger::LogIt( this, _L(a), b, c );
#define CLOG_WRITE_3( a, b, c, d )  TLogger::LogIt( this, _L(a), b, c, d );
#define CLOG_WRITE_4( a, b, c, d, e )   TLogger::LogIt( this, \
                                                          _L(a), b, c, d, e );
#define CLOG_WRITE8( a )         TLogger::LogIt( this, _L8(a) );
#define CLOG_WRITE8_1( a, b )    TLogger::LogIt( this, _L8(a), b );
#define CLOG_WRITE8_2( a, b, c ) TLogger::LogIt( this, _L8(a), b, c );
#define CLOG_WRITE8_3( a, b, c, d ) TLogger::LogIt( this, _L8(a), b, c, d );
#define CLOG_WRITE8_4( a, b, c, d, e )  TLogger::LogIt( this, \
                                                          _L8(a), b, c, d, e );

#define CLOG_NAME_PTR( ptr, a )                     TLogger::NameIt( ptr, a );
#define CLOG_ATTACH_PTR( ptr, attach1, attach2 )    TLogger::AttachLogger( \
                                                        ptr, attach1, attach2 );
#define CLOG_WRITE_PTR( ptr, a )                    TLogger::LogIt( ptr, \
                                                                      _L(a) );
#define CLOG_WRITE_1_PTR( ptr, a, b )               TLogger::LogIt( ptr, \
                                                                    _L(a), b );
#define CLOG_WRITE_2_PTR( ptr, a, b, c )            TLogger::LogIt( ptr, \
                                                                  _L(a), b, c );
#define CLOG_WRITE_3_PTR( ptr, a, b, c, d )         TLogger::LogIt( ptr, \
                                                               _L(a), b, c, d );
#define CLOG_WRITE_4_PTR( ptr, a, b, c, d, e )      TLogger::LogIt( ptr, \
                                                            _L(a), b, c, d, e );
#define CLOG_WRITE_FORMAT_PTR( ptr, a, b )          TLogger::LogIt( ptr, \
                                                                    _L(a), b );
#define CLOG_CLOSE_PTR( ptr )   TLogger::CloseLogger( ptr );

#else   // _DEBUG

#define LOGGER_ENTERFN( a )
#define CLOG_ENTERFN_PTR( a )

#define CLOG_CREATE
#define CLOG_CREATE_PTR
#define CLOG_ATTACH( attach1, attach2 )
#define CLOG_NAME( a )
#define CLOG_NAME_1( a, b )
#define CLOG_NAME_2( a, b, c )
#define CLOG_NAME_3( a, b, c, d )
#define CLOG_CLOSE
#define CLOG_WRITE( a )                   
#define CLOG_WRITE_FORMAT( a, b )              
#define CLOG_WRITE_1( a, b )
#define CLOG_WRITE_2( a, b, c )           
#define CLOG_WRITE_3( a, b, c, d )        
#define CLOG_WRITE_4( a, b, c, d, e )     
#define CLOG_WRITE8( a )                  
#define CLOG_WRITE8_1( a, b )             
#define CLOG_WRITE8_2( a, b, c )          
#define CLOG_WRITE8_3( a, b, c, d )       
#define CLOG_WRITE8_4( a, b, c, d, e )    

#define CLOG_NAME_PTR( ptr, a )
#define CLOG_ATTACH_PTR( ptr, attach1, attach2 )
#define CLOG_WRITE_PTR( ptr, a )
#define CLOG_WRITE_1_PTR( ptr, a, b )
#define CLOG_WRITE_2_PTR( ptr, a, b, c )
#define CLOG_WRITE_3_PTR( ptr, a, b, c, d )
#define CLOG_WRITE_4_PTR( ptr, a, b, c, d, e )
#define CLOG_WRITE_FORMAT_PTR( ptr, a, b )
#define CLOG_CLOSE_PTR( ptr )

#endif // _DEBUG
#endif // CONNECTIONMETHODLOGGER_H