/*
* Copyright (c) 2006-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:   Contains the function definitions used for logging in clock2.
*
*/
#ifndef __CLOCK_DEBUG_H__
#define __CLOCK_DEBUG_H__

/** The clock debug flag */
#undef __CLOCK_DEBUG__

// If the debug flag is not defined, all the macros are null.
#ifndef __CLOCK_DEBUG__

#define __TIME_MARK(_var)
#define __TIME_ENDMARK(_msg, _var)
#define __TIME(_msg, _code) _code;
#define __TICK(_msg)
#define __HEAP(_msg)
#define __PRINT(_fmt, args...)
#define __PRINT8(_fmt, args...)
#define __PRINTS(_str)
#define __PRINT_IF_ERROR(_stmt, _fmt) _stmt;
#define __TRAP_AND_PRINT_IF_ERROR(_stmt, _fmt) TRAP_IGNORE(_stmt);

#else

// System includes.
#include <flogger.h>

// Constants
#ifndef D_LOG_DIR
#define D_LOG_DIR _L("clock")			// The log directory.
#endif

#ifndef D_LOG_FILE
#define D_LOG_FILE _L("debug.log")		// The log file.
#endif


// ========== LOCAL FUNCTIONS =================================================

// ----------------------------------------------------------------------------
//
// Performance logging operation, give results in microseconds 10^-6
// The metricts are based on the measurment current value of microseconds in 
// the begining of operation and in the end. The time difference is actual result
//
// The logging operations take about 5ms, which should be considered if inner
// tag are used.
//
// Examples:
//
// __TIME_MARK(t)
// DoOperation(...);
// __TIME_ENDMARK(_L("Message 1"), t);
//
// __TIME(_L("Message 1"), DoOperation(...))
//
// ----------------------------------------------------------------------------
//

//
// Actual implementation of 
// Logs the microsecond difference between current value and stored earlier
// aMsg - textual message stored to the log file
// aStart - the start time, the value is set by previous macros
//
inline void __impl_time_endmark(const TDesC& aMsg, TTime aStart)
	{
	TTime now;
	now.UniversalTime();
	TTimeIntervalMicroSeconds delta = now.MicroSecondsFrom(aStart);
	RFileLogger::WriteFormat(D_LOG_DIR, D_LOG_FILE, EFileLoggingModeAppend, _L("\t[T]\t%S\tTime:\t%Ld"), &aMsg, delta.Int64());	
	}

//
// Prints the message and current ms value to the log file
//
inline void __impl_tick(const TDesC& aMsg)
	{
	// Gets the nanokernel tick count. This is the current value of the machine's millisecond tick counter.
    TUint32 nTick = User::NTickCount();
	RFileLogger::WriteFormat(D_LOG_DIR, D_LOG_FILE, EFileLoggingModeAppend, _L("\t[T]\t%S\tMicro Sec:\t%d000"), &aMsg, nTick);	
	}

//
// Stores the current microsecond value
// _var - A name, which will be declared as a TInt, and will receive the current time value.
// After the macro, _var remains in scope until the end of its enclosing block.
//
#define __TIME_MARK(_var) TTime _var;_var.UniversalTime();

//
// Logs the microsecond difference between current value and stored earlier
// _msg - textual message stored to the log file
// _var - the start time, the value is set by previous macros
//
#define __TIME_ENDMARK(_msg, _var) __impl_time_endmark(_L(_msg), _var);

//
// Measures the execution of code statement
// _msg - textual message stored to the log file
// _code - code statements to be measured
//
#define __TIME(_msg, _code) {TTime _time;_time.UniversalTime();_code;__impl_time_endmark(_L(_msg),_time);};

//
// The message and current ms value to the log file
//
#define __TICK(_msg) __impl_tick(_L(_msg));

// ----------------------------------------------------------------------------
// Logs the amout of used heap to log file. Notes that the Heap value equals
// to the result provided by Goofy tool.
// ----------------------------------------------------------------------------
//
inline void __impl_heap(const TDesC& aMsg)
	{
	// Log Memory	
    TInt size;
    User::Heap().AllocSize(size);
    RFileLogger::WriteFormat(D_LOG_DIR, D_LOG_FILE, EFileLoggingModeAppend, _L("\t[M]\t%S\tAlloc:\t%d\tHeap:\t%d"), &aMsg, size, User::Heap().Size());	
	}

#define __HEAP(_msg) __impl_heap(_L(_msg));

// ----------------------------------------------------------------------------
//
// ----------------------------------------------------------------------------
//
inline void __impl_print(TRefByValue<const TDesC16> aFmt, ...)
	{
	VA_LIST list;
	VA_START(list,aFmt);
	
	// Log event
    RFileLogger::WriteFormat(D_LOG_DIR, D_LOG_FILE, EFileLoggingModeAppend, aFmt, list);
	}

inline void __impl_print8(TRefByValue<const TDesC8> aFmt, ...)
	{
	VA_LIST list;
	VA_START(list,aFmt);
	
	// Log event
    RFileLogger::WriteFormat(D_LOG_DIR, D_LOG_FILE, EFileLoggingModeAppend, aFmt, list);
	}

inline void __impl_prints(const TDesC& aMsg)
	{
	RFileLogger::WriteFormat(D_LOG_DIR, D_LOG_FILE, EFileLoggingModeAppend, _L("\t[I]\t%S"), &aMsg);
	}

// It is a correct approach to define function-like macroses but GCC give
// compilatoin error.
// #define __PRINT(_fmt, ...) __impl_print(_L(_fmt), __VA_ARGS__);
// #define __PRINT8(_fmt, ...) __impl_print8(_L8(_fmt), __VA_ARGS__);
#define __PRINT(_fmt, args...) __impl_print(_L(_fmt), args);
// #define __PRINT8(_fmt, args...) __impl_print8(_L8(_fmt), args);
#define __PRINTS(_str) __impl_prints(_L(_str));

#define __PRINT_IF_ERROR(_stmt, _fmt) { TInt _error = _stmt; if (_error != KErrNone) __PRINT(_fmt, _error); };
#define __TRAP_AND_PRINT_IF_ERROR(_stmt, _fmt) { TRAPD(_error, _stmt); if (_error != KErrNone) __PRINT(_fmt, _error); };

#endif		// __CLOCK_DEBUG__

#endif		// __CLOCK_DEBUG_H__

// End of file