/*

* Copyright (c) 2002-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:  CCFContextObjectImpl class description.

*

*/

#include <s32strm.h>

#include "CFContextObjectImpl.h"

#include "cfserviceutils.h"

#include "cftrace.h"

static const TInt KTimesSame = 0;

static const TInt KTimeFirstGreater = -1;

static const TInt KTimeSecondGreater = 1;

static const TUint KFullConfidence = 100;

// MEMBER FUNCTIONS

EXPORT_C CCFContextObjectImpl* CCFContextObjectImpl::NewL()

    {

    FUNC_LOG;

    CCFContextObjectImpl* self = CCFContextObjectImpl::NewLC();

    CleanupStack::Pop( self );

    return self;

    }

EXPORT_C CCFContextObjectImpl* CCFContextObjectImpl::NewLC()

    {

    FUNC_LOG;

    CCFContextObjectImpl* self = new( ELeave ) CCFContextObjectImpl;

    CleanupStack::PushL( self );

    self->ConstructL( KNullDesC, KNullDesC, KNullDesC );

    return self;

    }

EXPORT_C CCFContextObjectImpl* CCFContextObjectImpl::NewL( const TDesC& aSource,

    const TDesC& aType,

    const TDesC& aValue )

    {

    FUNC_LOG;

    CCFContextObjectImpl* self =

        CCFContextObjectImpl::NewLC( aSource, aType, aValue );

    CleanupStack::Pop( self );

    return self;

    }

EXPORT_C CCFContextObjectImpl* CCFContextObjectImpl::NewLC( const TDesC& aSource,

    const TDesC& aType,

    const TDesC& aValue )

    {

    FUNC_LOG;

    CCFContextObjectImpl* self = new( ELeave ) CCFContextObjectImpl;

    CleanupStack::PushL( self );

    self->ConstructL( aSource, aType, aValue );

    return self;

    }

CCFContextObjectImpl::~CCFContextObjectImpl()

    {

    FUNC_LOG;

    delete iSource;

    delete iType;

    delete iValue;

    }

CCFContextObjectImpl::CCFContextObjectImpl():

    iConfidence( KFullConfidence )

    {

    FUNC_LOG;

    // Nothing to do

    }

void CCFContextObjectImpl::ConstructL( const TDesC& aSource,

    const TDesC& aType,

    const TDesC& aValue )

    {

    FUNC_LOG;

    // Initialize pointers

    iSource = aSource.AllocL();

    iType = aType.AllocL();

    iValue = aValue.AllocL();

    }

// METHODS

//-----------------------------------------------------------------------------

// CCFContextObjectImpl::SetTypeL

//-----------------------------------------------------------------------------

//

void CCFContextObjectImpl::SetTypeL( const TDesC& aType )

    {

    FUNC_LOG;

    CFServiceUtils::UpdateBufferL( iType, aType );

    }

//-----------------------------------------------------------------------------

// CCFContextObjectImpl::Type

//-----------------------------------------------------------------------------

//

const TDesC& CCFContextObjectImpl::Type() const

    {

    FUNC_LOG;

    if( iType )

        {

        return *iType;

        }

    else

        {

        return KNullDesC;

        }

    }

//-----------------------------------------------------------------------------

// CCFContextObjectImpl::SetValueL

//-----------------------------------------------------------------------------

//

void CCFContextObjectImpl::SetValueL( const TDesC& aValue )

    {

    FUNC_LOG;

    CFServiceUtils::UpdateBufferL( iValue, aValue );

    }

//-----------------------------------------------------------------------------

// CCFContextObjectImpl::Value

//-----------------------------------------------------------------------------

//

const TDesC& CCFContextObjectImpl::Value() const

    {

    FUNC_LOG;

    if( iValue )

        {

        return *iValue;

        }

    else

        {

        return KNullDesC;

        }

    }

//-----------------------------------------------------------------------------

// CCFContextObjectImpl::SetSourceL

//-----------------------------------------------------------------------------

