/*
* 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 "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:  Detailed entry implementation.
*
*/

// INCLUDE FILES
#include <E32Base.h>
#include <S32Strm.h>
#include "CPEngDetailedResultEntry.h"

//DATA TYPES

/**
 * Stream content indication.
 */
enum TPEngStreamContent
    {
    EPEngNullField = -1,    //Field isn't defined in stream (it is NULL)
    EPEngHasField = 1       //Field is defined in stream
    };


// ============================ MEMBER FUNCTIONS ===============================
// -----------------------------------------------------------------------------
// CPEngDetailedResultEntry::NewLC()
// Two-phased constructor.
// -----------------------------------------------------------------------------
//
CPEngDetailedResultEntry* CPEngDetailedResultEntry::NewLC( TInt aOperationID,
                                                           TInt aDetErr,
                                                           const TUint32* aAttribID,
                                                           const TDesC* aPresID,
                                                           const TDesC* aContactListID,
                                                           const TDesC* aDescription  )
    {
    CPEngDetailedResultEntry* self = new ( ELeave ) CPEngDetailedResultEntry();
    CleanupStack::PushL( self );
    self->ConstructL( aOperationID,
                      aDetErr,
                      aAttribID,
                      aPresID,
                      aContactListID,
                      aDescription );
    return self;
    }


// -----------------------------------------------------------------------------
// CPEngDetailedResultEntry::NewLC()
// Two-phased constructor.
// -----------------------------------------------------------------------------
//
CPEngDetailedResultEntry* CPEngDetailedResultEntry::NewLC( RReadStream& aStream )
    {
    CPEngDetailedResultEntry* self = new ( ELeave ) CPEngDetailedResultEntry();
    CleanupStack::PushL( self );
    self->InternalizeL( aStream );
    return self;
    }



// -----------------------------------------------------------------------------
// CPEngDetailedResultEntry::NewLC()
// Two-phased constructor.
// -----------------------------------------------------------------------------
//
CPEngDetailedResultEntry* CPEngDetailedResultEntry::NewLC( const CPEngDetailedResultEntry& aEntry )
    {
    CPEngDetailedResultEntry* self = new ( ELeave ) CPEngDetailedResultEntry();
    CleanupStack::PushL( self );
    self->ConstructL( aEntry );
    return self;
    }


// Destructor
CPEngDetailedResultEntry::~CPEngDetailedResultEntry()
    {
    delete iAttribID;
    delete iPresID;
    delete iContactListID;
    delete iDescription;
    }



// -----------------------------------------------------------------------------
// CPEngDetailedResultEntry::CPEngDetailedResultEntry
// C++ default constructor can NOT contain any code, that
// might leave.
// -----------------------------------------------------------------------------
//
CPEngDetailedResultEntry::CPEngDetailedResultEntry()
    {
    }


// -----------------------------------------------------------------------------
// CPEngDetailedResultEntry::ConstructL()
// -----------------------------------------------------------------------------
//
void CPEngDetailedResultEntry::ConstructL( TInt aOperationID,
                                           TInt aDetErr,
                                           const TUint32* aAttribID,
                                           const TDesC* aPresID,
                                           const TDesC* aContactListID,
                                           const TDesC* aDescription  )
    {
    iOperationID = aOperationID;
    iDetErr = aDetErr;

    if ( aAttribID )
        {
        iAttribID = new ( ELeave ) TUint32( *aAttribID );
        }

    if ( aPresID )
        {
        iPresID = aPresID->AllocL();
        }

    if ( aContactListID )
        {
        iContactListID  = aContactListID->AllocL();
        }

    if ( aDescription )
        {
        iDescription = aDescription->AllocL();
        }
    }



// -----------------------------------------------------------------------------
// CPEngDetailedResultEntry::ConstructL()
// -----------------------------------------------------------------------------
//
void CPEngDetailedResultEntry::ConstructL( const CPEngDetailedResultEntry& aEntry )
    {
    iOperationID = aEntry.iOperationID;
    iDetErr = aEntry.iDetErr;

    if ( aEntry.iAttribID )
        {
        iAttribID = new ( ELeave ) TUint32( *aEntry.iAttribID );
        }

    if ( aEntry.iPresID )
        {
        iPresID = aEntry.iPresID->AllocL();
        }

    if ( aEntry.iContactListID )
        {
        iContactListID = aEntry.iContactListID->AllocL();
        }

    if ( aEntry.iDescription )
        {
        iDescription = aEntry.iDescription->AllocL();
        }
    }




