/*
* Copyright (c) 2002 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:  Store entry abstract class
*
*/



// INCLUDE FILES
#include    <e32std.h>
#include    "CPEngStoreEntry.h"
#include	"MPEngStorageManagerWatcher.h"
#include	"MPEngStorageManager.h"
#include	"PEngStorageGlobals.h"

//	Debug prints
#include	"PresenceDebugPrint.h"


// ============================= LOCAL CLASS DEFINITION ======================

// CLASS DEFINITION
NONSHARABLE_CLASS( TPEngSIdsDesWraper ):
        public MDesCArray
    {
public:
    inline TPEngSIdsDesWraper( const TDesC& aSid )
            : iSid( aSid )
        {
        }
public: // from MDesC16Array
    inline TInt MdcaCount() const
        {
        // we have only one Sid
        return 1;
        }

    inline TPtrC16 MdcaPoint( TInt aIndex ) const
        {
        // panic is index is out of 0
        __ASSERT_DEBUG( aIndex == 0, User::Panic(
                            KPEngSMPanic,
                            EPEngSM_StoreManNotDefined ) );
        ( void ) aIndex; // Prevent compilation warning about unused variable
        return iSid;
        }

private: // data
    const TDesC& 			iSid;
    };

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

// -----------------------------------------------------------------------------
// CPEngStoreEntry::CPEngStoreEntry
// C++ default constructor can NOT contain any code, that might leave.
// -----------------------------------------------------------------------------
//
EXPORT_C CPEngStoreEntry::CPEngStoreEntry(
    TPEngStorageType aStorageType )
        : iStorageType( aStorageType )
    {
    }

// -----------------------------------------------------------------------------
// CPEngStoreEntry::BaseConstructL
// Symbian 2nd phase Base constructor can leave.
// -----------------------------------------------------------------------------
//
EXPORT_C void CPEngStoreEntry::BaseConstructL()
    {
    }

// -----------------------------------------------------------------------------
// CPEngStoreEntry::BaseConstructL
// Symbian 2nd phase Base constructor can leave.
// -----------------------------------------------------------------------------
//
EXPORT_C void CPEngStoreEntry::BaseConstructL(
    MPEngStorageManager& aStorageManager,
    TBool aRegister /* = ETrue */ )
    {
    iStorageManager = &aStorageManager;
    iStorageManager->Open();                        // CSI: 65 #

    if ( aRegister )
        {
        TPEngSIdsDesWraper sidWrap( this->StorageId() );
        iStorageManager->StorageManagerWatcher().RegisterListenSIDsObserverL(
            sidWrap,
            *this,
            MPEngStorageManagerWatcher::EPEngObserverInternal );
        }
    }


// Destructor
EXPORT_C CPEngStoreEntry::~CPEngStoreEntry()
    {
    if ( iStorageManager )
        {
        iStorageManager->StorageManagerWatcher(
        ).UnregisterListenSIDsObserver( *this );
        iStorageManager->Close();
        }
    }

// -----------------------------------------------------------------------------
// ==== Default implementation of functions from main class ====================
// -----------------------------------------------------------------------------

// -----------------------------------------------------------------------------
// CPEngStoreEntry::Release
// -----------------------------------------------------------------------------
//
EXPORT_C void CPEngStoreEntry::Release()
    {
    __ASSERT_DEBUG( iStorageManager, User::Panic(
                        KPEngSMPanic,
                        EPEngSM_StoreManNotDefined ) );
    // do not check, let client crash,
    // since this should be always valid pointer
    iStorageManager->Unlock( *this );
    }

// -----------------------------------------------------------------------------
// CPEngStoreEntry::LockLC()
// -----------------------------------------------------------------------------
//
EXPORT_C TInt CPEngStoreEntry::LockLC()
    {
    __ASSERT_DEBUG( iStorageManager, User::Panic(
                        KPEngSMPanic,
                        EPEngSM_StoreManNotDefined ) );
    TInt err( Lock() );
    CleanupReleasePushL( *this );
    return err;
    }