//

void CCFContextObjectImpl::SetSourceL( const TDesC& aSource )

    {

    FUNC_LOG;

    CFServiceUtils::UpdateBufferL( iSource, aSource );

    }

//-----------------------------------------------------------------------------

// CCFContextObjectImpl::Source

//-----------------------------------------------------------------------------

//

const TDesC& CCFContextObjectImpl::Source() const

    {

    FUNC_LOG;

    if( iSource )

        {

        return *iSource;

        }

    else

        {

        return KNullDesC;

        }

    }

//-----------------------------------------------------------------------------

// CCFContextObjectImpl::SetConfidence

//-----------------------------------------------------------------------------

//

void CCFContextObjectImpl::SetConfidence( const TUint8& aConfidence )

    {

    FUNC_LOG;

    iConfidence = aConfidence;

    }

//-----------------------------------------------------------------------------

// CCFContextObjectImpl::Confidence

//-----------------------------------------------------------------------------

//

TUint8 CCFContextObjectImpl::Confidence() const

    {

    FUNC_LOG;

    return iConfidence;

    }

//-----------------------------------------------------------------------------

// CCFContextObjectImpl::SetTimestampToHomeTime

//-----------------------------------------------------------------------------

//

void CCFContextObjectImpl::SetTimestampToHomeTime()

    {

    FUNC_LOG;

    iTimestamp.HomeTime();

    }

//-----------------------------------------------------------------------------

// CCFContextObjectImpl::SetTimestamp

//-----------------------------------------------------------------------------

//

void CCFContextObjectImpl::SetTimestamp( const TTime& aTimestamp )

    {

    FUNC_LOG;

    iTimestamp = aTimestamp;

    }

//-----------------------------------------------------------------------------

// CCFContextObjectImpl::SetTimestamp

//-----------------------------------------------------------------------------

//

void CCFContextObjectImpl::SetTimestamp( const TInt64& aTimestamp )

    {

    FUNC_LOG;

    iTimestamp = aTimestamp;

    }

//-----------------------------------------------------------------------------

// CCFContextObjectImpl::Timestamp

//-----------------------------------------------------------------------------

//

const TTime& CCFContextObjectImpl::Timestamp() const

    {

    FUNC_LOG;

    return iTimestamp;

    }

//-----------------------------------------------------------------------------

// CCFContextObjectImpl::CopyL

//-----------------------------------------------------------------------------

//

void CCFContextObjectImpl::CopyL( const CCFContextObject& aContext )

    {

    FUNC_LOG;

    SetSourceL( aContext.Source() );

    SetTypeL( aContext.Type() );

    SetValueL( aContext.Value() );

    SetTimestamp( aContext.Timestamp() );

    SetConfidence( aContext.Confidence() );

    }

//-----------------------------------------------------------------------------

// CCFContextObjectImpl::InternalizeL

//-----------------------------------------------------------------------------

//

EXPORT_C void CCFContextObjectImpl::InternalizeL( RReadStream& aStream )

    {

    FUNC_LOG;

    // Source

    CFServiceUtils::ReadFromStreamL( iSource, aStream );

    // Type

    CFServiceUtils::ReadFromStreamL( iType, aStream );

    // Value

    CFServiceUtils::ReadFromStreamL( iValue, aStream );

    // Timestamp

    TPckg<TTime> timeStamp( iTimestamp );

    aStream.ReadL( timeStamp, sizeof( TTime ) );

    // Confidence

    iConfidence = aStream.ReadUint16L();

    }

//-----------------------------------------------------------------------------

// CCFContextObjectImpl::ExternalizeL

//-----------------------------------------------------------------------------

//