// -----------------------------------------------------------------------------
// CPEngDetailedResultEntry::Operation()
// -----------------------------------------------------------------------------
//
TInt CPEngDetailedResultEntry::Operation() const
    {
    return iOperationID;
    }


// -----------------------------------------------------------------------------
// CPEngDetailedResultEntry::Error()
// -----------------------------------------------------------------------------
//
TInt CPEngDetailedResultEntry::Error() const
    {
    return iDetErr;
    }


// -----------------------------------------------------------------------------
// CPEngDetailedResultEntry::GetDetailedDesc()
// -----------------------------------------------------------------------------
//
TInt CPEngDetailedResultEntry::GetDetailedDesc( TPtrC& aDescriptionText,
                                                TPEngDetailedResultDescriptionText2 aDescriptionID ) const
    {
    switch ( aDescriptionID )
        {
        case EPEngDTPresenceID:
            {
            return DoReturnBuffer( iPresID, aDescriptionText );
            }

        case EPEngDTContactListID:
            {
            return DoReturnBuffer( iContactListID, aDescriptionText );
            }

        case EPEngDTErrorDescription:
            {
            return DoReturnBuffer( iDescription, aDescriptionText );
            }
        }

    return DoReturnBuffer( NULL, aDescriptionText );
    }


// -----------------------------------------------------------------------------
// CPEngDetailedResultEntry::GetDetailedInt()
// -----------------------------------------------------------------------------
//
TInt CPEngDetailedResultEntry::GetDetailedInt( TUint32& aDescriptionInt,
                                               TPEngDetailedResultDescriptionInteger2 aDescriptionID ) const
    {
    switch ( aDescriptionID )
        {
        case EPEngDIAttributeID:
            {
            return DoReturnInteger( iAttribID, aDescriptionInt );
            }
        }

    return DoReturnInteger( NULL, aDescriptionInt );
    }


// -----------------------------------------------------------------------------
// CPEngDetailedResultEntry::EntryExtension()
// -----------------------------------------------------------------------------
//
MPEngDetailedResultEntryExtension2* CPEngDetailedResultEntry::EntryExtension()
    {
    return NULL;
    }


// -----------------------------------------------------------------------------
// CPEngDetailedResultEntry::InternalizeL()
// -----------------------------------------------------------------------------
//
void CPEngDetailedResultEntry::InternalizeL( RReadStream& aStream )
    {
    iOperationID = aStream.ReadInt32L();
    iDetErr = aStream.ReadInt32L();

    DoInternalizeIntegerOrNullL( iAttribID, aStream );
    DoInternalizeBufferOrNullL( iPresID, aStream );
    DoInternalizeBufferOrNullL( iContactListID, aStream );
    DoInternalizeBufferOrNullL( iDescription, aStream );
    }



// -----------------------------------------------------------------------------
// CPEngDetailedResultEntry::ExternalizeL()
// -----------------------------------------------------------------------------
//
void CPEngDetailedResultEntry::ExternalizeL( RWriteStream& aStream ) const
    {
    aStream.WriteInt32L( iOperationID );
    aStream.WriteInt32L( iDetErr );

    DoExternalizeIntegerOrNullL( iAttribID, aStream );
    DoExternalizeBufferOrNullL( iPresID, aStream );
    DoExternalizeBufferOrNullL( iContactListID, aStream );
    DoExternalizeBufferOrNullL( iDescription, aStream );
    }



// -----------------------------------------------------------------------------
// CPEngDetailedResultEntry::ExternalizeSize()
// -----------------------------------------------------------------------------
//
TInt CPEngDetailedResultEntry::ExternalizeSize() const
    {
    TInt size = 8; //operation 4 bytes
    //error code 4 bytes

    size += DoIntegerExternalizeSizeInBytes( iAttribID );
    size += DoBufferExternalizeSizeInBytes( iPresID );
    size += DoBufferExternalizeSizeInBytes( iContactListID );
    size += DoBufferExternalizeSizeInBytes( iDescription );

    return size;
    }



// -----------------------------------------------------------------------------
// CPEngDetailedResultEntry::DoReturnBuffer()
// Static helper.
// -----------------------------------------------------------------------------
//
TInt CPEngDetailedResultEntry::DoReturnBuffer( const HBufC* const & aPtr,
                                               TPtrC16& aBuffer )
    {
    if ( aPtr )
        {
        aBuffer.Set( *aPtr );
        return KErrNone;
        }

    aBuffer.Set( NULL, 0 );
    return KErrNotFound;
    }


