/*
* Copyright (c) 2007 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:  Class definition of CDiagResultDetailBasic
*
*/


// CLASS DECLARATION
#include "diagresultdetailbasicitem.h"  // CDiagResultDetailBasicItem

// SYSTEM INCLUDE FILES
#include <DiagResultDetailBasic.h>
#include <s32mem.h>                     // RBufReadStream / RBufWriteStream

// USER INCLUDE FILES
#include "diagpluginbase.pan"           // panic codes


// CONSTANTS
static const TInt KDiagResultDetailBasicBufferSize = 1024;

// ======== LOCAL FUNCTIONS ========
// ---------------------------------------------------------------------------
// Compares two items by order field id
// ---------------------------------------------------------------------------
//
static TInt CompareItemById( const CDiagResultDetailBasicItem& aFirst,
                             const CDiagResultDetailBasicItem& aSecond )
    {
    return aFirst.FieldId() - aSecond.FieldId();
    }

// ======== MEMBER FUNCTIONS ========
// ---------------------------------------------------------------------------
// CDiagResultDetailBasic::CDiagResultDetailBasic()
// ---------------------------------------------------------------------------
//
EXPORT_C CDiagResultDetailBasic::CDiagResultDetailBasic( 
        CDiagResultsDatabaseItem::TResult aResult )
    :   iResult( aResult )
    {
    }

// ---------------------------------------------------------------------------
// CDiagResultDetailBasic::~CDiagResultDetailBasic()
// ---------------------------------------------------------------------------
//
EXPORT_C CDiagResultDetailBasic::~CDiagResultDetailBasic()
    {
    iFields.ResetAndDestroy();
    iFields.Close();
    }

// ---------------------------------------------------------------------------
// CDiagResultDetailBasic::BaseConstructL
// ---------------------------------------------------------------------------
//
EXPORT_C void CDiagResultDetailBasic::BaseConstructL( RReadStream& aReadStream )
    {
    InternalizeL( aReadStream );
    }

// ---------------------------------------------------------------------------
// CDiagResultDetailBasic::BaseConstructL
// ---------------------------------------------------------------------------
//
EXPORT_C void CDiagResultDetailBasic::BaseConstructL( const CBufFlat& aBuf )
    {
    // if empty buffer, do nothing.
    if ( aBuf.Size() == 0 )
        {
        return;
        }

    RBufReadStream readStream;

    readStream.Open( aBuf, 0 );

    InternalizeL( readStream );

    readStream.Close();
    }

// ---------------------------------------------------------------------------
// CDiagResultDetailBasic::SetResult()
// ---------------------------------------------------------------------------
//
EXPORT_C void CDiagResultDetailBasic::SetResult( 
        CDiagResultsDatabaseItem::TResult aResult )
    {
    iResult = aResult;
    }

// ---------------------------------------------------------------------------
// CDiagResultDetailBasic::SetValueL
// ---------------------------------------------------------------------------
//
EXPORT_C void CDiagResultDetailBasic::SetValueL( TInt aFieldId,
                                                 const TDesC8& aFieldName,
                                                 TInt aValue )
    {
    CDiagResultDetailBasicItem* newItem = CDiagResultDetailBasicItem::NewL( 
        aFieldId,
        aFieldName,
        aValue );

    // no need to call clean up stack since ownership is
    // transferred.
    SetItemL( newItem );
    newItem = NULL;
    }


// ---------------------------------------------------------------------------
// CDiagResultDetailBasic::SetValueL
// ---------------------------------------------------------------------------
//
EXPORT_C void CDiagResultDetailBasic::SetValueL( TInt aFieldId,
                                                 const TDesC8& aFieldName,
                                                 const TDesC8& aValue )
                
    {
    CDiagResultDetailBasicItem* newItem = CDiagResultDetailBasicItem::NewL( 
        aFieldId,
        aFieldName,
        aValue );
    
    // no need to call clean up stack since ownership is
    // transferred.
    SetItemL( newItem );
    newItem = NULL;
    }


// ---------------------------------------------------------------------------
// CDiagResultDetailBasic::SetValueL
// ---------------------------------------------------------------------------
//
EXPORT_C void CDiagResultDetailBasic::SetValueL( TInt aFieldId,
                                                 const TDesC8& aFieldName,
                                                 const TDesC16& aValue )
                
    {
    CDiagResultDetailBasicItem* newItem = CDiagResultDetailBasicItem::NewL( 
        aFieldId,
        aFieldName,
        aValue );
    
    // no need to call clean up stack since ownership is
    // transferred.
    SetItemL( newItem );
    newItem = NULL;
    }


// ---------------------------------------------------------------------------
// CDiagResultDetailBasic::GetValue
// ---------------------------------------------------------------------------
//
EXPORT_C TInt CDiagResultDetailBasic::GetValue( TInt aFieldId,
                                                TInt& aValue ) const
    {
    TInt itemIndex = FindItem( aFieldId );

    if ( itemIndex < 0 )
        {
        // item not found
        return KErrNotFound;
        }

    return iFields[itemIndex]->GetValue( aValue );
    }

// ---------------------------------------------------------------------------
// CDiagResultDetailBasic::GetValueL
// ---------------------------------------------------------------------------
//
EXPORT_C TInt CDiagResultDetailBasic::GetValue( TInt aFieldId,
                                                TPtrC8& aValue ) const
    {
    TInt itemIndex = FindItem( aFieldId );

    if ( itemIndex < 0 )
        {
        // item not found
        return KErrNotFound;
        }
    
    return iFields[itemIndex]->GetValue( aValue );
    }

