--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/mpx/commonframework/common/src/mpxdata.cpp Thu Dec 17 08:55:47 2009 +0200
@@ -0,0 +1,475 @@
+/*
+* 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