// Copyright (c) 2002-2009 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:

 //

 #include "LogServRecentList.h"

 #include <barsread.h>

 #include <logcntdef.h>

 #include <logcli.h>

 #include <logengdurations.h>

 #include <logfilterandeventconstants.hrh>

 #include <logwraplimits.h>

 #include "logservpanic.h"

 #include "LogServRecentCondition.h"

 #include "LogServSqlStrings.h"

 /////////////////////////////////////////////////////////////////////////////////////////

 // -----> CLogServRecentList (source)

 /////////////////////////////////////////////////////////////////////////////////////////

 CLogServRecentList::~CLogServRecentList()

 	{

 	iConditions.ResetAndDestroy();

 	iConditions.Close();

 	}

 void CLogServRecentList::ConstructL(TResourceReader& aReader)

 	{

 	iId = static_cast<TLogRecentList>(aReader.ReadInt8());

 	iDuplicates = static_cast<TUint16>(aReader.ReadUint16());

 	TInt count = aReader.ReadInt16();

 	iConditions.ReserveL(count);

 	while(count--)

 		{

 		CLogServRecentCondition* condition = CLogServRecentCondition::NewL(aReader);

 		TInt err = iConditions.Append(condition);

         __ASSERT_ALWAYS(err == KErrNone, Panic(ELogArrayReserved));

 		}

 	}

 CLogServRecentList* CLogServRecentList::NewL(TResourceReader& aReader)

 	{

 	CLogServRecentList* self = new(ELeave) CLogServRecentList;

 	CleanupStack::PushL(self);

 	self->ConstructL(aReader);

 	CleanupStack::Pop();

 	return self;

 	}

 #ifdef SYSLIBS_TEST

 #pragma BullseyeCoverage off

 //Used by the unit tests when SYSLIBS_TEST macro is defined.

 //Creates a complex recent list with a lot of fields.

 //This helps covering most of recent list related production code branches.

 CLogServRecentList* CLogServRecentList::TestNewL()

 	{

 	CLogServRecentList* self = new(ELeave) CLogServRecentList;

 	CleanupStack::PushL(self);

 	self->TestConstructL();

 	CleanupStack::Pop();

 	return self;

 	}

 void CLogServRecentList::TestConstructL()

 	{

 	iId = KLogRctTListId;

 	iDuplicates = ELogRemotePartyField | ELogNumberField | ELogDirectionField | ELogDurationTypeField |

 	              ELogStatusField | ELogFlagsField | ELogSubjectField

 #ifdef SYMBIAN_ENABLE_EVENTLOGGER_DUALSIM	

 	              | ELogSimIdField

 #endif	

 	              ;

 	TInt count = 7;//7 test recent list conditions added in the code bellow

 	iConditions.ReserveL(count);

 	//1

 	CLogServRecentCondition* condition1 = CLogServRecentCondition::TestNewL(ELogDirectionField);

 	(void)iConditions.Append(condition1);

 	//2

 	CLogServRecentCondition* condition2 = CLogServRecentCondition::TestNewL(ELogDurationTypeField);

 	(void)iConditions.Append(condition2);

 	//3

 	CLogServRecentCondition* condition3 = CLogServRecentCondition::TestNewL(ELogNumberField);

 	(void)iConditions.Append(condition3);

 	//4

 	CLogServRecentCondition* condition4 = CLogServRecentCondition::TestNewL(ELogRemotePartyField);

 	(void)iConditions.Append(condition4);

 	//5

 	CLogServRecentCondition* condition5 = CLogServRecentCondition::TestNewL(ELogStatusField);

 	(void)iConditions.Append(condition5);

 	//6

 	CLogServRecentCondition* condition6 = CLogServRecentCondition::TestNewL(ELogFlagsField);

 	(void)iConditions.Append(condition6);

 #ifdef SYMBIAN_ENABLE_EVENTLOGGER_DUALSIM	

 	//7

 	CLogServRecentCondition* condition7 = CLogServRecentCondition::TestNewL(ELogSimIdField);

 	(void)iConditions.Append(condition7);

 #endif	

 	}

 #pragma BullseyeCoverage on

 #endif//SYSLIBS_TEST

 /////////////////////////////////////////////////////////////////////////////////////////

 /////////////////////////////////////////////////////////////////////////////////////////

 /////////////////////////////////////////////////////////////////////////////////////////

 /**

 Checks whether the aEvent field values satisfy the conditions described in 

 in this CLogServRecentList object.

 @param aEvent Reference to a CLogEvent object which field values will be tested.

 @return True If the aEvent field values satisfy the conditions, false otherwise.

 */

 TBool CLogServRecentList::IsRecent(const CLogEvent& aEvent) const

 	{

 	//The implemented algorithm is:

 	//  usedFieldBitMask    - bit mask, where the "1" bits correspond to the fields used in the "recent condition" objects - 

 	//                        the iConditions array. Each "recent condition" object has "field" and "value" data members,

 	//                        where the "field" data member value is a power of 2.

 	//                        Some of the iConditions elemens may have the same field value.

 	//  matchedFieldBitMask - bit mask, where the "1" bits correspond to a "recent condition" object which field value is 

 	//                        equal to the corresponding field value of the aEvent object.

 	//

 	//  For example, the iConditions array contains three elements initialised as:

 	//            [2, "Incomming"]

 	//            [8, 1000550D]

 	//            [2, "Incomming Alternate"]

 	//  The aEvent object contains these fields initialized:

 	//            [2, "Incomming"]

 	//            [8, 1000550D]

 	//  Then usedFieldBitMask value will be:    0000000A -  (2 | 8).

 	//       matchedFieldBitMask value will be: 0000000A -  (2 | 8).

 	//  So, the operation performed on particular matchedFieldBitMask bit is bitwise OR -

 	//      in case if two "recent condition" objects use the same field (but have different field values), then the result

 	//      of the matching operation with the corresponding aEvent field value will be OR-ed in that matchedFieldBitMask bit.

 	TUint16 usedFieldBitMask = 0;

 	TUint16 matchedFieldBitMask = 0;

 	for(TInt i=iConditions.Count()-1;i>=0;--i)

 		{

 		const CLogServRecentCondition& condition = *iConditions[i];

 		usedFieldBitMask |= condition.Field();

 		if(condition.IsMatch(aEvent))

 			{

 			matchedFieldBitMask |= condition.Field();

 			}

 		}

 	//If both usedFieldBitMask and matchedFieldBitMask are 0, that means - the iConditions array is empty.

 	//The function returns true in this case.

 	return usedFieldBitMask == matchedFieldBitMask;

 	}

 void CLogServRecentList::GetFilter(const CLogEvent& aEvent, CLogFilter& aFilter) const

 	{

 	TUint16 nullFieldsBitMask = 0;

 	if	(iDuplicates & ELogContactField)

 		{

 		aFilter.SetContact(aEvent.Contact());

       	if (aEvent.Contact() == KLogNullContactId) 

 			nullFieldsBitMask |= ELogContactField;

 		}

 	if	(iDuplicates & ELogDirectionField)

 		{

 		aFilter.SetDirection(aEvent.Direction());

 		if (aEvent.Direction().Length() == 0) 

 			nullFieldsBitMask |= ELogDirectionField;

 		}

 	if	(iDuplicates & ELogDurationTypeField)

 		{

 		aFilter.SetDurationType(aEvent.DurationType());

 		if (aEvent.DurationType() == KLogDurationNone) 

 			nullFieldsBitMask |= ELogDurationTypeField;

 		}

 	if	(iDuplicates & ELogEventTypeField)

 		{

 		aFilter.SetEventType(aEvent.EventType());

 		if (aEvent.EventType() == KNullUid) 

 			nullFieldsBitMask |= ELogEventTypeField;

 		}

 	if	(iDuplicates & ELogNumberField)

 		{

 		aFilter.SetNumber(aEvent.Number());

 		if (aEvent.Number().Length() == 0) 

 			nullFieldsBitMask |= ELogNumberField;

 		}

 	if	(iDuplicates & ELogRemotePartyField)

 		{

 		aFilter.SetRemoteParty(aEvent.RemoteParty());

 		if (aEvent.RemoteParty().Length() == 0) 

 			nullFieldsBitMask |= ELogRemotePartyField;

 		}

 	if	(iDuplicates & ELogStatusField)

 		{

 		aFilter.SetStatus(aEvent.Status());

 		if (aEvent.Status().Length() == 0) 

 			nullFieldsBitMask |= ELogStatusField;

 		}

 	if	(iDuplicates & ELogFlagsField)

 		{

 		aFilter.SetFlags(aEvent.Flags());

 		if (aEvent.Flags() == KLogNullFlags) 

 			nullFieldsBitMask |= ELogFlagsField;

 		}

 #ifdef SYMBIAN_ENABLE_EVENTLOGGER_DUALSIM	

 	if	(iDuplicates & ELogSimIdField)

 		{

 		aFilter.SetSimId(aEvent.SimId());

       	if (aEvent.SimId() == KLogNullSimId) 

 			nullFieldsBitMask |= ELogSimIdField;

 		}

 #endif	

 	aFilter.SetNullFields(nullFieldsBitMask); 

 	// This is a special case, if all the fields are null

 	// In this case we want to be a duplicate of other events where all the fields are null

 	if	(IsFilterEmpty(aFilter))

 		aFilter.SetNullFields(iDuplicates);

 	}

 TBool CLogServRecentList::IsFilterEmpty(const CLogFilter& aFilter) const

 	{

 	return aFilter.EventType() == KNullUid &&

 	       aFilter.RemoteParty().Length() == 0 &&

 	       aFilter.Direction().Length() == 0 &&

 	       aFilter.Status().Length() == 0 &&

 	       aFilter.Contact() == KLogNullContactId &&

 	       aFilter.Number().Length() == 0 

 #ifdef SYMBIAN_ENABLE_EVENTLOGGER_DUALSIM	

 	       &&

 	       aFilter.SimId() == KLogNullSimId

 #endif	       

 	       ;

 	}