// ---------------------------------------------------------------------------
// CDiagResultDetailBasic::GetValueL
// ---------------------------------------------------------------------------
//
EXPORT_C TInt CDiagResultDetailBasic::GetValue( TInt aFieldId,
                                                TPtrC16& aValue ) const
    {
    TInt itemIndex = FindItem( aFieldId );

    if ( itemIndex < 0 )
        {
        // item not found
        return KErrNotFound;
        }
    
    return iFields[itemIndex]->GetValue( aValue );
    }

// ---------------------------------------------------------------------------
// CDiagResultDetailBasic::InternalizeL
// ---------------------------------------------------------------------------
//
void CDiagResultDetailBasic::InternalizeL( RReadStream& aReadStream )
    {
    iFields.ResetAndDestroy();

    // Make sure that we are dealing with the correct version of data format.
    TUint32 version = aReadStream.ReadUint32L();

    if ( version != ( TUint32 )KDiagResultDetailBasicVersion )
        {
        User::Leave( KErrCorrupt );
        }

    // Read the number of items in the list.
    TUint32 count = aReadStream.ReadUint32L();

    // Read each item
    for ( TUint i = 0; i < count; i++ )
        {
        CDiagResultDetailBasicItem* newItem = 
            CDiagResultDetailBasicItem::NewL( aReadStream );

        SetItemL( newItem ); // ownership passed.
        }
    }


// ---------------------------------------------------------------------------
// CDiagResultDetailBasic::ExternalizeL
// ---------------------------------------------------------------------------
//
EXPORT_C void CDiagResultDetailBasic::ExternalizeL(
        RWriteStream& aWriteStream ) const
    {
    // write only if there is something to write..
    if ( iFields.Count() > 0 )
        {
        aWriteStream.WriteUint32L( KDiagResultDetailBasicVersion );
        aWriteStream.WriteUint32L( iFields.Count() );

        for ( TInt i = 0; i < iFields.Count(); i++ )
            {
            iFields[i]->ExternalizeL( aWriteStream );
            }
        }
    }


// ---------------------------------------------------------------------------
// CDiagResultDetailBasic::ExternalizeToBufferL
// ---------------------------------------------------------------------------
//
EXPORT_C CBufFlat* CDiagResultDetailBasic::ExternalizeToBufferL() const
    {
    CBufFlat* buffer = CBufFlat::NewL( KDiagResultDetailBasicBufferSize );

    CleanupStack::PushL( buffer );

    RBufWriteStream bufStream;
    bufStream.Open( *buffer );

    ExternalizeL( bufStream );

    bufStream.CommitL();
    bufStream.Close();

    CleanupStack::Pop( buffer );

    return buffer;
    }


// ---------------------------------------------------------------------------
// CDiagResultDetailBasic::GetSupportedOutput
// ---------------------------------------------------------------------------
//
EXPORT_C void CDiagResultDetailBasic::GetSupportedOutput(
        RArray<TOutputFormat>& /* aOutputList */ ) const
    {
    }

// ---------------------------------------------------------------------------
// CDiagResultDetailBasic::IsOutputSupported
// ---------------------------------------------------------------------------
//
EXPORT_C TBool CDiagResultDetailBasic::IsOutputSupported(
        MDiagResultDetail::TOutputFormat /* aOutputFormat */ ) const
    {
    return EFalse;
    }

// ---------------------------------------------------------------------------
// CDiagResultDetailBasic::GetOutputL
// ---------------------------------------------------------------------------
//
EXPORT_C void CDiagResultDetailBasic::GetOutputL(
        MDiagResultDetail::TOutputFormat /* aOutputFormat */,
        RBuf& /* aBuffer */ ) const
    {
    User::Leave( KErrNotSupported );
    }

// ---------------------------------------------------------------------------
// CDiagResultDetailBasic::CreateIconL
// ---------------------------------------------------------------------------
//
EXPORT_C CGulIcon* CDiagResultDetailBasic::CreateIconL() const
    {
    User::Leave( KErrNotSupported );
    return NULL;
    }

// ---------------------------------------------------------------------------
// CDiagResultDetailBasic::SetItemL
// ---------------------------------------------------------------------------
//
void CDiagResultDetailBasic::SetItemL( CDiagResultDetailBasicItem* aNewItem )
    {
    // Check if an item with same field id already exists.
    TInt itemIndex = FindItem( aNewItem->FieldId() );
    
    if ( itemIndex >= 0 )
        {
        // duplicate found. Remove old one.
        CDiagResultDetailBasicItem* oldItem = iFields[itemIndex];
        iFields.Remove( itemIndex );
        delete oldItem;
        }

    CleanupStack::PushL( aNewItem );
    TLinearOrder<CDiagResultDetailBasicItem> order( *CompareItemById );

    // if a duplicate item is still found, leave.
    User::LeaveIfError( iFields.InsertInOrder( aNewItem, order ) );
    CleanupStack::Pop( aNewItem );
    }

// ---------------------------------------------------------------------------
// CDiagResultDetailBasic::FindItem
// ---------------------------------------------------------------------------
//
TInt CDiagResultDetailBasic::FindItem( TInt aFieldId ) const
    {
    for ( TInt i = 0; i < iFields.Count(); i++ )
        {
        if ( iFields[i]->FieldId() == aFieldId )
            {
            return i;
            }
        }
    return -1;
    }

// End of File