// -----------------------------------------------------------------------------
// CPEngDetailedResultEntry::DoReturnInteger()
// Static helper.
// -----------------------------------------------------------------------------
//
TInt CPEngDetailedResultEntry::DoReturnInteger( const TUint32* aPtr,
                                                TUint32& aInteger )
    {
    if ( aPtr )
        {
        aInteger = *aPtr;
        return KErrNone;
        }

    aInteger = 0;
    return KErrNotFound;
    }



// -----------------------------------------------------------------------------
// CPEngDetailedResultEntry::DoExternalizeBufferOrNullL()
// Static helper.
// -----------------------------------------------------------------------------
//
void CPEngDetailedResultEntry::DoExternalizeBufferOrNullL( const HBufC* aBuffer,
                                                           RWriteStream& aStream )
    {
    if ( aBuffer )
        {
        aStream.WriteInt8L( EPEngHasField );
        aStream << TCardinality( aBuffer->Length() );  //pack the length bits
        aStream.WriteL( *aBuffer );
        }
    else
        {
        aStream.WriteInt8L( EPEngNullField );
        }
    }


// -----------------------------------------------------------------------------
// CPEngDetailedResultEntry::DoExternalizeIntegerOrNullL()
// Static helper.
// -----------------------------------------------------------------------------
//
void CPEngDetailedResultEntry::DoExternalizeIntegerOrNullL( TUint32* aInteger,
                                                            RWriteStream& aStream )
    {
    if ( aInteger )
        {
        aStream.WriteInt8L( EPEngHasField );
        aStream.WriteUint32L( *aInteger );
        }
    else
        {
        aStream.WriteInt8L( EPEngNullField );
        }
    }


// -----------------------------------------------------------------------------
// CPEngDetailedResultEntry::DoInternalizeBufferOrNullL()
// Static helper.
// -----------------------------------------------------------------------------
//
void CPEngDetailedResultEntry::DoInternalizeBufferOrNullL( HBufC*& aBuffer,
                                                           RReadStream& aStream )
    {
    HBufC* buffer = NULL;

    TPEngStreamContent content = static_cast< TPEngStreamContent >( aStream.ReadInt8L() );

    if ( content == EPEngHasField )
        {
        TCardinality c;
        aStream >> c;   //read the length bits
        TInt length = c;

        buffer = HBufC::NewLC( length );
        TPtr ptr( buffer->Des() );
        aStream.ReadL( ptr, length );
        CleanupStack::Pop(); //buffer
        }

    delete aBuffer;
    aBuffer = buffer;
    }


// -----------------------------------------------------------------------------
// CPEngDetailedResultEntry::DoInternalizeIntegerOrNullL()
// Static helper.
// -----------------------------------------------------------------------------
//
void CPEngDetailedResultEntry::DoInternalizeIntegerOrNullL( TUint32*& aInteger,
                                                            RReadStream& aStream )
    {
    TUint32* integer = NULL;

    TPEngStreamContent content = static_cast< TPEngStreamContent >( aStream.ReadInt8L() );

    if ( content == EPEngHasField )
        {
        TUint32 value = aStream.ReadUint32L();
        integer = new ( ELeave ) TUint32( value );
        }

    delete aInteger;
    aInteger = integer;
    }


// -----------------------------------------------------------------------------
// CPEngDetailedResultEntry::DoBufferExternalizeSizeInBytes()
// Static helper.
// -----------------------------------------------------------------------------
//
TInt CPEngDetailedResultEntry::DoBufferExternalizeSizeInBytes( const HBufC* aBuffer )
    {
    TInt size = 1; // 1 byte for content mark

    if ( aBuffer )
        {
        size = size + aBuffer->Size() + 4; // max four bytes for buffer length
        }

    return size;
    }


// -----------------------------------------------------------------------------
// CPEngDetailedResultEntry::DoIntegerExternalizeSizeInBytes()
// Static helper.
// -----------------------------------------------------------------------------
//
TInt CPEngDetailedResultEntry::DoIntegerExternalizeSizeInBytes( TUint32* aInteger )
    {
    TInt size = 1; // 1 byte for content mark

    if ( aInteger )
        {
        size = size + 4; // four bytes for integer
        }

    return size;
    }



//  End of File