/*
* Copyright (c) 2005,2006 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:  List class to hold CXnDomList objects.
*
*/



// INCLUDE FILES
#include    "xndomlist.h"
#include    "xndomnode.h"
#include    "xndomattribute.h"
#include    "xndomproperty.h"
#include    "xndompropertyvalue.h"
#include    "xndomstringpool.h"



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

// -----------------------------------------------------------------------------
// CXnDomList::CXnDomList
// C++ parameter constructor can NOT contain any code, that
// might leave.
// -----------------------------------------------------------------------------
//
CXnDomList::CXnDomList( 
    TListType aListType, 
    CXnDomStringPool* aStringPool,
    TInt aGranularity ):
    iListType( aListType ),
    iList( aGranularity ), 
    iStringPool( aStringPool )
    {
    }
// -----------------------------------------------------------------------------
// CXnDomList::ConstructL
// Symbian 2nd phase constructor can leave.
// -----------------------------------------------------------------------------
//
void CXnDomList::ConstructL()
    {
   
    }

// -----------------------------------------------------------------------------
// CXnDomList::NewL
// Two-phased constructor.
// -----------------------------------------------------------------------------
//
CXnDomList* CXnDomList::NewL( 
    TListType aListType, 
    CXnDomStringPool* aStringPool,
    TInt aGranularity)
    {
    CXnDomList* self = 
        new( ELeave ) CXnDomList( aListType, aStringPool,aGranularity );
    
    CleanupStack::PushL( self );
    self->ConstructL();
    CleanupStack::Pop( self );

    return self;
    }
// -----------------------------------------------------------------------------
// CXnDomList::NewL
// Two-phased stream constructor.
// -----------------------------------------------------------------------------
//
CXnDomList* CXnDomList::NewL( 
    RReadStream& aStream, 
    CXnDomStringPool* aStringPool )
    {
    CXnDomList* self = new( ELeave ) CXnDomList( ENodeList, aStringPool );
    
    CleanupStack::PushL( self );
   
    aStream >> *self;
    CleanupStack::Pop( self );

    return self;
    }
    
// Destructor
CXnDomList::~CXnDomList()
    {
    iList.ResetAndDestroy();    
    }

// -----------------------------------------------------------------------------
// CXnDomList::Reset
// -----------------------------------------------------------------------------
//
EXPORT_C void CXnDomList::Reset()
    {
    iList.Reset();
    }
    
// -----------------------------------------------------------------------------
// CXnDomList::AddItemL
// -----------------------------------------------------------------------------
//
EXPORT_C void CXnDomList::AddItemL( MXnDomListItem* aItem )
    {
    iList.AppendL( aItem );
    }
    
// -----------------------------------------------------------------------------
// CXnDomList::AddItemL
// -----------------------------------------------------------------------------
//
EXPORT_C void CXnDomList::AddItemL( MXnDomListItem* aItem, TInt aIndex )
    {
    iList.InsertL( aItem, aIndex );
    }

// -----------------------------------------------------------------------------
// CXnDomList::RemoveItem
// -----------------------------------------------------------------------------
//
EXPORT_C void CXnDomList::RemoveItem( TInt aIndex )
    {
    iList.Remove( aIndex);
    iList.Compress();
    }
// -----------------------------------------------------------------------------
// CXnDomList::DeleteItem
// -----------------------------------------------------------------------------
//
EXPORT_C void CXnDomList::DeleteItem( TInt aIndex )
    {
    delete iList[ aIndex ];
    iList.Remove( aIndex);
    iList.Compress();
    }

// -----------------------------------------------------------------------------
// CXnDomList::RemoveItem
// -----------------------------------------------------------------------------
//
EXPORT_C void CXnDomList::RemoveItem( MXnDomListItem* aItem ) 
    {
    MXnDomListItem* tmp = NULL;
    TInt count( iList.Count() );
    TBool stop( EFalse );
    for ( TInt i=0; i<count && !stop; i++ )    
        {
        tmp = iList[i];
        if ( tmp == aItem )
            {
            iList.Remove( i );
            iList.Compress();
            stop = ETrue;
            }
        }
    }

// -----------------------------------------------------------------------------
// CXnDomList::DeleteItem
// -----------------------------------------------------------------------------
//
EXPORT_C void CXnDomList::DeleteItem( MXnDomListItem* aItem ) 
    {
    MXnDomListItem* tmp = NULL;
    TInt count( iList.Count() );
    TBool stop( EFalse );
    for ( TInt i=0; i<count && !stop ; i++ )    
        {
        tmp = iList[i];
        if ( tmp == aItem )
            {
            delete iList[i];
            iList.Remove( i );
            iList.Compress();
            stop = ETrue;
            }
        }
    }    
// -----------------------------------------------------------------------------
// CXnDomList::Item
// -----------------------------------------------------------------------------
//    
EXPORT_C MXnDomListItem* CXnDomList::Item( TInt aIndex )const
    {
    
    return iList[ aIndex ];
    }    
