// 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

 @publishedPartner

*/

#include <mtp/cmtptypearray.h>

#include <mtp/mtpdatatypeconstants.h>

#include "mtpdatatypespanic.h"

// Array type constants.

const TUint KMTPNumElementsLen(sizeof(TUint32));

const TUint KMTPNumElementsOffset(0);

const TUint KMTPFirstElementOffset(KMTPNumElementsLen);

const TUint KMTPGranularity(8);

/**

MTP array data type factory method. This method is used to create an empty MTP

array.

@param aElementType The MTP type identifier of the elements contained in the 

array.

@param aElementSize The size (in bytes) of the elements contained in the array.

@return A pointer to an empty MTP array data type. Ownership IS transfered.

@leave One of the system wide error codes, if a processing failure occurs.

*/   

EXPORT_C CMTPTypeArray* CMTPTypeArray::NewL(TInt aElementType, TUint aElementSize)

    {

    return NewL(EMTPTypeArray, aElementType, aElementSize);

    }

/**

MTP array data type factory method. This method is used to create an empty MTP

array. A pointer to the MTP array data type is placed on the cleanup stack.

@param aElementType The MTP type identifier of the elements contained in the 

array.

@param aElementSize The size (in bytes) of the elements which contained in 

array.

@return A pointer to an empty MTP array data type. Ownership IS transfered.

@leave One of the system wide error codes, if a processing failure occurs.

*/  

EXPORT_C CMTPTypeArray* CMTPTypeArray::NewLC(TInt aElementType, TUint aElementSize)

    {

    return CMTPTypeArray::NewLC(EMTPTypeArray, aElementType, aElementSize);

    }

/**

MTP array data type factory method. This method is used to create an empty MTP

array of the specified MTP array type.

@param aArrayType The MTP type identifier to be assigned to the array.

@param aElementType The MTP type identifier of the elements contained in the 

array.

@param aElementSize The size (in bytes) of the elements contained in the array.

@return A pointer to an empty MTP array data type. Ownership IS transfered.

@leave One of the system wide error codes, if a processing failure occurs.

*/   

EXPORT_C CMTPTypeArray* CMTPTypeArray::NewL(TInt aArrayType, TInt aElementType, TUint aElementSize)

    {

    CMTPTypeArray* self = NewLC(aArrayType, aElementType, aElementSize);

    CleanupStack::Pop(self);

    return self;

    }

/**

MTP array data type factory method. This method is used to create an empty MTP

array of the specified MTP array type. A pointer to the MTP array data type is 

placed on the cleanup stack.

@param aArrayType The MTP type identifier to be assigned to the array.

@param aElementType The MTP type identifier of the elements contained in the 

array.

@param aElementSize The size (in bytes) of the elements which contained in 

array.

@return A pointer to an empty MTP array data type. Ownership IS transfered.

@leave One of the system wide error codes, if a processing failure occurs.

*/  

EXPORT_C CMTPTypeArray* CMTPTypeArray::NewLC(TInt aArrayType, TInt aElementType, TUint aElementSize)

    {

    CMTPTypeArray* self = new(ELeave) CMTPTypeArray(aArrayType, aElementType, aElementSize);

    CleanupStack::PushL(self);

    self->ConstructL(KMTPGranularity);

    return self;

    }

/**

MTP simple data type array factory method. This method is used to create

an empty MTP array of the specified MTP simple data type.

@param aArrayType The array data type indentifier datacode. This must be in 

the range EMTPTypeFirstSimpleArrayType ... EMTPTypeLastSimpleArrayType.

@return A pointer to an empty MTP array data type. Ownership IS transfered.

@leave KErrArgument, if aArrayType is not in the range 

EMTPTypeFirstSimpleArrayType ... EMTPTypeLastSimpleArrayType.

@leave One of the system wide error codes, if a processing failure occurs.

*/ 

EXPORT_C CMTPTypeArray* CMTPTypeArray::NewL(TInt aArrayType)

    {

    CMTPTypeArray* self = NewLC(aArrayType);

    CleanupStack::Pop(self);

    return self;   

    } 

