// 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/cmtptypestring.h>
#include <mtp/mtpdatatypeconstants.h>

#include "mtpdatatypespanic.h"

// String type constants
const TUint KMTPAlignmentOffset(0);
const TUint KMTPAlignmentSize(1);
const TUint KMTPNumCharsOffset(KMTPAlignmentOffset + KMTPAlignmentSize);
const TUint KMTPNumCharsSize(KMTPTypeUINT8Size);
const TUint KMTPStringCharactersOffset(KMTPNumCharsOffset + KMTPNumCharsSize);

/**
MTP string data type factory method. This method is used to create a 
zero-length MTP string.
@return A pointer to a zero-length MTP string data type. Ownership IS 
transfered.
@leave One of the system wide error codes, if unsuccessful.
*/   
EXPORT_C CMTPTypeString* CMTPTypeString::NewL()
    {
	CMTPTypeString* self = NewLC(); 
	CleanupStack::Pop(self);
	return self; 
    }

/**
MTP string data type factory method. This method is used to create an 
MTP string with the specified value.
@param aString The initial string value.
@return A pointer to the MTP string data type. Ownership IS transfered.
@leave One of the system wide error codes, if unsuccessful.
*/     
EXPORT_C CMTPTypeString* CMTPTypeString::NewL(const TDesC& aString)
    {
	CMTPTypeString* self = NewLC(aString);
	CleanupStack::Pop(self);
	return self;
    }

/**
MTP string data type factory method. This method is used to create a 
zero-length MTP string. A pointer to the MTP string data type is placed on the
cleanup stack.
@return A pointer to a zero-length MTP string data type. Ownership IS 
transfered.
@leave One of the system wide error codes, if unsuccessful.
*/   
EXPORT_C CMTPTypeString* CMTPTypeString::NewLC()
    {
	CMTPTypeString* self = NewLC(KNullDesC);
	return self;    
    }

/**
MTP string data type factory method. This method is used to create an MTP 
string with the specified value. A pointer to the MTP string data type is 
placed on the cleanup stack.
@param aString The initial string value.
@return A pointer to the MTP string data type. Ownership IS transfered.
@leave One of the system wide error codes, if unsuccessful.
*/      
EXPORT_C CMTPTypeString* CMTPTypeString::NewLC(const TDesC& aString)
    {
	CMTPTypeString* self = new(ELeave) CMTPTypeString;
	CleanupStack::PushL(self);
    self->ConstructL(aString);
	return self;
    }

/**
Destructor
*/
EXPORT_C CMTPTypeString::~CMTPTypeString()
    {
    iBuffer.Close();
    }
    
/**
Provides the number of unicode characters making up the MTP string.
@return The number of unicode characters making up the MTP string.
*/    
EXPORT_C TUint8 CMTPTypeString::NumChars() const
    {
    return iBuffer[KMTPNumCharsOffset];
    }

/**
Provides a non-modifiable reference to the MTP String Characters data. The data
provided does not include the terminating null character.
@return A non-modifiable MTP string data reference.
*/  
EXPORT_C const TDesC& CMTPTypeString::StringChars() const
    {
    return iStringChars;
    }
    
/**
Sets the MTP string data type to the specified value.
@param aString The type's new value.
@leave One of the system wide error codes, if a processing error occurs.
*/     
EXPORT_C void CMTPTypeString::SetL(const TDesC& aString)
    {
    ConstructL(aString);
    }
	
EXPORT_C TInt CMTPTypeString::FirstReadChunk(TPtrC8& aChunk) const
    {
	aChunk.Set(&iBuffer[KMTPNumCharsOffset], (iBuffer.Length() - KMTPAlignmentSize));
    return KMTPChunkSequenceCompletion;
    }
	
EXPORT_C TInt CMTPTypeString::NextReadChunk(TPtrC8& aChunk) const
    {
    aChunk.Set(NULL, 0);
    return KErrNotReady;
    }
	
EXPORT_C TInt CMTPTypeString::FirstWriteChunk(TPtr8& aChunk)
    {
    TInt ret(KErrNone);
    aChunk.Set(&iBuffer[KMTPNumCharsOffset], 0, KMTPNumCharsSize);
    iWriteSequenceState = ENumChars;        
    return ret;
    }
	