// -----------------------------------------------------------------------------
// CXnDomList::Length
// -----------------------------------------------------------------------------
//
EXPORT_C TInt CXnDomList::Length() const
    {
   
    return iList.Count();    
    }
// -----------------------------------------------------------------------------
// CXnDomList::First
// -----------------------------------------------------------------------------
//
EXPORT_C MXnDomListItem* CXnDomList::First()
    {
    if ( iList.Count() )
        {
        return iList[ 0 ];
        }
    else
        {
        return NULL;
        }
    }    
    
// -----------------------------------------------------------------------------
// CXnDomList::Last
// -----------------------------------------------------------------------------
//
EXPORT_C MXnDomListItem* CXnDomList::Last()
    {
    TInt count( iList.Count() );
    if ( count )
        {
        return  iList[ count-1 ];
        }
    else
        {
        return NULL;
        }
   
    }    
    

// -----------------------------------------------------------------------------
// CXnDomList::FindByName
// -----------------------------------------------------------------------------
//
EXPORT_C MXnDomListItem* CXnDomList::FindByName( const TDesC8& aName )
    {
    
    if ( iListType == CXnDomList::EPropertyValueList )
        {
        return NULL;
        }
        
    MXnDomListItem* tmp = NULL;
    TInt count( iList.Count() );
    for ( TInt i=0; i<count; i++ )    
        {
        tmp = iList[ i ];
        
        if ( aName.Compare( tmp->Name() ) == 0 )
            {
            return tmp;
            }
        }
    return NULL; 
    }
        
// -----------------------------------------------------------------------------
// CXnDomList::ItemIndex
// -----------------------------------------------------------------------------
//
EXPORT_C TInt CXnDomList::ItemIndex( const MXnDomListItem& aItem ) const
    {
    
    MXnDomListItem* tmp = NULL;
    TInt count( iList.Count() );
    for ( TInt i=0; i<count; i++ )    
        {
        tmp = iList[ i ];
        if ( tmp == &aItem )
            {
            return i;
            }
        }
    return KErrNotFound;   
    }

// -----------------------------------------------------------------------------
// CXnDomList::StringPool
// -----------------------------------------------------------------------------
//        
EXPORT_C CXnDomStringPool* CXnDomList::StringPool() const
    {
    return iStringPool;
    }

// -----------------------------------------------------------------------------
// CXnDomAttribute::SwapStringPoolL
// -----------------------------------------------------------------------------
//
EXPORT_C void CXnDomList::SwapStringPoolL( CXnDomStringPool* aStringPool )
    {
    if( !aStringPool )
        {
        User::Leave( KErrArgument );
        }
    
    iStringPool = aStringPool;
    }

// -----------------------------------------------------------------------------
// CXnDomList::Size
// -----------------------------------------------------------------------------
//
TInt CXnDomList::Size() const
    {
    TInt size = 0;
    
    size += sizeof(TInt8);      //Type
    size += sizeof(TInt32);     //Item count
   
    TInt count( iList.Count() );
    for ( TInt i=0; i<count; i++ )    
        {
        size += iList[ i ]->Size();
        }
    return size;
    }
// -----------------------------------------------------------------------------
// CXnDomList::ExternalizeL
// -----------------------------------------------------------------------------
//
void CXnDomList::ExternalizeL( RWriteStream& aStream ) const
    {
    aStream.WriteInt8L( iListType );
    
   
    TInt count( iList.Count() );
    aStream.WriteInt32L( count );
    
    
    for ( TInt i=0; i<count; i++ )    
        {
        aStream << *iList[ i ];
        }    
    }

// -----------------------------------------------------------------------------
// CXnDomList::InternalizeL
// -----------------------------------------------------------------------------
//
void CXnDomList::InternalizeL( RReadStream& aStream )
    {
    iListType = static_cast<CXnDomList::TListType>( aStream.ReadInt8L() );    
    
    TInt count ( aStream.ReadInt32L() );
    for ( TInt i=0; i<count; i++ )
        {
        MXnDomListItem* item = NULL;
        
        switch( iListType )
        	{
        	case CXnDomList::ENodeList:
    			{
    			item = CXnDomNode::NewL( aStream, iStringPool );
    			}
        	break;
        	
        	case CXnDomList::EAttributeList:
    			{
    			item = CXnDomAttribute::NewL( aStream, iStringPool );
    			}
        	break;
        	case CXnDomList::EPropertyList:
        		{
        		item = CXnDomProperty::NewL( aStream, iStringPool );
        		}
        	break;
        	case CXnDomList::EPropertyValueList:
        		{
        		item = CXnDomPropertyValue::NewL( aStream, iStringPool );
        		}
        	break;
        	
        	default:
        		User::Leave(KErrArgument);
        		break;
        	}
        CleanupDeletePushL( item );	
        iList.AppendL( item );
        CleanupStack::Pop( item );
        }
    }



//  End of File