EXPORT_C void CCFContextObjectImpl::ExternalizeL( RWriteStream& aStream )

    {

    FUNC_LOG;

    // Source

    CFServiceUtils::WriteIntoStreamL( iSource, aStream );

    // Type

    CFServiceUtils::WriteIntoStreamL( iType, aStream );

    // Value

    CFServiceUtils::WriteIntoStreamL( iValue, aStream );

    // Timestamp

    TPckg<TTime> timestamp( iTimestamp );

    aStream.WriteL( timestamp, sizeof( TTime ) );

    // Confidence

    aStream.WriteUint16L( iConfidence );

    // Commit stream

    aStream.CommitL();

    }

//-----------------------------------------------------------------------------

// CCFContextObjectImpl::Size

//-----------------------------------------------------------------------------

//

EXPORT_C TInt CCFContextObjectImpl::Size() const

    {

    FUNC_LOG;

    TInt size = 0;

    // Source

    size += sizeof( TInt );

    if( iSource )

        {

        size += ( *iSource ).Size();

        }

    // Type

    size += sizeof( TInt );

    if( iType )

        {

        size += ( *iType ).Size();

        }

    // Value

    size += sizeof( TInt );

    if( iValue )

        {

        size += ( *iValue ).Size();

        }

    // Timestamp

    size += sizeof( TTime );

    // Confidence

    size += sizeof( TUint );

    return size;

    }

//-----------------------------------------------------------------------------

// CCFContextObjectImpl::CompareValue

//-----------------------------------------------------------------------------

//

EXPORT_C TInt CCFContextObjectImpl::CompareValue(

    const CCFContextObject& aContext ) const

    {

    FUNC_LOG;

    return Value().Compare( aContext.Value() );

    }

//-----------------------------------------------------------------------------

// CCFContextObjectImpl::CompareByType

//-----------------------------------------------------------------------------

//

EXPORT_C TInt CCFContextObjectImpl::CompareByType(

    const CCFContextObject& aFirst,

    const CCFContextObject& aSecond )

    {

    FUNC_LOG;

    return aFirst.Type().Compare( aSecond.Type() );

    }

//-----------------------------------------------------------------------------

// CCFContextObjectImpl::CompareByTypeAndSource

//-----------------------------------------------------------------------------

//

EXPORT_C TInt CCFContextObjectImpl::CompareByTypeAndSource(

    const CCFContextObject& aFirst,

    const CCFContextObject& aSecond )

    {

    FUNC_LOG;

    TInt typeCompareResult = aFirst.Type().Compare( aSecond.Type() );

    if( typeCompareResult != 0 )

        {

        return typeCompareResult;

        }

    else

        {

        return aFirst.Source().Compare( aSecond.Source() );

        }

    }

//-----------------------------------------------------------------------------

// CCFContextObjectImpl::CompareByTimeDescending

//-----------------------------------------------------------------------------

//

EXPORT_C TInt CCFContextObjectImpl::CompareByTimeDescending( 

    const CCFContextObject& aFirst,

    const CCFContextObject& aSecond )

    {

    FUNC_LOG;

    TInt retVal = KTimeSecondGreater;

    // Both same

    if( aFirst.Timestamp() == aSecond.Timestamp() )

        {

        retVal = KTimesSame;

        }

    // First greater than second

    else if( aFirst.Timestamp() > aSecond.Timestamp() )

        {

        retVal = KTimeFirstGreater;

        }

    return retVal;

    }

//-----------------------------------------------------------------------------

// CCFContextObjectImpl::IsSame

//-----------------------------------------------------------------------------

//

EXPORT_C TBool CCFContextObjectImpl::IsSame(

    const CCFContextObject& aFirst,

    const CCFContextObject& aSecond )

    {

    FUNC_LOG;

    if( aFirst.Timestamp() == aSecond.Timestamp() )

        {

        if( aFirst.Type().Compare( aSecond.Type() ) == KErrNone )

            {

            if( aFirst.Value().Compare( aSecond.Value() ) == KErrNone )

                {

                if( aFirst.Source().Compare( aSecond.Source() ) == KErrNone )

                    {

                    if( aFirst.Confidence() == aSecond.Confidence() )

                        {

                        return ETrue;

                        }

                    }

                }

            }

        }

    return EFalse;

    }