/*
* Copyright (c) 2007-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:  An array that manages shared views
*
*/


//  INCLUDES
#include "CSharedViewArray.h"

#include <CVPbkSimContactView.h>

// FORWARD DECLARATIONS

namespace VPbkSimStoreImpl {

// CLASS DECLARATION

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

// -----------------------------------------------------------------------------
// CSharedViewArray::NewL
// -----------------------------------------------------------------------------
//
CSharedViewArray* CSharedViewArray::NewL( 
        TViewDestructionPolicy aDestructionPolicy )
    {
    return new (ELeave ) CSharedViewArray( aDestructionPolicy );
    }

// -----------------------------------------------------------------------------
// CSharedViewArray::~CSharedViewArray
// -----------------------------------------------------------------------------
//    
CSharedViewArray::~CSharedViewArray()
    {
    iSharedViews.ResetAndDestroy();
    }

// -----------------------------------------------------------------------------
// CSharedViewArray::CreateNewHandleL
// -----------------------------------------------------------------------------
//        
CViewHandle* CSharedViewArray::CreateNewHandleL(
        const RVPbkSimFieldTypeArray& aSortOrder,
        TVPbkSimViewConstructionPolicy aConstructionPolicy, 
        MVPbkSimCntStore& aParentStore, const TDesC& aViewName )
    {
    CSharedViewOwner* viewOwner = FindOwner( aSortOrder, aConstructionPolicy, aViewName );
    
    if ( !viewOwner )
        {
        CVPbkSimContactView* sharedView = 
                CVPbkSimContactView::NewLC( aSortOrder, aConstructionPolicy,
                aParentStore, aViewName, NULL );
        viewOwner = new (ELeave ) CSharedViewOwner( *this, sharedView );
        CleanupStack::Pop( sharedView );
        CleanupStack::PushL( viewOwner );
        iSharedViews.AppendL( viewOwner );
        CleanupStack::Pop( viewOwner );
        }
    
    return viewOwner->CreateNewHandleL();
    }

// -----------------------------------------------------------------------------
// CSharedViewArray::RemoveHandle
// -----------------------------------------------------------------------------
//        
void CSharedViewArray::RemoveHandle( CViewHandle& aHandle )
    {
    CSharedViewOwner* viewOwner = NULL;
    for ( TInt i=0; i<iSharedViews.Count()&&!viewOwner; i++ )
        {
       if ( &iSharedViews[i]->View() == &aHandle.SharedView() )
            {
            viewOwner = iSharedViews[i];
            }
        }
    if ( viewOwner )
        {
        viewOwner->RemoveHandle( aHandle );
        if ( iDestructionPolicy == EDestroyViewIfNoHandles &&
             !viewOwner->HasHandles() )
            {
            TInt index = iSharedViews.Find( viewOwner );
            delete iSharedViews[index];
            iSharedViews.Remove( index );
            }
        }
    }

// -----------------------------------------------------------------------------
// CSharedViewArray::FindOwner
// -----------------------------------------------------------------------------
//        
CSharedViewOwner* CSharedViewArray::FindOwner( 
       const RVPbkSimFieldTypeArray& aSortOrder,
       TVPbkSimViewConstructionPolicy aConstructionPolicy,
       const TDesC& aViewName )
    {
    CSharedViewOwner* viewOwner = NULL;
    const TInt count = iSharedViews.Count();
    for ( TInt i = 0; i < count && !viewOwner; ++i )
        {
        if ( iSharedViews[i]->View().IsMatch( aSortOrder, aConstructionPolicy, aViewName ) )
            {
            viewOwner = iSharedViews[i];
            }
        }
    return viewOwner;
    }
    
// -----------------------------------------------------------------------------
// CViewHandle::CViewHandle
// C++ default constructor can NOT contain any code, that
// might leave.
// -----------------------------------------------------------------------------
//
CViewHandle::CViewHandle( CSharedViewArray& aSharedViewArray, 
        CVPbkSimContactView& aSharedView )
        :   iSharedViewArray( aSharedViewArray ),
            iSharedView( aSharedView )
    {
    }
    
// -----------------------------------------------------------------------------
// CViewHandle::~CViewHandle
// -----------------------------------------------------------------------------
//            
CViewHandle::~CViewHandle()
    {
    iSharedViewArray.RemoveHandle( *this );
    }

// -----------------------------------------------------------------------------
// CViewHandle::SharedView
// -----------------------------------------------------------------------------
//                
CVPbkSimContactView& CViewHandle::SharedView()
    {
    return iSharedView;
    }
    
// -----------------------------------------------------------------------------
// CViewHandle::Name
// -----------------------------------------------------------------------------
//                
const TDesC& CViewHandle::Name() const
    {
    return iSharedView.Name();
    }

// -----------------------------------------------------------------------------
// CViewHandle::ParentStore
// -----------------------------------------------------------------------------
//                    
MVPbkSimCntStore& CViewHandle::ParentStore() const
    {
    return iSharedView.ParentStore();
    }

// -----------------------------------------------------------------------------
// CViewHandle::OpenL
// -----------------------------------------------------------------------------
//                    
void CViewHandle::OpenL( MVPbkSimViewObserver& aObserver )
    {
    iSharedView.OpenL( aObserver );
    }

// -----------------------------------------------------------------------------
// CViewHandle::Close
// -----------------------------------------------------------------------------
//                        
void CViewHandle::Close( MVPbkSimViewObserver& aObserver )
    {
    iSharedView.Close( aObserver );
    }

// -----------------------------------------------------------------------------
// CViewHandle::CountL
// -----------------------------------------------------------------------------
//                            
TInt CViewHandle::CountL() const
    {
    return iSharedView.CountL();
    }

// -----------------------------------------------------------------------------
// CViewHandle::ContactAtL
// -----------------------------------------------------------------------------
//                                
MVPbkSimContact& CViewHandle::ContactAtL( TInt aIndex )
    {
    return iSharedView.ContactAtL( aIndex );
    }

// -----------------------------------------------------------------------------
// CViewHandle::ChangeSortOrderL
// -----------------------------------------------------------------------------
//                                    
void CViewHandle::ChangeSortOrderL( const RVPbkSimFieldTypeArray& aSortOrder )
    {
    iSharedView.ChangeSortOrderL( aSortOrder );
    }

// -----------------------------------------------------------------------------
// CViewHandle::MapSimIndexToViewIndexL
// -----------------------------------------------------------------------------
//                                        
TInt CViewHandle::MapSimIndexToViewIndexL( TInt aSimIndex )
    {
    return iSharedView.MapSimIndexToViewIndexL( aSimIndex );
    }
    
// -----------------------------------------------------------------------------
// CViewHandle::ContactMatchingPrefixL
// -----------------------------------------------------------------------------
//                                        
MVPbkSimStoreOperation* CViewHandle::ContactMatchingPrefixL(
        const MDesCArray& aFindStrings, 
        MVPbkSimViewFindObserver& aObserver )
    {
    return iSharedView.ContactMatchingPrefixL( aFindStrings, aObserver );
    }

// -----------------------------------------------------------------------------
// CViewHandle::SortOrderL
// -----------------------------------------------------------------------------
//                                        
const RVPbkSimFieldTypeArray& CViewHandle::SortOrderL() const
    {
    return iSharedView.SortOrderL();
    }
    
// -----------------------------------------------------------------------------
// CSharedViewOwner::CSharedViewOwner
// C++ default constructor can NOT contain any code, that
// might leave.
// -----------------------------------------------------------------------------
//
CSharedViewOwner::CSharedViewOwner( CSharedViewArray& aSharedViewArray,
        CVPbkSimContactView* aSharedView )
        :   iSharedViewArray( aSharedViewArray ),
            iSharedView( aSharedView )   
    {
    }

// -----------------------------------------------------------------------------
// CSharedViewOwner::~CSharedViewOwner
// -----------------------------------------------------------------------------
//   
CSharedViewOwner::~CSharedViewOwner()
    {
    iViewHandles.Close();
    delete iSharedView;
    }

// -----------------------------------------------------------------------------
// CSharedViewOwner::View
// -----------------------------------------------------------------------------
//   
CVPbkSimContactView& CSharedViewOwner::View() const
    {
    return *iSharedView;
    }

// -----------------------------------------------------------------------------
// CSharedViewOwner::CreateNewHandleL
// -----------------------------------------------------------------------------
//           
CViewHandle* CSharedViewOwner::CreateNewHandleL()
    {
    CViewHandle* handle = 
            new( ELeave ) CViewHandle( iSharedViewArray, *iSharedView );
    CleanupStack::PushL( handle );
    iViewHandles.AppendL( handle );
    CleanupStack::Pop( handle );
    return handle;
    }

// -----------------------------------------------------------------------------
// CSharedViewOwner::RemoveHandle
// -----------------------------------------------------------------------------
//           
void CSharedViewOwner::RemoveHandle( CViewHandle& aHandle )
    {
    TInt index = iViewHandles.Find( &aHandle );
    if ( index != KErrNotFound )
        {
        iViewHandles.Remove( index );
        }
    }
    
// -----------------------------------------------------------------------------
// CSharedViewOwner::HasHandles
// -----------------------------------------------------------------------------
//   
TBool CSharedViewOwner::HasHandles() const
    {
    return iViewHandles.Count() > 0;
    }    
} // namespace VPbkSimStoreImpl
            
// End of File