/**

MTP simple data type array factory method. This method is used to create

an MTP array of the specified MTP simple data type with the specified element 

content.

@param aArrayType The array data type indentifier datacode. This must be in 

the range EMTPTypeFirstSimpleArrayType ... EMTPTypeLastSimpleArrayType.

@param aElements The initial set of element values.

@return A pointer to an empty MTP array data type. Ownership IS transfered.

@leave KErrArgument, if aArrayType is not in the range 

EMTPTypeFirstSimpleArrayType ... EMTPTypeLastSimpleArrayType.

@leave One of the system wide error codes, if a processing failure occurs.

*/ 

EXPORT_C CMTPTypeArray* CMTPTypeArray::NewL(TInt aArrayType, const RArray<TInt>& aElements)

    {

    CMTPTypeArray* self = NewLC(aArrayType, aElements);

    CleanupStack::Pop(self);

    return self; 

    }

/**

MTP simple data type array factory method. This method is used to create

an MTP array of the specified MTP simple data type with the specified element 

content.

@param aArrayType The array data type indentifier datacode. This must be in 

the range EMTPTypeFirstSimpleArrayType ... EMTPTypeLastSimpleArrayType.

@param aElements The initial set of element values.

@return A pointer to an empty MTP array data type. Ownership IS transfered.

@leave KErrArgument, if aArrayType is not in the range 

EMTPTypeFirstSimpleArrayType ... EMTPTypeLastSimpleArrayType.

@leave One of the system wide error codes, if a processing failure occurs.

*/ 

EXPORT_C CMTPTypeArray* CMTPTypeArray::NewL(TInt aArrayType, const RArray<TUint>& aElements)

    {

    CMTPTypeArray* self = NewLC(aArrayType, aElements);

    CleanupStack::Pop(self);

    return self; 

    }

/**

MTP AINT64 array factory method. This method is used to create an MTP AINT64 

array with the specified element content.

@param aElements The initial set of element values.

@return A pointer to an empty MTP array data type. Ownership IS transfered.

@leave KErrArgument, if aArrayType is not in the range 

EMTPTypeFirstSimpleArrayType ... EMTPTypeLastSimpleArrayType.

@leave One of the system wide error codes, if a processing failure occurs.

*/ 

EXPORT_C CMTPTypeArray* CMTPTypeArray::NewL(const RArray<TInt64>& aElements)

    {

    CMTPTypeArray* self = NewLC(aElements);

    CleanupStack::Pop(self); 

    return self; 

    }

/**

MTP AUINT64 array factory method. This method is used to create an MTP AINT64 

array with the specified element content.

@param aElements The initial set of element values.

@return A pointer to an empty MTP array data type. Ownership IS transfered.

@leave KErrArgument, if aArrayType is not in the range 

EMTPTypeFirstSimpleArrayType ... EMTPTypeLastSimpleArrayType.

@leave One of the system wide error codes, if a processing failure occurs.

*/ 

EXPORT_C CMTPTypeArray* CMTPTypeArray::NewL(const RArray<TUint64>& aElements)

    {

    CMTPTypeArray* self = NewLC(aElements);

    CleanupStack::Pop(self);

    return self; 

    }

/**

MTP simple data type array factory method. This method is used to create

an empty MTP array of the specified MTP simple data type. A pointer to the MTP 

array data type is placed on the cleanup stack.

@param aArrayType The array data type indentifier datacode. This must be in 

the range EMTPTypeFirstSimpleArrayType ... EMTPTypeLastSimpleArrayType.

@return A pointer to an empty MTP array data type. Ownership IS transfered.

@leave KErrArgument, if aArrayType is not in the range 

EMTPTypeFirstSimpleArrayType ... EMTPTypeLastSimpleArrayType.

@leave One of the system wide error codes, if a processing failure occurs.

*/ 

EXPORT_C CMTPTypeArray* CMTPTypeArray::NewLC(TInt aArrayType)

    {

    TInt    type(aArrayType);

    TUint   size(0);

    SimpleArrayTypeMetaDataL(aArrayType, type, size);

    CMTPTypeArray* self = new(ELeave) CMTPTypeArray(aArrayType, type, size);

    CleanupStack::PushL(self);

    self->ConstructL(KMTPGranularity);

    return self;   

    }

