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

//

/**

@file

@internalComponent

*/ 

#include "mtpservicecommon.h"

#include "cmtpserviceinfo.h"

// Class constants.

__FLOG_STMT(_LIT8(KComponent,"ServiceInfo");)

TPKeyPair::TPKeyPair( const TMTPTypeGuid& aNamespace, const TUint aID ):

    iNamespace( aNamespace ),

    iPKeyId(aID)

    {

    }

CServiceElementBase::CServiceElementBase(const TMTPTypeGuid& aGUID, HBufC* aName):

    iCode( KInvliadU16DataCode ),

    iGUID( aGUID ),

    iName( aName )

    {

    }

CServiceElementBase::~CServiceElementBase()

    {

    delete iName;

    }

EXPORT_C TBool CServiceElementBase::IsUsed()

    {

    return ( KInvliadU16DataCode != iCode );

    }

EXPORT_C TUint CServiceElementBase::Code() const

    {

    return iCode;

    }

EXPORT_C const TDesC& CServiceElementBase::Name() const

    {

    return *iName;

    }

EXPORT_C const TMTPTypeGuid& CServiceElementBase::GUID() const

    {

    return iGUID;

    }

EXPORT_C void CServiceElementBase::SetCode( const TUint aCode )

    {

    iCode = aCode;

    }

TInt CServiceElementBase::Compare( const CServiceElementBase& aR ) const

    {

    return iGUID.Compare( aR.GUID() );

    }

CServiceProperty::CServiceProperty( const TMTPTypeGuid& aGUID, const TUint aPkeyID, HBufC* aName, const TUint aDataType, const TUint aGetSet, const TUint aFormFlag):

    CServiceElementBase( aGUID, aName ),

    iPKeyId( aPkeyID ),

    iDataType( aDataType ),

    iGetSet( aGetSet ),

    iFormFlag( aFormFlag )

    {

    }

CServiceProperty* CServiceProperty::NewLC(const TMTPTypeGuid& aGUID, const TUint aPkeyID, HBufC* aName, const TUint aDataType, const TUint aGetSet, const TUint aFormFlag)

    {

    CServiceProperty* self = new (ELeave) CServiceProperty(aGUID, aPkeyID, aName, aDataType, aGetSet, aFormFlag);

    CleanupStack::PushL(self);

    self->ConstructL(); 

    return self;

    }

void CServiceProperty::ConstructL()

    {

    }

EXPORT_C const TMTPTypeGuid& CServiceProperty::Namespace() const

    {

    return GUID();

    }

EXPORT_C TUint CServiceProperty::PKeyID() const

    {

    return iPKeyId;

    }

EXPORT_C TUint CServiceProperty::DataType() const

    {

    return iDataType;

    }

EXPORT_C TUint CServiceProperty::GetSet() const

    {

    return iGetSet;

    }

EXPORT_C TUint CServiceProperty::FormFlag() const

    {

    return iFormFlag;

    }

CServiceFormat::CServiceFormat(const TMTPTypeGuid& aGUID, HBufC* aName, const TUint aBaseFormat, HBufC* aMime ):

    CServiceElementBase( aGUID, aName ),

    iFormatBase(aBaseFormat),

    iMIMEType1(aMime)

    {

    }

CServiceFormat* CServiceFormat::NewLC(const TMTPTypeGuid& aGUID, HBufC* aName, const TUint aBaseFormat, HBufC* aMime )

    {

    CServiceFormat* self = new (ELeave) CServiceFormat( aGUID, aName, aBaseFormat, aMime );

    CleanupStack::PushL(self);

    self->ConstructL(); 

    return self;

    }

void CServiceFormat::ConstructL()

    {

    }

CServiceFormat::~CServiceFormat()

	{

	delete iMIMEType1;

	}

EXPORT_C TUint CServiceFormat::FormatBase() const

    {

    return iFormatBase;

    }

EXPORT_C const TDesC& CServiceFormat::MIMEType1() const

    {

    return *iMIMEType1;

    }

CServiceMethod::CServiceMethod(const TMTPTypeGuid& aGUID, HBufC* aName, const TUint aAssFormat):

    CServiceElementBase( aGUID, aName ),

    iObjAssociateFormatCode(aAssFormat)

    {

    }

CServiceMethod* CServiceMethod::NewLC(const TMTPTypeGuid& aGUID, HBufC* aName, const TUint aAssFormat)

    {

    CServiceMethod* self = new (ELeave) CServiceMethod( aGUID,  aName, aAssFormat );

    CleanupStack::PushL(self);

    self->ConstructL(); 

    return self;

    }

void CServiceMethod::ConstructL()

    {

    }

EXPORT_C TUint CServiceMethod::ObjAssociateFormatCode() const

    {

    return iObjAssociateFormatCode;

    }

CServiceEvent::CServiceEvent( const TUint aCode, const TMTPTypeGuid& aGUID, HBufC* aName):

    CServiceElementBase( aGUID, aName )

    {

    SetCode(aCode);

    }

