/*

* Copyright (c) 2004 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: Object handler implementation

*

*/

//  INCLUDES

#include    "IMPSSAPObjectHandler.h"

#include    <s32mem.h>

// size to use if the source object size is 0 in copy

const TInt KTargetObjectSize = 200;

// ================= LOCAL FUNCTIONS =======================

// -----------------------------------------------------------------------------

// ImplementationVersionsLeft()

// -----------------------------------------------------------------------------

//

TBool ImplementationVersionsLeft( const MIMPSSapObject& aObj, TInt aVersionID )

    {

    return ( aVersionID < aObj.ObjectVersion() );

    }

// -----------------------------------------------------------------------------

// WriteZeroVersionMarkL()

// -----------------------------------------------------------------------------

//

TStreamPos WriteZeroExtensionMarkL( RWriteStream& aStream )

    {

    //Write extension mark & return its position

    TStreamPos extMarkPos = aStream.Sink()->TellL( MStreamBuf::EWrite );

    aStream.WriteInt32L( 0 ); //Zero length extension

    return extMarkPos;

    }

// -----------------------------------------------------------------------------

// PatchVersionMarkL()

// -----------------------------------------------------------------------------

//

void PatchExtensionMarkL( const TStreamPos& aExtMarkPos,

                          RWriteStream& aStream,

                          TInt aExtensionLength )

    {

    aStream.Sink()->SeekL( MStreamBuf::EWrite, aExtMarkPos );

    aStream.WriteInt32L( aExtensionLength );

    }

// -----------------------------------------------------------------------------

// ReadExtensionMarkL()

// -----------------------------------------------------------------------------

//

TInt ReadExtensionMarkL( RReadStream& aStream )

    {

    return aStream.ReadInt32L();

    }

// -----------------------------------------------------------------------------

// ExternalizeVersionL()

// -----------------------------------------------------------------------------

//

TInt ExternalizeVersionL( const MIMPSSapObject& aObj, TInt aVersionID, RWriteStream& aStream )

    {

    TStreamPos versionStartPos = aStream.Sink()->TellL( MStreamBuf::EWrite );

    //Write version data & zero extension mark

    aObj.ExternalizeVersionDataL( aVersionID, aStream );

    TStreamPos extMarkPos = WriteZeroExtensionMarkL( aStream );

    //Calculate version length

    TInt extensionLength = 0;

    TInt versionLenght = aStream.Sink()->TellL( MStreamBuf::EWrite ) -

                         versionStartPos;

    //Recurse to next version if needed & patch

    //the extension mark to contain cumulative length

    //all data stored during recursion

    if ( ImplementationVersionsLeft( aObj, aVersionID ) )

        {

        extensionLength = ExternalizeVersionL( aObj, ++aVersionID, aStream );

        PatchExtensionMarkL( extMarkPos, aStream, extensionLength );

        }

    return versionLenght + extensionLength;

    }

// -----------------------------------------------------------------------------

// InternalizeVersionL()

// -----------------------------------------------------------------------------

//

void InternalizeVersionL( MIMPSSapObject& aObj,

                          TInt aVersionID,

                          RReadStream& aStream )

    {

    //Three cases:

    // 1. Stream has same versions than implementaion.

    // 2. Stream is missing data version compared to the implementation.

    // 3. Stream has higher data version than implementation supports.

    aObj.InternalizeVersionDataL( aVersionID, aStream );

    TInt extensionLength = ReadExtensionMarkL( aStream );

    //Proceed if stream has subsequent extensions

    if ( extensionLength > 0 )

        {

        if ( ImplementationVersionsLeft( aObj, aVersionID ) )

            {

            //Current implementation is capable to read more versions

            //==> recurse to next one

            InternalizeVersionL( aObj, ++aVersionID, aStream );

            }

        else

            {

            //Implementation isn't capable to read more version

            //==> consume remaining extension blocks

            aStream.ReadL( extensionLength );

            }

        }

    }

// ================= MEMBER FUNCTIONS =======================

// -----------------------------------------------------------------------------

// IMPSSAPObjectHandler::DataSize()

// -----------------------------------------------------------------------------

//

TInt IMPSSAPObjectHandler::DataSize( const MIMPSSapObject& aObj )

    {

    // Object id: 4 bytes

    // Object version: 4 bytes

    TInt dataSize = 8;

    //For each version: version extension mark, 4 bytes

    TInt versionCount = aObj.ObjectVersion() - KIMPSSapObjVersionInitial;

    dataSize += ( versionCount * 4 );

    //and actual data size

    dataSize += aObj.DataSize();

    return dataSize;

    }

// -----------------------------------------------------------------------------

// IMPSSAPObjectHandler::ExternalizeL()

// -----------------------------------------------------------------------------

//

void IMPSSAPObjectHandler::ExternalizeL( const MIMPSSapObject& aObj,

                                         RWriteStream& aStream )

    {

    //Externalize object ID's

    aStream.WriteInt32L( aObj.ObjectID() );

    aStream.WriteInt32L( aObj.ObjectVersion() );

    TStreamPos pos = aStream.Sink()->TellL( MStreamBuf::EWrite );

    //Recursively go through all data versions

    TInt length = ExternalizeVersionL( aObj, KIMPSSapObjVersionInitial, aStream );

    //And correct the stream write point

    aStream.Sink()->SeekL( MStreamBuf::EWrite, ( pos + length ) );

    }

// -----------------------------------------------------------------------------

// IMPSSAPObjectHandler::InternalizeL()

// -----------------------------------------------------------------------------

//

void IMPSSAPObjectHandler::InternalizeL( MIMPSSapObject& aObj, RReadStream& aStream )

    {

    aObj.Reset();

    //Object ID

    TIMPSSapObjectID id = static_cast<TIMPSSapObjectID> ( aStream.ReadInt32L() );

    if ( id != aObj.ObjectID() )

        {

        User::Leave( KErrCorrupt );

        }

    //Object version

    aStream.ReadInt32L();

    //and recursively go through all available version datas

    InternalizeVersionL( aObj, KIMPSSapObjVersionInitial, aStream );

    }

// -----------------------------------------------------------------------------

// IMPSSAPObjectHandler::CopyL()

// -----------------------------------------------------------------------------

//

void IMPSSAPObjectHandler::CopyL( const MIMPSSapObject& aSource, MIMPSSapObject& aTarget )

    {

    //Don't check here object ID's because underlying stream

    //implementations might be capable to convert objects to another

    TInt objectSize = IMPSSAPObjectHandler::DataSize( aSource );

    if ( objectSize == 0 )

        {

        objectSize = KTargetObjectSize;

        }

    CBufSeg* buffer = CBufSeg::NewL( objectSize );

    CleanupStack::PushL( buffer );

    RBufWriteStream wstream;

    wstream.Open( *buffer );

    CleanupClosePushL( wstream );

    IMPSSAPObjectHandler::ExternalizeL( aSource, wstream );

    CleanupStack::PopAndDestroy(); //wstream

    RBufReadStream rstream;

    rstream.Open( *buffer );

    CleanupClosePushL( rstream );

    IMPSSAPObjectHandler::InternalizeL( aTarget, rstream );

    CleanupStack::PopAndDestroy( 2 ); //rstream, buffer

    }

//  End of File