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

 // CLogEventType

 // 

 //

 /** Gets the UID identifying the event type.

 @return The UID. */

 inline TUid CLogEventType::Uid() const

 	{

 	return iUid;

 	}

 /** Sets the UID identifying the event type.

 @param aUid The Uid. */

 inline void CLogEventType::SetUid(TUid aUid)

 	{

 	iUid = aUid;

 	}

 /** Gets the human readable and localised name of the event type.

 @return A non-modifiable descriptor containing the name. */

 inline const TDesC& CLogEventType::Description() const

 	{

 	return *iDescription;

 	}

 /** Sets the human readable and localised name of the event type.

 For example, Email.

 @param aDescription The name. */

 inline void CLogEventType::SetDescription(const TDesC& aDescription)

 	{

 	iDescription->Des().Copy(aDescription);

 	}

 /** Determines whether logging for this event type is enabled.

 @return ETrue, if logging is enabled. EFalse, if logging is disabled. */

 inline TBool CLogEventType::LoggingEnabled() const

 	{

 	return iLoggingEnabled;

 	}

 /** Enables or disables logging for this event type.

 Note that disabling the logging of an event type causes a CLogClient::AddEventL() 

 request for an event of that type to complete with an appropriate error.

 @param aEnable ETrue, to enable logging for this event type.EFalse, to disable 

 logging for this event type.

 @see CLogClient::AddEvent() */

 inline void CLogEventType::SetLoggingEnabled(TBool aEnable)

 	{

 	iLoggingEnabled = aEnable;

 	}

 //**********************************

 // CLogFilter

 //**********************************

 /** Gets the event type used by the filter.

 @return The event type UID.

 @see CLogEvent::EventType() */

 inline TUid CLogFilter::EventType() const

 	{

 	return iEventType;

 	}

 /** Sets the event type to be used by the filter.

 @param aType The event type UID.

 @see CLogEvent::SetEventType() */

 inline void CLogFilter::SetEventType(TUid aType)

 	{

 	iEventType = aType;

 	}

 /** Gets the remote party string used by the filter.

 @return A non-modifiable descriptor containing the remote party string.

 @see CLogEvent::RemoteParty() */

 inline const TDesC& CLogFilter::RemoteParty() const

 	{

 	return *iRemoteParty;

 	}

 /** Sets the remote party string to be used by the filter.

 @param aRemote The remote party string.

 @see CLogEvent::SetRemoteParty() */

 inline void CLogFilter::SetRemoteParty(const TDesC& aRemote)

 	{

 	iRemoteParty->Des().Copy(aRemote);

 	}

 /** Gets the direction string used by the filter.

 @return A non-modifiable descriptor containing the direction string.

 @see CLogEvent::Direction() */

 inline const TDesC& CLogFilter::Direction() const

 	{

 	return *iDirection;

 	}

 /** Sets the direction string to be used by the filter.

 @param aDirection The direction string.

 @see CLogEvent::SetDirection() */

 inline void CLogFilter::SetDirection(const TDesC& aDirection)

 	{

 	iDirection->Des().Copy(aDirection);

 	}

 /** Gets the duration type used by the filter.

 @return The duration type.

 @see CLogEvent::DurationType() */

 inline TLogDurationType CLogFilter::DurationType() const

 	{

 	return iDurationType;

 	}

 /** Sets the duration type to be used by the filter.

 @param aType The duration type.

 @see CLogEvent::SetDurationType() */

 inline void CLogFilter::SetDurationType(TLogDurationType aType)

 	{

 	iDurationType = aType;

 	}

 /** Gets the delivery status used by the filter.

 @return A non-modifiable descriptor containing the delivery status.

 @see CLogEvent::Status() */

 inline const TDesC& CLogFilter::Status() const

 	{

 	return *iStatus;

 	}

 /** Sets the delivery status to be used by the filter.

 @param aStatus The delivery status.

 @see CLogEvent::SetStatus() */

 inline void CLogFilter::SetStatus(const TDesC& aStatus)

 	{

 	iStatus->Des().Copy(aStatus);

 	}

 /** Gets the contact ID used by the filter.

 @return The contact ID.

 @see CLogEvent::Contact() */

 inline TLogContactItemId  CLogFilter::Contact() const

 	{

 	return iContact;

 	}

 /** Sets the contact ID to be used by the filter.

 @param aContact The contact ID.

 @see CLogEvent::SetContact() */

 inline void CLogFilter::SetContact(TLogContactItemId  aContact)

 	{

 	iContact = aContact;

 	}

 /** Gets the phone number used by the filter.

 @return A non-modifiable descriptor containing the phone number.

 @see CLogEvent::Number() */

 inline const TDesC& CLogFilter::Number() const

 	{

 	return *iNumber;

 	}

 /** Sets the phone number to be used by the filter.

 @param aNumber The phone number.

 @see CLogEvent::SetNumber() */

 inline void CLogFilter::SetNumber(const TDesC& aNumber)

 	{

 	iNumber->Des().Copy(aNumber);

 	}

 /** Identifies the fields defined as NULL in the filter. These are the fields that 

 the filter expects to be NULL in the database. A NULL field is one that has 

 no value.

 @return Bit values defining the null fields.

 @see SetNullFields() */

 inline TUint32 CLogFilter::NullFields() const

 	{

 	return iNullFields;

 	}

 /** Defines NULL fields to the filter. These are the fields that the filter expects 

 to be NULL in the database. A NULL field is one that has no value.

 Each field is identified by a bit value. The bit values may be ORd together 

 in any combination.

 Note that setting a flag and explicitly setting a value for the corresponding 

 field generates an OR condition in the SQL WHERE clause.

 @param aFields Bit values defining the null fields. These are one or more 

 of the following values defined in logwrap.hrh: ELogContactField, ELogDirectionField, 

 ELogDurationTypeField, ELogEventTypeField, ELogNumberField, ELogRemotePartyField, 

 ELogStatusField, ELogFlagsField, ELogSubjectField, ELogLinkField, ELogDataField, ELogSimIdField. */

 inline void CLogFilter::SetNullFields(TUint32 aFields)

 	{

 	iNullFields = aFields;

 	}

 /** Gets the UTC start time used by the filter.

 @return The UTC start time. */

 inline const TTime& CLogFilter::StartTime() const

 	{

 	return iStartTime;

 	}

 /** Sets the specified UTC start time to be used by the filter.

 @param aStartTime The UTC start time to be set. */

 inline void CLogFilter::SetStartTime(const TTime& aStartTime)

 	{

 	iStartTime = aStartTime; 

 	}

 /** Gets the UTC end time used by the filter.

 @return The UTC end time. */

 inline const TTime& CLogFilter::EndTime() const

 	{

 	return iEndTime;

 	}

 /** Sets the specified UTC end time to be used by the filter.

 @param aEndTime The UTC end time to be set. */

 inline void CLogFilter::SetEndTime(const TTime& aEndTime)

 	{

 	iEndTime = aEndTime;

 	}

 /** Gets the flags used by the filter.

 @return The flags. */

 inline TLogFlags CLogFilter::Flags() const

 	{

 	return iFlags;

 	}

 /** Sets the specified flags to be used by the filter.

 @param aFlags The flags to be set. */

 inline void CLogFilter::SetFlags(TLogFlags aFlags)

 	{

 	__ASSERT_DEBUG(aFlags <= KLogFlagsMask, User::Invariant());

 	iFlags = (TLogFlags)(iFlags | aFlags);

 	}

 /** Clears the specified flags to be used by the filter. 

 The constant KLogFlagsMask can be used to clear all the flags.

 @param aFlags The flags to be cleared */

 inline void CLogFilter::ClearFlags(TLogFlags aFlags)

 	{

 	__ASSERT_DEBUG(aFlags <= KLogFlagsMask, User::Invariant());

 	iFlags = (TLogFlags)(iFlags & ~aFlags);

 	}