/*
* 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 array of variable size elements on global chunk
*
*/

#include "mpxmediadataarray.h"
#include "mpxheapmanager.h"
#include "mpxdata.h"

#define ITEM(x,y) RMPXHeapManager::Ptr<RMPXMediaDataItem>(x,y)

// -----------------------------------------------------------------------------
// RMPXMediaDataItemArray::Append
// -----------------------------------------------------------------------------
//
TInt RMPXMediaDataItemArray::Append(
    TUint aClientHandle,
    const TMPXAttribute& aAttr,
    TMPXAttributeType aAttrType,
    const TDesC8& aData)
    {
    MPX_ASSERT(aClientHandle);
    //
    TInt r=KErrNone;
    RMPXMediaDataItem* item=NewItem(aClientHandle,aAttr,aAttrType,aData);
    if (item)
        {
        RMPXDataItemArray::Append(aClientHandle,*item);
        }
    else
        {
        r=KErrNoMemory;
        }
    return r;
    }


// -----------------------------------------------------------------------------
// RMPXMediaDataItemArray::Set
// -----------------------------------------------------------------------------
//
TInt RMPXMediaDataItemArray::Set(
    TUint aClientHandle,
    const TMPXAttribute& aAttr,
    TMPXAttributeType aAttrType,
    const TDesC8& aData,
    TInt aIndex)
    {
    TInt r=KErrNone;
    RMPXMediaDataItem* item=NewItem(aClientHandle,aAttr,aAttrType,aData);
    if (item)
        {       
        RMPXDataItemArray::Set(aClientHandle,*item,aIndex);
        }
    else
        {
        r=KErrNoMemory;
        }
    return r;
    }

// -----------------------------------------------------------------------------
// RMPXMediaDataItemArray::RMPXMediaDataItemArray
// -----------------------------------------------------------------------------
//
TInt RMPXMediaDataItemArray::Insert(
    TUint aClientHandle,
    const TMPXAttribute& aAttr,
    TMPXAttributeType aAttrType,
    const TDesC8& aData,
    TInt aIndex)
    {
    TInt r=KErrNone;
    RMPXMediaDataItem* item=NewItem(aClientHandle,aAttr,aAttrType,aData);
    if (item)
        {       
        RMPXDataItemArray::Insert(aClientHandle,*item,aIndex);
        }
    else
        {
        r=KErrNoMemory;
        }
    return r;
    }

// -----------------------------------------------------------------------------
// RMPXMediaDataItemArray::Index
// -----------------------------------------------------------------------------
//
TInt RMPXMediaDataItemArray::Index(TUint aClientHandle,const TMPXAttribute& aAttr)
    {
    TInt index( KErrNotFound );
    RMPXMediaDataItem* item=NULL;
    
    if (iFirstItemOffset)
        {
        item=ITEM(aClientHandle,iFirstItemOffset);
        while(item)
            {
            index++;
            if (item->Attribute()==aAttr)
                {
                //
                // Found it, so break outer of the loop, but first store
                // the current position in case an index based query will
                // follow (e,g, for data, type etc.)
                //
                iIndex=index;
                iPos=RMPXHeapManager::Offset(aClientHandle,item);
                break;
                }
            TInt next=item->NextOffset();
            item=next?ITEM(aClientHandle,next):NULL;
            }
        }
    return item?index:KErrNotFound;
    }
 
 // -----------------------------------------------------------------------------
// RMPXMediaDataItemArray::NewItem
// -----------------------------------------------------------------------------
//   
 RMPXMediaDataItem* RMPXMediaDataItemArray::NewItem(
    TUint aClientHandle,
    const TMPXAttribute& aAttr,
    TMPXAttributeType aAttrType,
    const TDesC8& aData)
    {
    MPX_ASSERT(aClientHandle);
    //
    RMPXHeapManager& m=RMPXHeapManager::HeapManager(aClientHandle);
    TAny* ptr=m.Alloc(aClientHandle, sizeof(RMPXMediaDataItem) + aData.Size());
    RMPXMediaDataItem* item(NULL);
    if (ptr) 
        { 
        //Alloc media data item
        item = new(ptr)RMPXMediaDataItem();
        //Copy data to RMPXMediaDataItem
        item->Copy(aClientHandle,aData);
        item->SetAttribute(aAttr,aAttrType);
        }
    return item;
    }

// -----------------------------------------------------------------------------
// RMPXDataItemArray::Copy
// -----------------------------------------------------------------------------
//
TInt RMPXMediaDataItemArray::Copy(
    TUint aClientHandle,
    const RMPXMediaDataItemArray& aArray)
    {
    Reset(aClientHandle); // Clear existing data
    TInt r=KErrNone;
    TInt first=aArray.iFirstItemOffset;
    if (first)
        {
        RMPXMediaDataItem* item=ITEM(aClientHandle,first);
        while(item)
            {
            MMPXData* d=MMPXData::Data(aClientHandle,
                                       item->Buf(aClientHandle),
                                       item->Size());
            if (d)
                { 
                // It's a global object. e.g. media or media array, so we need to copy
                // that and place the handle into the buffer
                //
                MMPXData* newd=NULL;
                TRAP(r,newd=MMPXData::NewL(aClientHandle,*d)); // will end up recursive
                if (r==KErrNone)
                    {
                    // Create the data: a buffer of 8 bytes
                    //
                    const TInt KMediaStreamLen=sizeof(MMPXData::TMPXObjectType)+sizeof(TUint);
                    TBuf8<KMediaStreamLen> newbuf;
                    //
                    TUint* ptr=(TUint*)newbuf.Ptr(); // pointer to the new (empty) buffer
                    TUint* oldPtr=(TUint*)item->Buf(aClientHandle); // pointer to the old data
                    //
                    *ptr=*oldPtr; // the TMPXObjectType
                    *++ptr=newd->DataHandle(aClientHandle); //  the data: handle to this new data
                    //
                    newbuf.SetLength(KMediaStreamLen);
                    //
                    r=Append(aClientHandle,item->Attribute(),item->Type(),newbuf);
                    //
                    // Don't need to call newd->Release(aClientHandle) currently, since the Append()
                    // would have created a ref count of 1, and the MMPXData::NewL() doesn't.
                    //
                    }
                }
            else 
                {
                // Regular streamed object, so we can duplicate it by just copying the bytes
                // in an Append()
                //
                r=Append(aClientHandle,item->Attribute(),item->Type(),item->Data(aClientHandle));
                }
            item=item->NextOffset()&&r==KErrNone?ITEM(aClientHandle,item->NextOffset()):NULL;
            }
        }
    return r;
    }

// End of file