/**

MTP simple data type array factory method. This method is used to create

an MTP array of the specified MTP simple data type with the specified element 

content. A pointer to the MTP array data type is placed on the cleanup stack.

@param aArrayType The array data type indentifier datacode. This must be in 

the range EMTPTypeFirstSimpleArrayType ... EMTPTypeLastSimpleArrayType.

@param aElements The initial set of element values.

@return A pointer to an empty MTP array data type. Ownership IS transfered.

@leave KErrArgument, if aArrayType is not in the range 

EMTPTypeFirstSimpleArrayType ... EMTPTypeLastSimpleArrayType.

@leave One of the system wide error codes, if a processing failure occurs.

*/ 

EXPORT_C CMTPTypeArray* CMTPTypeArray::NewLC(TInt aArrayType, const RArray<TInt>& aElements)

    {

    TInt    type(aArrayType);

    TUint   size(0);

    SimpleArrayTypeMetaDataL(aArrayType, type, size);

    CMTPTypeArray* self = new(ELeave) CMTPTypeArray(aArrayType, type, size);

    CleanupStack::PushL(self);

    TUint count(aElements.Count());

    self->ConstructL(count);

    for (TUint i(0); (i < count); i++)

        {

        self->AppendIntL(aElements[i]);

        }

    return self; 

    }

/**

MTP simple data type array factory method. This method is used to create

an MTP array of the specified MTP simple data type with the specified element 

content. A pointer to the MTP array data type is placed on the cleanup stack.

@param aArrayType The array data type indentifier datacode. This must be in 

the range EMTPTypeFirstSimpleArrayType ... EMTPTypeLastSimpleArrayType.

@param aElements The initial set of element values.

@return A pointer to an empty MTP array data type. Ownership IS transfered.

@leave KErrArgument, if aArrayType is not in the range 

EMTPTypeFirstSimpleArrayType ... EMTPTypeLastSimpleArrayType.

@leave One of the system wide error codes, if a processing failure occurs.

*/ 

EXPORT_C CMTPTypeArray* CMTPTypeArray::NewLC(TInt aArrayType, const RArray<TUint>& aElements)

    {

    TInt    type(aArrayType);

    TUint   size(0);

    SimpleArrayTypeMetaDataL(aArrayType, type, size);

    CMTPTypeArray* self = new(ELeave) CMTPTypeArray(aArrayType, type, size);

    CleanupStack::PushL(self);

    TUint count(aElements.Count());

    self->ConstructL(count);

    for (TUint i(0); (i < count); i++)

        {

        self->AppendUintL(aElements[i]);

        }

    return self; 

    }

/**

MTP AINT64 array factory method. This method is used to create an MTP AINT64 

array with the specified element content. A pointer to the MTP array data type 

is placed on the cleanup stack.

@param aElements The initial set of element values.

@return A pointer to an empty MTP array data type. Ownership IS transfered.

@leave KErrArgument, if aArrayType is not in the range 

EMTPTypeFirstSimpleArrayType ... EMTPTypeLastSimpleArrayType.

@leave One of the system wide error codes, if a processing failure occurs.

*/ 

EXPORT_C CMTPTypeArray* CMTPTypeArray::NewLC(const RArray<TInt64>& aElements)

    {

    TInt    type(EMTPTypeINT64);

    TUint   size(0);

    SimpleArrayTypeMetaDataL(EMTPTypeAINT64, type, size);

    CMTPTypeArray* self = new(ELeave) CMTPTypeArray(EMTPTypeAINT64, type, size);

    CleanupStack::PushL(self);

    TUint count(aElements.Count());

    self->ConstructL(count);

    for (TUint i(0); (i < count); i++)

        {

        self->AppendInt64L(aElements[i]);

        }

    return self; 

    }

/**

MTP AUINT64 array factory method. This method is used to create an MTP AUINT64 

array with the specified element content. A pointer to the MTP array data type 

is placed on the cleanup stack.

@param aElements The initial set of element values.

@return A pointer to an empty MTP array data type. Ownership IS transfered.

@leave KErrArgument, if aArrayType is not in the range 

EMTPTypeFirstSimpleArrayType ... EMTPTypeLastSimpleArrayType.

@leave One of the system wide error codes, if a processing failure occurs.

*/ 

