/*

* Copyright (c) 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:  Implementation of data

*

*/

#include <mpxlog.h>

#include "mpxheapmanager.h"

#include "mpxmedia.h"

#include "mpxmediaarray.h"

#include "mpxfixedarray.h"

#include "mpxmediadataarray.h"

#include "mpxdata.h"

/**

*  Class RMPXData. Implementation of MMPXData interface

*/

NONSHARABLE_CLASS( RMPXData ) : public MMPXData

    {

public:

    /**

     * C++ default constructor.

     */

    RMPXData();

public:

    /**

    * Copies contents of aData to this object, deleting any

    * existing data

    */

    TInt Copy(TUint aClientHandle,const RMPXData& aData);

private: // From MMPXData

    TUint DataHandle(TUint aClientHandle);

    void AddRef(TUint aClientHandle);

    void Release(TUint aClientHandle);

    void AddClientRef(TUint aClientHandle);

    TPtrC8 Value(TUint aClientHandle,TInt aIndex);

    const TMPXAttribute& Attribute(TUint aClientHandle,TInt aIndex);

    TMPXAttributeType AttributeType(TUint aClientHandle,TInt aIndex);

    TArray<TInt> SupportedIds(TUint aClientHandle);

    TInt SetSupportedIds(TUint aClientHandle,const TArray<TInt>& aSupportedIds);

    void Delete(TUint aClientHandle,TInt aIndex);

    void Set(TUint aClientHandle,const TMPXAttribute& aAttr,

             TMPXAttributeType aType,const TDesC8& aData,TInt aIndex);

    TInt Insert(TUint aClientHandle,const TMPXAttribute& aAttr,

                TMPXAttributeType aType,const TDesC8& aData,TInt aIndex);

    TInt Append(TUint aClientHandle,const TMPXAttribute& aAttr,

                TMPXAttributeType aType,const TDesC8& aData);

    void Reset(TUint aClientHandle);

    TInt Count(TUint aClientHandle);

    TInt Index(TUint aClientHandle,const TMPXAttribute& aAttr);

    TInt Index(TUint aClientHandle,TInt aUid);

    TInt Uid(TUint aClientHandle,TInt aIndex);

private:

    /**

    * Number of clients (for example CMPXMedia) sharing this object

    */

    TInt iRef;

    /**

    * Array of data items

    */

    RMPXMediaDataItemArray iDataArray;

    /**

    * The IDs supported by the source of the data

    */

    RMPXFixedArray<TInt> iSupportedIds;

    };

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

// MMPXData::NewL

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

//

MMPXData* MMPXData::NewL(TUint aClientHandle)

    {

    RMPXHeapManager& m=RMPXHeapManager::HeapManager(aClientHandle);

    m.Lock(aClientHandle);

    MMPXData* d=m.Alloc<RMPXData>(aClientHandle);

    m.Unlock(aClientHandle);

    User::LeaveIfNull(d);

    return d;

    }

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

// MMPXData::NewL

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

//

MMPXData* MMPXData::NewL(TUint aClientHandle,const MMPXData& aData)

    {

    RMPXHeapManager& m=RMPXHeapManager::HeapManager(aClientHandle);

    m.Lock(aClientHandle);

    RMPXData* d1=m.Alloc<RMPXData>(aClientHandle); // Create empty one

    TInt r=KErrNone;

    if (d1)

        { // Now copy data from old one

        const RMPXData& d2=static_cast<const RMPXData&>(aData);

        r=d1->Copy(aClientHandle,d2);

        }

    m.Unlock(aClientHandle);

    User::LeaveIfNull(d1);

    User::LeaveIfError(r);

    return d1;

    }

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

// MMPXData::Data

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

//

MMPXData* MMPXData::Data(TUint aClientHandle,TAny* aData,TInt aSize)

    {

    MMPXData* d=NULL;

    //

    // Check its the right size, and it's on a word boundary first:

    // if either is not true, then its not an MMPXData implementation

    // for sure

    //

    TBool aligned=((TUint)aData&3)==0;

    const TInt KDataSize=sizeof(TInt)+sizeof(TUint);

    if (aSize==KDataSize&&aligned)

        {

        TUint* ptr=(TUint*)aData;

        MMPXData::TMPXObjectType t=*(MMPXData::TMPXObjectType*)ptr;

        switch(t)

            {

            case MMPXData::EMedia:

            case MMPXData::EMediaArray:

                d=MMPXData::Data(aClientHandle,*++ptr);

                MPX_ASSERT(d);

                MPX_ASSERT_WORD_ALIGNED(d);

                break;

                //

            default:

                break;

            }

        }

    return d;

    }

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

