/*
* 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:  CCFContextQueryImpl class implementation.
*
*/


#include <s32strm.h>

#include "CFContextQueryImpl.h"
#include "cfserviceutils.h"
#include "cftrace.h"

// MEMBER FUNCTIONS

EXPORT_C CCFContextQueryImpl* CCFContextQueryImpl::NewL( const TDesC& aSource,
    const TDesC& aType )
    {
    FUNC_LOG;
    
    CCFContextQueryImpl* self = CCFContextQueryImpl::NewLC( aSource, aType );
    CleanupStack::Pop( self );
    
    return self;
    }

EXPORT_C CCFContextQueryImpl* CCFContextQueryImpl::NewLC( const TDesC& aSource,
    const TDesC& aType )
    {
    FUNC_LOG;
    
    CCFContextQueryImpl* self = new( ELeave ) CCFContextQueryImpl;
    CleanupStack::PushL( self );
    self->ConstructL( aSource, aType );
    
    return self;
    }
    
CCFContextQueryImpl::~CCFContextQueryImpl()
    {
    FUNC_LOG;
    
    delete iSource;
    delete iType;
    }

CCFContextQueryImpl::CCFContextQueryImpl()
    {
    FUNC_LOG;
    
    // Nothing to do
    }
    
void CCFContextQueryImpl::ConstructL( const TDesC& aSource,
    const TDesC& aType )
    {
    FUNC_LOG;
    
    // Initialize members
    iSource = aSource.AllocL();
    iType = aType.AllocL();
    }

// METHODS

//-----------------------------------------------------------------------------
// CCFContextQueryImpl::SetTypeL
//-----------------------------------------------------------------------------
// 
void CCFContextQueryImpl::SetTypeL( const TDesC& aType )
    {
    FUNC_LOG;
    
    CFServiceUtils::UpdateBufferL( iType, aType );
    }

//-----------------------------------------------------------------------------
// CCFContextQueryImpl::Type
//-----------------------------------------------------------------------------
// 
const TDesC& CCFContextQueryImpl::Type() const
    {
    FUNC_LOG;

    if( iType )
        {
        return *iType;
        }
    else
        {
        return KNullDesC;
        }
    }

//-----------------------------------------------------------------------------
// CCFContextQueryImpl::SetSourceL
//-----------------------------------------------------------------------------
// 
void CCFContextQueryImpl::SetSourceL( const TDesC& aSource )
    {
    FUNC_LOG;

    CFServiceUtils::UpdateBufferL( iSource, aSource );
    }

//-----------------------------------------------------------------------------
// CCFContextQueryImpl::Source
//-----------------------------------------------------------------------------
// 
const TDesC& CCFContextQueryImpl::Source() const
    {
    FUNC_LOG;

    if( iSource )
        {
        return *iSource;
        }
    else
        {
        return KNullDesC;
        }
    }

//-----------------------------------------------------------------------------
// CCFContextQueryImpl::SubTypeMatch
//-----------------------------------------------------------------------------
//
TBool CCFContextQueryImpl::SubTypeMatch() const
	{
	FUNC_LOG;
	
	return iMatchSubTypes;
	}
		
//-----------------------------------------------------------------------------
// CCFContextQueryImpl::SetTypeMatch
//-----------------------------------------------------------------------------
//
void CCFContextQueryImpl::SetSubTypeMatch( TBool aMatchSubTypes )
    {
	FUNC_LOG;
	
	iMatchSubTypes = aMatchSubTypes;    	
    }

//-----------------------------------------------------------------------------
// CCFContextQueryImpl::Matches
//-----------------------------------------------------------------------------
// 
EXPORT_C TBool CCFContextQueryImpl::MatchesQuery(
    const CCFContextQuery& aQuery,
	const TDesC& aContextType,
	const TDesC& aContextSource,
	TBool aMatchSubTypes )
    {
    FUNC_LOG;

	// Source must be always completely the same
    if( aQuery.Source().Compare( aContextSource ) == KErrNone )
    	{
    	if ( aMatchSubTypes )
    		{
    		// beginning of the type must be same
    		if( aQuery.Type().Compare(
        	aContextType.Left( aQuery.Type().Length() ) ) == KErrNone )
        		{
            	return ETrue;
            	}
    		}
    	else
    		{
    		// type must be completely same
    		if( aQuery.Type().Compare( aContextType ) == KErrNone )
        		{
            	return ETrue;
            	}	
    		}
        }
    return EFalse;
    }

//-----------------------------------------------------------------------------
// CCFContextQueryImpl::Matches
//-----------------------------------------------------------------------------
// 
EXPORT_C TBool CCFContextQueryImpl::Matches( const TDesC& aContextType, 
    const TDesC& aContextSource ) const
    {
    FUNC_LOG;

	return MatchesQuery( *this, aContextType, aContextSource, iMatchSubTypes );
    }


//-----------------------------------------------------------------------------
// CCFContextQueryImpl::IsSame
//-----------------------------------------------------------------------------
// 
EXPORT_C TBool CCFContextQueryImpl::IsSame(
	const CCFContextQuery& aQuery1,
	const CCFContextQuery& aQuery2)
    {
    FUNC_LOG;

    if( aQuery1.Type().Compare( aQuery2.Type() ) == KErrNone &&
        aQuery1.Source().Compare( aQuery2.Source() ) == KErrNone )
        {
        return ETrue;
        }
    else
        {
        return EFalse;
        }
    }

//-----------------------------------------------------------------------------
// CCFContextQueryImpl::InternalizeL
//-----------------------------------------------------------------------------
//
EXPORT_C void CCFContextQueryImpl::InternalizeL( RReadStream& aStream )
    {
    FUNC_LOG;
    
    // Source
    CFServiceUtils::ReadFromStreamL( iSource, aStream );
    
    // Type
    CFServiceUtils::ReadFromStreamL( iType, aStream );
    
    // Sub type match flag
    iMatchSubTypes = aStream.ReadInt16L();
    }

//-----------------------------------------------------------------------------
// CCFContextQueryImpl::ExternalizeL
//-----------------------------------------------------------------------------
//
EXPORT_C void CCFContextQueryImpl::ExternalizeL( RWriteStream& aStream )
    {
    FUNC_LOG;

    // Source
    CFServiceUtils::WriteIntoStreamL( iSource, aStream );
    
    // Type
    CFServiceUtils::WriteIntoStreamL( iType, aStream );
    
    // Sub type match flag
    aStream.WriteInt16L( iMatchSubTypes );
    
    // Commit stream
    aStream.CommitL();
    }

//-----------------------------------------------------------------------------
// CCFContextQueryImpl::Size
//-----------------------------------------------------------------------------
//
EXPORT_C TInt CCFContextQueryImpl::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();
        }
    
    // Sub type match flag
    size += sizeof( iMatchSubTypes );
    
    return size;
    }