EXPORT_C CMTPTypeArray* CMTPTypeArray::NewLC(const RArray<TUint64>& aElements)

    {

    TInt    type(EMTPTypeUINT64);

    TUint   size(0);

    SimpleArrayTypeMetaDataL(EMTPTypeAUINT64, type, size);

    CMTPTypeArray* self = new(ELeave) CMTPTypeArray(EMTPTypeAUINT64, type, size);

    CleanupStack::PushL(self);

    TUint count(aElements.Count());

    self->ConstructL(count);

    for (TUint i(0); (i < count); i++)

        {

        self->AppendUint64L(aElements[i]);

        }

    return self; 

    }

/**

Destructor

*/

EXPORT_C CMTPTypeArray::~CMTPTypeArray()

    {

    iBuffer.Close();    

    }

/**

Provides the MTP identifier of the elements contained in the array.

@return The MTP identifier of the elements contained in the array.

*/ 

EXPORT_C TInt CMTPTypeArray::ElementType() const

    {

    return iElementType;    

    }

/**

Provides the number of elements contained in the MTP array.

@return The number of elements contained in the MTP array.

*/ 

EXPORT_C TUint32 CMTPTypeArray::NumElements() const

    {

    return *(reinterpret_cast<const TUint32*>(&iBuffer[KMTPNumElementsOffset]));

    }

/**

Appends the specified element to the end of the MTP array.

@param aElement The element to be appended to the MTP array.

@leave One of the system wide error codes, if a processing failure occurs.

@panic MTPDataTypes 3, if aElement does not match the MTP type of the elements

contained in the array.

*/

EXPORT_C void CMTPTypeArray::AppendL(const MMTPType& aElement)

    {    

    __ASSERT_ALWAYS((aElement.Type() == iElementType), Panic(EMTPTypeIdMismatch));

    const TUint index(NumElements());

    TUint32 numElements(index + 1);

    if (iBuffer.MaxLength() < BufferSize(numElements))

        {

        ReAllocBufferL(numElements);

        }

    TBool complete(EFalse);

    TUint offset(Offset(index));

    TPtrC8 src;

    const TUint startOffset(offset);

    TInt err(aElement.FirstReadChunk(src));

    while (((err == KMTPChunkSequenceCompletion) || (err == KErrNone)) && (!complete))

        {

        __ASSERT_ALWAYS(((offset - startOffset) <= iElementSize), Panic(EMTPTypeSizeMismatch));

        memcpy(&iBuffer[offset], src.Ptr(), src.Length());

        offset += src.Length();

        complete = (err == KMTPChunkSequenceCompletion);

        if (!complete)

            {

            err = aElement.NextReadChunk(src);                

            } 

        }

    if (err != KMTPChunkSequenceCompletion)

        {

        User::Leave(err);            

        }

    SetNumElements(numElements);

    }

/**

Appends the specified elements to the end of the MTP array. The array 

element type MUST be one of the MTP INT8, INT16, or INT32 types.

@param aElements The elements to be appended to the MTP array.

@leave One of the system wide error codes, if a processing failure occurs.

@panic MTPDataTypes 3, if aElement does not match the MTP array's element type.

*/   

EXPORT_C void CMTPTypeArray::AppendL(const RArray<TInt>& aElements)

    {

    TUint count(aElements.Count());

    for (TUint i(0); (i < count); i++)

        {

        AppendIntL(aElements[i]);

        }

    }

/**

Appends the specified elements to the end of the MTP array. The array 

element type MUST be one of the MTP UINT8, UINT16, or UINT32 types.

@param aElements The elements to be appended to the MTP array.

@leave One of the system wide error codes, if a processing failure occurs.

@panic MTPDataTypes 3, if aElement does not match the MTP array's element type.

*/    

EXPORT_C void CMTPTypeArray::AppendL(const RArray<TUint>& aElements)

    {

    TUint count(aElements.Count());

    for (TUint i(0); (i < count); i++)

        {

        AppendUintL(aElements[i]);

        }

    }

/**

Appends the specified elements to the end of the MTP array. The array 

element type MUST be of the MTP INT64 type.

@param aElements The elements to be appended to the MTP array.

@leave One of the system wide error codes, if a processing failure occurs.

@panic MTPDataTypes 3, if aElement does not match the MTP array's element type.

*/   