// MMPXData::Data

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

//

MMPXData* MMPXData::Data(TUint aClientHandle,const TDesC8& aData)

    {

    return Data(aClientHandle,(TAny*)aData.Ptr(),aData.Size());

    }

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

// MMPXData::Data

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

//

MMPXData* MMPXData::Data(TUint aClientHandle,TUint aDataHandle)

    {

    return RMPXHeapManager::Ptr<RMPXData>(aClientHandle,aDataHandle);

    }

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

// MMPXData::ClientHandle

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

//

TUint MMPXData::ClientHandle()

    {

    // Already protected by the mutex

    return RMPXHeapManager::ClientHandle();

    }

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

// MMPXData::AddClientRef

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

//

void MMPXData::AddClientRef(TUint aClientHandle)

    {

    RMPXHeapManager::HeapManager(aClientHandle).AddRef(aClientHandle);

    }

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

// MMPXData::ReleaseClient

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

//

void MMPXData::ReleaseClient(TUint aClientHandle)

    {

    RMPXHeapManager::HeapManager(aClientHandle).Release(aClientHandle);

    }

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

// MMPXData::HeapMemoryInfoL

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

//

void MMPXData::HeapMemoryInfoL( TInt& aTotal, TInt& aUsed )

    {

    return RMPXHeapManager::HeapMemoryInfoL( aTotal, aUsed );

    }

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

// RMPXData::LockHeap

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

//

void MMPXData::LockHeap(TUint aClientHandle)

    {

    RMPXHeapManager& m=RMPXHeapManager::HeapManager(aClientHandle);

    m.Lock(aClientHandle);

    }

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

// RMPXData::UnlockHeap

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

//

void MMPXData::UnlockHeap(TUint aClientHandle)

    {

    RMPXHeapManager& m=RMPXHeapManager::HeapManager(aClientHandle);

    m.Unlock(aClientHandle);

    }

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

// RMPXData::RMPXData

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

//

RMPXData::RMPXData()

    :iRef(0)

    {

    }

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

// RMPXData::DataHandle

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

//

TUint RMPXData::DataHandle(TUint aClientHandle)

    {

    return RMPXHeapManager::Offset(aClientHandle,this);

    }

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

// RMPXData::AddRef

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

//

void RMPXData::AddRef(TUint aClientHandle)

    {

#ifdef __ENABLE_MPX_GARBAGE_COLLECTOR

    TUint dataHandle=DataHandle(aClientHandle); //GC

    (void)RMPXHeapManager::HeapManager(aClientHandle).AddData(aClientHandle,dataHandle);//GC

#else

    (void) aClientHandle;

#endif // __ENABLE_MPX_GARBAGE_COLLECTOR

    ++iRef;

    }

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

// RMPXData::Release

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

//

void RMPXData::Release(TUint aClientHandle)

    {

    --iRef;

    RMPXHeapManager& m=RMPXHeapManager::HeapManager(aClientHandle);

#ifdef __ENABLE_MPX_GARBAGE_COLLECTOR

    TUint dataHandle=DataHandle(aClientHandle); //GC

    // if the reference of the data is zero, remove all reference from all

    // clients.

    (void)m.RemoveData(aClientHandle,dataHandle,iRef==0); //GC

#endif // __ENABLE_MPX_GARBAGE_COLLECTOR

    if(iRef==0)

        {

        m.Lock(aClientHandle);

        iDataArray.Close(aClientHandle);

        iSupportedIds.Close(aClientHandle);

        m.Free(aClientHandle,this);

        m.Unlock(aClientHandle);

        }

    }

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

// RMPXData::Value

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

//

TPtrC8 RMPXData::Value(TUint aClientHandle,TInt aIndex)

    {

    return iDataArray.Data(aClientHandle,aIndex);

    }

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

// RMPXData::Attribute

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

//

const TMPXAttribute& RMPXData::Attribute(TUint aClientHandle,TInt aIndex)

    {

    return iDataArray.MediaDataItem(aClientHandle,aIndex)->Attribute();

    }

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

// RMPXData::AttributeType

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

//

TMPXAttributeType RMPXData::AttributeType(TUint aClientHandle,TInt aIndex)

    {

    return iDataArray.MediaDataItem(aClientHandle,aIndex)->Type();

    }

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

// RMPXData::SupportedIds

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

//

