/*
* Copyright (c) 2005 Nokia Corporation and/or its subsidiary(-ies).
* All rights reserved.
* This component and the accompanying materials are made available
* under the terms of the License "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:  A base class to serialize objects between clients and the server.
*
*/


#include "Logger.h"
#include "Packed.h"
#include "PackedAttributes.h"


// -----------------------------------------------------------------------------
// CPacked::CPacked
//
// C++ default constructor can NOT contain any code, that
// might leave.  
// -----------------------------------------------------------------------------
//
CPacked::CPacked(TInt aTokenArrayInc, TInt aStringTableInc):
        KTokenArrayInc(aTokenArrayInc), KStringTableInc(aStringTableInc)
    {
    }
        

// -----------------------------------------------------------------------------
// CPacked::ConstructL
//
// Symbian 2nd phase constructor can leave.  
// -----------------------------------------------------------------------------
//
void CPacked::BaseConstructL()
    {
    iStringTable = HBufC::NewL(KStringTableInc);
    }
        

// -----------------------------------------------------------------------------
// CPacked::~CPacked
//
// Deconstructor.  
// -----------------------------------------------------------------------------
//
CPacked::~CPacked()
    {
    delete iTokenArray;
    delete iStringTable;
    }

        
// -----------------------------------------------------------------------------
// CPacked::AddAttributeL
//
// Insert an attribute.  This attribute is applied to the enclosing entity 
// (Feed, Item, Enclosure, folder, etc.).   
// -----------------------------------------------------------------------------
//
void CPacked::AddAttributeL(TInt aAttribute, const TDesC& aValue)
    {
    TUint  offset;
    
    // Get the offset for the string.
    offset = iStringTable->Length();
        
    // If need be re-alloc the string table.
    if ((iStringTable->Length() + aValue.Length()) >= iStringTable->Des().MaxLength())
        {
        TUint delta = KStringTableInc;
        
        if (aValue.Length() > KStringTableInc)
            {
            delta = aValue.Length() + KStringTableInc;
            }
            
        iStringTable = iStringTable->ReAllocL(iStringTable->Des().MaxLength() + delta);
        }

    // Add the value to the string table.
    iStringTable->Des().Append(aValue);
    
    // Add the attribute token block.
    InsertTokenL(EPackedTokenAttribute);
    InsertTokenL(aAttribute);
    InsertTokenL(offset);
    InsertTokenL(aValue.Length());
    }


// -----------------------------------------------------------------------------
// CPacked::AddAttributeL
//
// Insert an attribute.  This attribute is applied to the enclosing entity 
// (Feed, Item, Enclosure, folder, etc.).   
// -----------------------------------------------------------------------------
//
void CPacked::AddAttributeL(TInt aAttribute, TInt aValue)
    {
    TBuf<25> buff;
    
    buff.AppendNum(aValue);
    AddAttributeL(aAttribute, buff);
    }
    
    
// -----------------------------------------------------------------------------
// CPacked::InsertTokenL
//
// Insert a token.   
// -----------------------------------------------------------------------------
//
void CPacked::InsertTokenL(TUint aToken)
    {
    // If need be re-alloc the token array.
    if (iTokenArrayLength == iTokenArrayMaxLength)
        {
        iTokenArray = static_cast<TUint*>(User::ReAllocL(iTokenArray, sizeof(TUint) * 
                (iTokenArrayMaxLength + KTokenArrayInc)));
                
        iTokenArrayMaxLength += KTokenArrayInc;
        }
        
    // Append the token.
    iTokenArray[iTokenArrayLength++] = aToken;
    }