EXPORT_C TInt CMTPTypeString::NextWriteChunk(TPtr8& aChunk)
    {
    TInt ret(KMTPChunkSequenceCompletion);
    
    if (iWriteSequenceState != ENumChars)
        {
        ret = KErrNotReady;
        }
    else
        {
        const TUint numChars(NumChars());
        __ASSERT_ALWAYS((numChars <= KMTPMaxStringLength), Panic(EMTPTypeSizeMismatch));
        if (numChars > 0)
            {
        	aChunk.Set(&iBuffer[KMTPStringCharactersOffset], 0, (iBuffer.MaxLength() - KMTPAlignmentSize - KMTPNumCharsSize));
            }
        else
            {
            aChunk.Set(NULL, 0, 0);
            }
            
        iWriteSequenceState = EStringChars;
        }
        
    return ret;
    }
    
EXPORT_C TUint64 CMTPTypeString::Size() const
    {
	return (iBuffer.Size() - KMTPAlignmentSize);
    }
    
EXPORT_C TUint CMTPTypeString::Type() const
	{
	return EMTPTypeString;
	}

EXPORT_C TBool CMTPTypeString::CommitRequired() const
    {
    return ETrue;
    }

EXPORT_C MMTPType* CMTPTypeString::CommitChunkL(TPtr8& aChunk)
    {
    switch (iWriteSequenceState)
        {
    case ENumChars:
        /* 
        The first chunk specifies the NumChars field, and is used to re-size 
        the array buffer. 
        */
        ReAllocBufferL(NumChars());  
        break;
        
    case EStringChars:
        // Check that the correct number of characters has been received.
        {
        TUint len(aChunk.Length());
        if ((len % KMTPCharSize) ||
            ((len / KMTPCharSize) != NumChars()))
            {
            iValidationState = KMTPDataTypeInvalid;
            User::Leave(iValidationState);
            }
        iWriteSequenceState = EIdle;
        }
        break;
        
    case EIdle:
    default:
        break;
        }
    return NULL;
    }
    
EXPORT_C TInt CMTPTypeString::Validate() const
    {
    return iValidationState;
    }

CMTPTypeString::CMTPTypeString() :
    iBuffer(),
    iStringChars(NULL, 0)
    {

    }

void CMTPTypeString::ConstructL(const TDesC& aString)
    {
    if (aString.Length() > KMTPMaxStringCharactersLength)
        {
        User::Leave(KErrArgument);            
        }
    
    // Allocate string storage.
    TUint numChars(aString.Length());
    if (numChars)
        {
        numChars += KMTPNullCharLen;   
        }
    ReAllocBufferL(numChars);
    
    // Append the String Characters.
    if (numChars > 0)
        {
        iStringChars.Copy(aString);
        }
    }

void CMTPTypeString::ReAllocBufferL(TUint aNumNullTerminatedChars)
    {
    if (aNumNullTerminatedChars > KMTPMaxStringLength)
        {
        User::Leave(KErrOverflow);            
        }
        
    // Delete the current buffer
    iBuffer.Close();
    iStringChars.Set(NULL, 0, 0);
    
    // Allocate a new buffer.
    if (aNumNullTerminatedChars > 0)
        {  
        /*
        Allocate storage for both the NumChars and String Characters fields. A single 
        alignment byte is pre-pended to force String Characters to be 16-bit aligned.
        */
        iBuffer.CreateMaxL(KMTPAlignmentSize + KMTPNumCharsSize + (aNumNullTerminatedChars * KMTPCharSize));
        
        // Insert the terminating NULL character.
        TUint numChars(aNumNullTerminatedChars - KMTPNullCharLen);
        memcpy(&iBuffer[KMTPStringCharactersOffset + (numChars * KMTPCharSize)], &KMTPNullChar, KMTPCharSize);
        
        // Set the String Characters pointer.
        iStringChars.Set(reinterpret_cast<TUint16*>(&iBuffer[KMTPStringCharactersOffset]), numChars, numChars);
        }
    else
        {       
        /*
        Allocate storage for the NumChars field only. A single alignment byte 
        is pre-pended to force String Characters to be 16-bit aligned.
        */
        iBuffer.CreateMaxL(KMTPNumCharsSize + KMTPAlignmentSize);
        }
        
    // Insert the NumChars value
    iBuffer[KMTPNumCharsOffset] = aNumNullTerminatedChars;
    }