/*
* Copyright (c) 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:
*
*/

#include "MemSpyDriverStreamWriter.h"

// User includes
#include "MemSpyDriverUtils.h"
#include "MemSpyDriverXferBuffer.h"



RMemSpyMemStreamWriter::RMemSpyMemStreamWriter()
:   iBuffer( NULL ), iCurrent( NULL ), iMax( 0 ), iMark( NULL ), iCommitted( 0 )
    {
    }


RMemSpyMemStreamWriter::RMemSpyMemStreamWriter( DMemSpyDriverXferBuffer& aBuffer )
:   iBuffer( &aBuffer ), iMark( NULL ), iCommitted( 0 )
    {
    iCurrent = iBuffer->Ptr();
    iMax = iCurrent + iBuffer->Size();
    TRACE( Kern::Printf("RMemSpyMemStreamWriter::RMemSpyMemStreamWriter() - current: 0x%08x, max: 0x%08x, size: %d", iCurrent, iMax, iBuffer->Size() ) );
    }


void RMemSpyMemStreamWriter::Close()
    {
    iBuffer = NULL;
    iMark = NULL;
    }


TInt RMemSpyMemStreamWriter::WriteAndClose( TDes8* aDestinationPointer )
    {
    __ASSERT_ALWAYS( IsOpen(), MemSpyDriverUtils::Fault( __LINE__ ) );
    //
    const TInt ret = iBuffer->WriteToClient( aDestinationPointer, iCommitted );
    Close();
    //
    return ret;
    }


TInt32* RMemSpyMemStreamWriter::WriteInt32( TInt32 aValue )
    {
    TInt32* ret = NULL;
    //
    __ASSERT_ALWAYS( IsOpen(), MemSpyDriverUtils::Fault( __LINE__ ) );
    if  ( !IsFull() )
        {
        ret = (TInt32*) iCurrent;
        *ret = aValue;
        IncrementPos( sizeof( TInt32 ) );
        }
    else
        {
        TRACE( Kern::Printf( "RMemSpyMemStreamWriter::WriteInt32() - asked to write: 0x%08x from fn: 0x%08x BUT AM FULL", aValue, __return_address() ) );
        }
    //
    return ret;
    }


TUint32* RMemSpyMemStreamWriter::WriteUint32( TUint32 aValue )
    {
    TUint32* ret = NULL;
    //
    __ASSERT_ALWAYS( IsOpen(), MemSpyDriverUtils::Fault( __LINE__ ) );
    if  ( !IsFull() )
        {
        ret = (TUint32*) iCurrent;
        *ret = aValue;
        IncrementPos( sizeof( TUint32 ) );
        }
    else
        {
        TRACE( Kern::Printf( "RMemSpyMemStreamWriter::WriteUint32() - asked to write: 0x%08x from fn: 0x%08x BUT AM FULL", aValue, __return_address() ) );
        }
    //
    return ret;
    }


TUint8* RMemSpyMemStreamWriter::Current() const
    {
    __ASSERT_ALWAYS( IsOpen(), MemSpyDriverUtils::Fault( __LINE__ ) );
    return iCurrent;
    }


void RMemSpyMemStreamWriter::Seek( TInt aPosition )
    {
    __ASSERT_ALWAYS( IsOpen(), MemSpyDriverUtils::Fault( __LINE__ ) );
    TUint8* pos = iBuffer->Ptr() + aPosition;
    __ASSERT_ALWAYS( pos < iMax, MemSpyDriverUtils::Fault( __LINE__ ) );
    iCurrent = pos;
    }


TUint32 RMemSpyMemStreamWriter::Remaining() const
    {
    __ASSERT_ALWAYS( IsOpen(), MemSpyDriverUtils::Fault( __LINE__ ) );
    const TUint32 max = reinterpret_cast< TUint32 >( iMax );
    const TUint32 cur = reinterpret_cast< TUint32 >( iCurrent );
    TRACE( Kern::Printf("RMemSpyMemStreamWriter::Remaining() - current: 0x%08x, max: 0x%08x, ret: %d", cur, max, ( max - cur ) ) );
    return ( max - cur );
    }


void RMemSpyMemStreamWriter::MarkSet()
    {
    __ASSERT_ALWAYS( iMark == NULL, MemSpyDriverUtils::Fault( __LINE__ ) );
    iMark = iCurrent;
    }


void RMemSpyMemStreamWriter::MarkResume()
    {
    __ASSERT_ALWAYS( iMark != NULL, MemSpyDriverUtils::Fault( __LINE__ ) );
    iCurrent = iMark;
    iMark = NULL;
    }


TBool RMemSpyMemStreamWriter::IsFull() const
    {
    __ASSERT_ALWAYS( IsOpen(), MemSpyDriverUtils::Fault( __LINE__ ) );
    const TBool ret = ( iCurrent >= iMax );
    return ret;
    }


TBool RMemSpyMemStreamWriter::IsOpen() const
    {
    const TBool ret = ( iBuffer && iCurrent && iMax );
    return ret;
    }


RMemSpyMemStreamWriter& RMemSpyMemStreamWriter::operator=( const RMemSpyMemStreamWriter& aCopy )
    {
    iBuffer = aCopy.iBuffer;
    iMark = aCopy.iMark;
    iCommitted = aCopy.iCommitted;
    iCurrent = aCopy.iCurrent;
    iMax = aCopy.iMax;
    //
    return *this;
    }


void RMemSpyMemStreamWriter::IncrementPos( TInt aAmount )
    {
    __ASSERT_ALWAYS( IsOpen(), MemSpyDriverUtils::Fault( __LINE__ ) );
    if  ( iCurrent + aAmount > iMax )
        {
        Kern::Printf("RMemSpyMemStreamWriter::IncrementPos() - OVERFLOW - current: 0x%08x, max: 0x%08x, aAmount: %d", iCurrent, iMax, aAmount );
        }

    iCurrent += aAmount;
    iCommitted += aAmount;
    }