EXPORT_C void CMTPTypeArray::AppendL(const RArray<TInt64>& aElements)

    {

    TUint count(aElements.Count());

    for (TUint i(0); (i < count); i++)

        {

        AppendInt64L(aElements[i]);

        }

    }

/**

Appends the specified elements to the end of the MTP array. The array 

element type MUST be of the MTP UINT64 type.

@param aElements The elements to be appended to the MTP array.

@leave One of the system wide error codes, if a processing failure occurs.

@panic MTPDataTypes 3, if aElement does not match the MTP array's element type.

*/

EXPORT_C void CMTPTypeArray::AppendL(const RArray<TUint64>& aElements)

    {

    TUint count(aElements.Count());

    for (TUint i(0); (i < count); i++)

        {

        AppendUint64L(aElements[i]);

        }

    }

/**

Appends the specified element to the end of the MTP array. The array 

element type MUST be one of the MTP INT8, INT16, or INT32 types.

@param aElement The element to be appended to the MTP array.

@leave One of the system wide error codes, if a processing failure occurs.

@panic MTPDataTypes 3, if aElement does not match the MTP array's element type.

*/

EXPORT_C void CMTPTypeArray::AppendIntL(TInt aElement)

    {

    __ASSERT_ALWAYS(((iElementType == EMTPTypeINT8) || (iElementType == EMTPTypeINT16) || (iElementType == EMTPTypeINT32)), Panic(EMTPTypeIdMismatch));

    // Relies on Symbian OS little-endianess.

    AppendL(&aElement);

    }

/**

Appends the specified element to the end of the MTP array. The array 

element type MUST be one of the MTP UINT8, UINT16, or UINT32 types.

@param aElement The element to be appended to the MTP array.

@leave One of the system wide error codes, if a processing failure occurs.

@panic MTPDataTypes 3, if aElement does not match the MTP array's element type.

*/

EXPORT_C void CMTPTypeArray::AppendUintL(TUint aElement)

    {  

    __ASSERT_ALWAYS(((iElementType == EMTPTypeUINT8) || (iElementType == EMTPTypeUINT16) || (iElementType == EMTPTypeUINT32)), Panic(EMTPTypeIdMismatch));

    // Relies on Symbian OS little-endianess.

    AppendL(&aElement);  

    }

/**

Appends the specified element to the end of the MTP array. The array 

element type MUST be of the MTP INT64 type.

@param aElement The element to be appended to the MTP array.

@leave One of the system wide error codes, if a processing failure occurs.

@panic MTPDataTypes 3, if aElement does not match the MTP array's element type.

*/

EXPORT_C void CMTPTypeArray::AppendInt64L(TInt64 aElement)

    {    

    __ASSERT_ALWAYS((iElementType == EMTPTypeINT64) ,Panic(EMTPTypeIdMismatch));

    AppendL(&aElement);

    }

/**

Appends the specified element to the end of the MTP array. The array 

element type MUST be of the MTP UINT64 type.

@param aElement The element to be appended to the MTP array.

@leave One of the system wide error codes, if a processing failure occurs.

@panic MTPDataTypes 3, if aElement does not match the MTP array's element type.

*/

EXPORT_C void CMTPTypeArray::AppendUint64L(TUint64 aElement)

    {    

    __ASSERT_ALWAYS((iElementType == EMTPTypeUINT64) ,Panic(EMTPTypeIdMismatch));

    AppendL(&aElement);

    }

/**

Provides a copy of the MTP element at the specified array index.

@param aIndex The index in the MTP array of the required element.

@param aElement On completion, a copy of the required element.

@leave One of the system wide error codes, if a processing failure occurs.

@panic MTPDataTypes 2, if aIndex is greater than or equal to the number of 

objects currently contained in the array.

@panic MTPDataTypes 3, if aElement does not match the MTP type of the elements

contained in the array.

@panic MTPDataTypes 4, if aElement's size does not match that of the elements

contained in the array.

*/

EXPORT_C void CMTPTypeArray::ElementL(TUint aIndex, MMTPType& aElement) const

    {

    __ASSERT_ALWAYS((aIndex < NumElements()), Panic(EMTPTypeBoundsError));