CServiceEvent* CServiceEvent:: NewLC(const TUint aCode, const TMTPTypeGuid& aGUID, HBufC* aName)

    {

    CServiceEvent* self = new (ELeave) CServiceEvent( aCode, aGUID, aName );

    CleanupStack::PushL(self);

    self->ConstructL(); 

    return self;

    }

void CServiceEvent::ConstructL()

    {

    }

CMTPServiceInfo* CMTPServiceInfo::NewLC()

    {

    CMTPServiceInfo* self = new (ELeave) CMTPServiceInfo();

    CleanupStack::PushL(self);

    self->ConstructL(); 

    return self;

    }

CMTPServiceInfo::~CMTPServiceInfo()

    {

    __FLOG(_L8("CServiceInfo::~CserviceInfo() - Entry"));

    delete iServiceName;

    iUsedServiceGUIDs.Close();

    iServiceProperties.ResetAndDestroy();

    iServiceFormats.ResetAndDestroy();

    iServiceMethods.ResetAndDestroy();

    iServiceEvents.ResetAndDestroy();

    iDataBlock.Close();

    __FLOG(_L8("CServiceInfo::~CserviceInfo() - Exit"));

    __FLOG_CLOSE;

    }

CMTPServiceInfo::CMTPServiceInfo()

    {

    }

void CMTPServiceInfo::ConstructL()

    {

    __FLOG_OPEN(KMTPSubsystem, KComponent);

    __FLOG(_L8("CServiceInfo::ConstructL() - Entry"));

    __FLOG(_L8("CServiceInfo::ConstructL() - Exit"));

    }

TInt CMTPServiceInfo::ServicePropertyOrderFromAscending( const CServiceProperty& aL, const CServiceProperty& aR)

    {

    TInt ret = aL.Compare( aR );

    if( 0 == ret )

        {

        return aL.PKeyID() - aR.PKeyID();

        }

    else

        {

        return ret;

        }

    }

TInt CMTPServiceInfo::ServicePropertyOrderFromKeyAscending( const TPKeyPair* aL, const CServiceProperty& aR)

    {

    TInt ret = aL->iNamespace.Compare( aR.Namespace() );

        if( 0 == ret )

            {

            return aL->iPKeyId - aR.PKeyID();

            }

        else

            {

            return ret;

            }

    }

TInt CMTPServiceInfo::ServiceElementBaseOrderFromAscending( const CServiceElementBase& aL, const CServiceElementBase& aR)

    {

    return aL.Compare( aR );

    }

TInt CMTPServiceInfo::ServiceElementBaseOrderFromKeyAscending( const TMTPTypeGuid* aL, const CServiceElementBase& aR )

    {

    return aL->Compare( aR.GUID() );

    }

TInt CMTPServiceInfo::ServiceFormatOrderFromAscending( const CServiceFormat& aL, const CServiceFormat& aR)

    {

    return ServiceElementBaseOrderFromAscending(aL, aR);

    }

TInt CMTPServiceInfo::ServiceFormatOrderFromKeyAscending( const TMTPTypeGuid* aL, const CServiceFormat& aR )

    {

    return ServiceElementBaseOrderFromKeyAscending(aL, aR);

    }

TInt CMTPServiceInfo::ServiceMethodOrderFromAscending( const CServiceMethod& aL, const CServiceMethod& aR )

    {

    return ServiceElementBaseOrderFromAscending(aL, aR);

    }

TInt CMTPServiceInfo::ServiceMethodOrderFromKeyAscending( const TMTPTypeGuid* aL, const CServiceMethod& aR )

    {

    return ServiceElementBaseOrderFromKeyAscending(aL, aR);

    }

TInt CMTPServiceInfo::ServiceEventOrderFromAscending( const CServiceEvent& aL, const CServiceEvent& aR )

    {

    return ServiceElementBaseOrderFromAscending(aL, aR);

    }

void CMTPServiceInfo::SetServiceID( TUint aServiceID)

    {

    iServiceId = aServiceID;

    }

void CMTPServiceInfo::SetServiceStorageID( TUint aStorageID )

    {

    iServiceStorageId = aStorageID;

    }

void CMTPServiceInfo::SetPersistentGUIDL( const TMTPTypeGuid& aGUID )

    {

    MMTPType::CopyL( aGUID, iPersistentGUID);

    }

void CMTPServiceInfo::SetServiceVersion( TUint aVersion )

    {

    iServiceVersion = aVersion;

    }

void CMTPServiceInfo::SetServiceGUIDL( const TMTPTypeGuid& aGUID )

    {

    MMTPType::CopyL( aGUID, iServiceGUID);

    }

void CMTPServiceInfo::SetServiceName( HBufC* aName )

    {

    delete iServiceName;

    iServiceName = aName;

    }

void CMTPServiceInfo::SetServiceType( TUint aServiceType )

    {

    iServiceType = aServiceType;

    }

void CMTPServiceInfo::SetBaseServiceID( TUint aID )

    {

    iBaseServiceId = aID;

    }

void CMTPServiceInfo::AppendUserServiceL( const TMTPTypeGuid& aServiceGUID )

    {

    __FLOG(_L8("CServiceInfo::AppendUserServiceL - Entry"));

    iUsedServiceGUIDs.AppendL( aServiceGUID );

    __FLOG(_L8("CServiceInfo::AppendUserServiceL - Exit"));

    }