TArray<TInt> RMPXData::SupportedIds(TUint aClientHandle)

    {

    return iSupportedIds.Array(aClientHandle);

    }

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

// RMPXData::SetSupportedIds

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

//

TInt RMPXData::SetSupportedIds(TUint aClientHandle,const TArray<TInt>& aSupportedIds)

    {

    RMPXHeapManager& m=RMPXHeapManager::HeapManager(aClientHandle);

    m.Lock(aClientHandle);

    TInt r=iSupportedIds.Copy(aClientHandle,aSupportedIds);

    m.Unlock(aClientHandle);

    return r;

    }

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

// RMPXData::Delete

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

//

void RMPXData::Delete(TUint aClientHandle,TInt aIndex)

    {

    RMPXHeapManager& m=RMPXHeapManager::HeapManager(aClientHandle);

    m.Lock(aClientHandle);

    iDataArray.Remove(aClientHandle,aIndex);

    m.Unlock(aClientHandle);

    }

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

// RMPXData::Set

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

//

void RMPXData::Set(

    TUint aClientHandle,

    const TMPXAttribute& aAttr,

    TMPXAttributeType aType,

    const TDesC8& aData,

    TInt aIndex)

    {

    RMPXHeapManager& m=RMPXHeapManager::HeapManager(aClientHandle);

    m.Lock(aClientHandle);

    iDataArray.Set(aClientHandle,aAttr,aType,aData,aIndex);

    m.Unlock(aClientHandle);

    }

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

// RMPXData::Insert

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

//

TInt RMPXData::Insert(

    TUint aClientHandle,

    const TMPXAttribute& aAttr,

    TMPXAttributeType aType,

    const TDesC8& aData,

    TInt aIndex)

    {

    RMPXHeapManager& m=RMPXHeapManager::HeapManager(aClientHandle);

    m.Lock(aClientHandle);

    TInt r=iDataArray.Insert(aClientHandle,aAttr,aType,aData,aIndex);

    m.Unlock(aClientHandle);

    return r;

    }

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

// RMPXData::Append

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

//

TInt RMPXData::Append(

    TUint aClientHandle,

    const TMPXAttribute& aAttr,

    TMPXAttributeType aType,

    const TDesC8& aData)

    {

    RMPXHeapManager& m=RMPXHeapManager::HeapManager(aClientHandle);

    m.Lock(aClientHandle);

    TInt r=iDataArray.Append(aClientHandle,aAttr,aType,aData);

    m.Unlock(aClientHandle);

    return r;

    }

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

// RMPXData::Reset

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

//

void RMPXData::Reset(TUint aClientHandle)

    {

    RMPXHeapManager& m=RMPXHeapManager::HeapManager(aClientHandle);

    m.Lock(aClientHandle);

    iDataArray.Reset(aClientHandle);

    m.Unlock(aClientHandle);

    }

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

// RMPXData::Count

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

//

TInt RMPXData::Count(TUint /*aClientHandle*/)

    {

    return iDataArray.Count();

    }

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

// RMPXData::Index

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

//

TInt RMPXData::Index(TUint aClientHandle,const TMPXAttribute& aAttr)

    {

    return iDataArray.Index(aClientHandle,aAttr);

    }

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

// RMPXData::Index

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

//

TInt RMPXData::Index(TUint aClientHandle,TInt aUid)

    {

    TInt ret(KErrNotFound);

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

        {

        RMPXMediaDataItem* item=iDataArray.MediaDataItem(aClientHandle,i);

        if (item->Uid()==aUid)

            {

            ret = i;

            break;

            }

        }

    return ret;

    }

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

// RMPXData::Uid

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

//

TInt RMPXData::Uid(TUint aClientHandle,TInt aIndex)

    {

    RMPXMediaDataItem* item=iDataArray.MediaDataItem(aClientHandle,aIndex);

    return item->Uid();

    }

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

// RMPXData::Copy

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

//

TInt RMPXData::Copy(TUint aClientHandle,const RMPXData& aData)

    {

    // Now copy data from old one. The data members are iDataArray

    // and iSupportedIds that need duplicating, and any values that they

    // now hold are deleted; iRef remains the same

    //

    TInt r(KErrNone);

    if (aData.iSupportedIds.Count())

        {

        r=iSupportedIds.RMPXFixedArrayBase::Copy(aClientHandle,aData.iSupportedIds);

        }

    return r==KErrNone?iDataArray.Copy(aClientHandle,aData.iDataArray):r;

    }

// End of file