// -----------------------------------------------------------------------------
// CPEngStoreEntry::Lock
// -----------------------------------------------------------------------------
//
EXPORT_C TInt CPEngStoreEntry::Lock(
    TPengStorageLockPriority aPriority
    /* EStorageLockLevelBasic */,
    TBool aCreateEntry /* = ETrue */ ) const
    {
    __ASSERT_DEBUG( iStorageManager, User::Panic(
                        KPEngSMPanic,
                        EPEngSM_StoreManNotDefined ) );

    // do not check, let client crash,
    // since this should be always valid pointer
    return iStorageManager->Lock( *this, aPriority, aCreateEntry );
    }

// -----------------------------------------------------------------------------
// CPEngStoreEntry::Unlock
// -----------------------------------------------------------------------------
//
EXPORT_C TInt CPEngStoreEntry::Unlock() const
    {
    __ASSERT_DEBUG( iStorageManager, User::Panic(
                        KPEngSMPanic,
                        EPEngSM_StoreManNotDefined ) );
    // do not check, let client crash, since this should be always valid pointer
    return iStorageManager->Unlock( *this );
    }

// -----------------------------------------------------------------------------
// CPEngStoreEntry::BufferServerSideNotifications
// -----------------------------------------------------------------------------
//
EXPORT_C TInt CPEngStoreEntry::BufferServerSideNotifications()
    {
    __ASSERT_DEBUG( iStorageManager, User::Panic(
                        KPEngSMPanic,
                        EPEngSM_StoreManNotDefined ) );
    return iStorageManager->BufferServerSideNotifications();
    }

// -----------------------------------------------------------------------------
// CPEngStoreEntry::ReleaseServerSideBuffering
// -----------------------------------------------------------------------------
//
EXPORT_C TInt CPEngStoreEntry::ReleaseServerSideBuffering()
    {
    __ASSERT_DEBUG( iStorageManager, User::Panic(
                        KPEngSMPanic,
                        EPEngSM_StoreManNotDefined ) );

    return iStorageManager->ReleaseServerSideBuffering();
    }

// -----------------------------------------------------------------------------
// CPEngStoreEntry::StoreL
// -----------------------------------------------------------------------------
//
EXPORT_C void CPEngStoreEntry::StoreL()
    {
    __ASSERT_DEBUG( iStorageManager, User::Panic(
                        KPEngSMPanic,
                        EPEngSM_StoreManNotDefined ) );
    iStorageManager->StoreL( *this );
    }

// -----------------------------------------------------------------------------
// ===================== Storage type support ==================================
// -----------------------------------------------------------------------------

// -----------------------------------------------------------------------------
// CPEngStoreEntry::StorageType
// -----------------------------------------------------------------------------
//
EXPORT_C TPEngStorageType CPEngStoreEntry::StorageType() const
    {
    return iStorageType;
    }

// -----------------------------------------------------------------------------
// CPEngStoreEntry::ChangeStorageTypeL
// -----------------------------------------------------------------------------
//
EXPORT_C void CPEngStoreEntry::ChangeStorageTypeL( TPEngStorageType aNewType )
    {
    __ASSERT_DEBUG( iStorageManager, User::Panic(
                        KPEngSMPanic,
                        EPEngSM_StoreManNotDefined ) );
    if ( iStorageType == aNewType )
        {
        return;
        }
    TInt err( iStorageManager->Delete( *this ) );
    err = err == KErrNotFound ? KErrNone : err;
    User::LeaveIfError( err );
    iStorageType = aNewType;
    // reset version counter to zero
    iEntryVersion = 0;
    iStorageManager->StoreL( *this );
    }

// -----------------------------------------------------------------------------
// ====  New functions of MPEngSIDChangeObserver with default implementation ===
// -----------------------------------------------------------------------------

// -----------------------------------------------------------------------------
// CPEngStoreEntry::HandleSIDsChangeL
// -----------------------------------------------------------------------------
//
EXPORT_C void CPEngStoreEntry::HandleSIDsChangeL(
    CPtrCArray& /* aChangedSIDs */ )
    {
    // does nothing
    }

// -----------------------------------------------------------------------------
// CPEngStoreEntry::HandleSIDNotifyError
// -----------------------------------------------------------------------------
//
EXPORT_C void CPEngStoreEntry::HandleSIDNotifyError(
    TInt /* aError */ )
    {
    // does nothing
    }

//  End of File