void CMTPServiceInfo::InsertPropertyL( const CServiceProperty* aProperty )

    {

    __FLOG(_L8("CServiceInfo::InsertPropertyL - Entry"));

    iServiceProperties.InsertInOrderL( aProperty, TLinearOrder<CServiceProperty>(ServicePropertyOrderFromAscending) );

    __FLOG(_L8("CServiceInfo::InsertPropertyL - Exit"));

    }

void CMTPServiceInfo::InsertFormatL( const CServiceFormat* aFormat )

    {

    __FLOG(_L8("CServiceInfo::InsertFormatL - Entry"));

    iServiceFormats.InsertInOrderL( aFormat, TLinearOrder<CServiceFormat>(ServiceFormatOrderFromAscending) );

    __FLOG(_L8("CServiceInfo::InsertFormatL - Exit"));

    }

void CMTPServiceInfo::InsertMethodL( const CServiceMethod* aMethod )

    {

    __FLOG(_L8("CServiceInfo::InsertMethodL - Entry"));

    iServiceMethods.InsertInOrderL( aMethod , TLinearOrder<CServiceMethod>(ServiceMethodOrderFromAscending) );

    __FLOG(_L8("CServiceInfo::InsertMethodL - Exit"));

    }

void CMTPServiceInfo::InsertEventL( const CServiceEvent* aEvent )

    {

    __FLOG(_L8("CServiceInfo::InsertMethodL - Entry"));

    iServiceEvents.InsertInOrderL( aEvent , TLinearOrder<CServiceEvent>(ServiceEventOrderFromAscending) );

    __FLOG(_L8("CServiceInfo::InsertMethodL - Exit"));

    }

void CMTPServiceInfo::AppendDataGUIDL( const TMTPTypeGuid& aGUID )

    {

    __FLOG(_L8("CServiceInfo::AppendDataGUIDL - Entry"));

    iDataBlock.AppendL( aGUID );

    __FLOG(_L8("CServiceInfo::AppendDataGUIDL - Exit"));

    }

EXPORT_C TUint CMTPServiceInfo::ServiceID() const

    {

    return iServiceId;

    }

EXPORT_C TUint CMTPServiceInfo::ServiceStorageID() const

    {

    return iServiceStorageId;

    }

EXPORT_C const TMTPTypeGuid& CMTPServiceInfo::ServicePersistentGUID() const

    {

    return iPersistentGUID;

    }

EXPORT_C TUint CMTPServiceInfo::ServiceVersion() const

    {

    return iServiceVersion;

    }

EXPORT_C const TMTPTypeGuid& CMTPServiceInfo::ServiceGUID() const

    {

    return iServiceGUID;

    }

EXPORT_C const TDesC& CMTPServiceInfo::ServiceName() const

    {

    return *iServiceName;

    }

EXPORT_C TUint CMTPServiceInfo::ServiceType() const

    {

    return iServiceType;

    }

EXPORT_C TUint CMTPServiceInfo::BaseServiceID() const

    {

    return iBaseServiceId;

    }

CServiceProperty* CMTPServiceInfo::ServiceProperty( const TMTPTypeGuid& aPKNamespace, const TUint aPKID ) const

    {

    TInt index = iServiceProperties.FindInOrder( TPKeyPair(aPKNamespace, aPKID), ServicePropertyOrderFromKeyAscending );

    if( index != KErrNotFound )

        return iServiceProperties[index];

    return NULL;

    }

CServiceFormat* CMTPServiceInfo::ServiceFormat( const TMTPTypeGuid& aGUID ) const

    {

    TInt index = iServiceFormats.FindInOrder( aGUID, ServiceFormatOrderFromKeyAscending );

    if( index != KErrNotFound )

        return iServiceFormats[index];

    return NULL;

    }

CServiceMethod* CMTPServiceInfo::ServiceMethod( const TMTPTypeGuid& aGUID ) const

    {

    TInt index = iServiceMethods.FindInOrder( aGUID , ServiceMethodOrderFromKeyAscending );

    if( index != KErrNotFound )

        return iServiceMethods[index];

    return NULL;

    }

EXPORT_C const RArray<TMTPTypeGuid>& CMTPServiceInfo::UsedServiceGUIDs() const

	{

	return iUsedServiceGUIDs;

	}

EXPORT_C const RPointerArray<CServiceProperty>& CMTPServiceInfo::ServiceProperties() const

	{

	return iServiceProperties;

	}

EXPORT_C const RPointerArray<CServiceFormat>& CMTPServiceInfo::ServiceFormats() const

	{

	return iServiceFormats;

	}

EXPORT_C const RPointerArray<CServiceMethod>& CMTPServiceInfo::ServiceMethods() const

	{

	return iServiceMethods;

	}

EXPORT_C const RPointerArray<CServiceEvent>& CMTPServiceInfo::ServiceEvents() const

	{

	return iServiceEvents;

	}

EXPORT_C const RArray<TMTPTypeGuid>& CMTPServiceInfo::DataBlockGUIDs() const

    {

    return iDataBlock;

    }