// -----------------------------------------------------------------------------
// CPacked::AppendTokenChunkL
//
// Append a chunk of "token" values to the feed.   
// -----------------------------------------------------------------------------
//
void CPacked::AppendTokenChunkL(const TDesC8& aChunk)
    {
    if (aChunk.Length() == 0)
        {
        return;
        }
        
    TInt          tokenLength = aChunk.Size() / sizeof(TUint);
    const TUint*  tokens = (const TUint*) aChunk.Ptr();
    
    // If need be re-alloc the token array.
    if ((iTokenArrayLength + tokenLength) >= iTokenArrayMaxLength)
        {
        TInt inc = tokenLength; 
        
        if (KTokenArrayInc > tokenLength)
            {
            inc = KTokenArrayInc;
            }
            
        iTokenArray = static_cast<TUint*>(User::ReAllocL(iTokenArray, sizeof(TUint) * 
                (iTokenArrayMaxLength + inc)));
                
        iTokenArrayMaxLength += inc;
        }
        
    // Append the tokens.
    for (TInt i = 0; i < tokenLength; i++)
        {
        iTokenArray[iTokenArrayLength++] = tokens[i];
        }
    }
        

// -----------------------------------------------------------------------------
// CPacked::AppendStringTableChunkL
//
// Append a chunk of "string-table" values to the feed.   
// -----------------------------------------------------------------------------
//
void CPacked::AppendStringTableChunkL(const TDesC8& aChunk)
    {
    if (aChunk.Length() == 0)
        {
        return;
        }
        
    TPtrC buf((const TUint16 *) aChunk.Ptr(), aChunk.Size() / sizeof(TUint16));
    
    // If need be re-alloc the string table.
    if ((iStringTable->Length() + buf.Length()) >= iStringTable->Des().MaxLength())
        {
        TInt inc = buf.Length(); 
        
        if (KStringTableInc > buf.Length())
            {
            inc = KStringTableInc;
            }

        iStringTable = iStringTable->ReAllocL(iStringTable->Des().MaxLength() + 
                inc);
        }

    // Add the value to the string table.
    iStringTable->Des().Append(buf);    
    }
    

// -----------------------------------------------------------------------------
// CPacked::Trim
//
// Removes any temp memory used while appending chunks.   
// -----------------------------------------------------------------------------
//
void CPacked::Trim()
    {
    //  Trim the string table.
    if (iStringTable->Length() < iStringTable->Des().MaxLength())
        {
        TRAP_IGNORE(iStringTable = iStringTable->ReAllocL(iStringTable->Length()));
        }

    //  Trim the string table.
    if (iTokenArrayLength < iTokenArrayMaxLength)
        {
        TRAP_IGNORE(iTokenArray = static_cast<TUint*>(User::ReAllocL(iTokenArray, 
                sizeof(TUint) * iTokenArrayLength)));
        }
    }
    
    
// -----------------------------------------------------------------------------
// CPacked::HasNextToken
//
// Determine if there is a next token.   
// -----------------------------------------------------------------------------
//
TBool CPacked::HasNextToken() const
    {
    return (iNextToken < iTokenArrayLength);
    }
    
    
// -----------------------------------------------------------------------------
// CPacked::NextToken
//
// Returns the next token.   
// -----------------------------------------------------------------------------
//
TUint CPacked::NextToken() const
    {
    // TODO: Panic if iNextToken >= iTokenArrayLength.
    
    return iTokenArray[const_cast<CPacked*>(this)->iNextToken++];
    }
    

// -----------------------------------------------------------------------------
// CPacked::NextToken
//
// Resets back to the first token.   
// -----------------------------------------------------------------------------
//
void CPacked::Reset() const
    {
    const_cast<CPacked*>(this)->iNextToken = 0;
    }


// -----------------------------------------------------------------------------
// CPacked::ExtractAttributeValue
//
// Upon completion aValue wraps the current attribute value.
// This method must only be called when the call to NextToken
// returns EPackedTokenAttribute.   
// -----------------------------------------------------------------------------
//
void CPacked::ExtractAttributeValue(TUint& aAttribute, TPtrC& aValue) const
    {
    TUint  offset;
    TUint  length;
    
    // TODO: Panic if iTokenArray[iNextToken] != EPackedTokenAttribute.
    
    aAttribute = NextToken();
    offset = NextToken();
    length = NextToken();
    
    if(iStringTable->Length() >= (length + offset))
    	{
    	aValue.Set(iStringTable->Mid(offset, length));
    	}
    else
    	{
    	aValue.Set(KNullDesC);	
    	}
    
    }