// Copyright (c) 1998-2009 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:

 //

 #include "UT_STD.H"

 // Class RDbTransaction::CNotifier

 NONSHARABLE_CLASS(RDbTransaction::CNotifier) : public CDbNotifier

 	{

 public:

 	inline CNotifier( RDbTransaction& aTransaction );

 	~CNotifier();

 //

 //	void Event( RDbNotifier::TEvent aEvent );

 private:

 //	void Complete( TInt aStatus );

 // from CDbNotifier

 //	void Notify( TType aEvent, TRequestStatus& aStatus );

 	void Cancel();

 private:

 	RDbTransaction* iTransaction;

 //	TRequestStatus* iStatus;

 	TInt iPending;

 	};

 inline RDbTransaction::CNotifier::CNotifier( RDbTransaction& aTransaction )

  :	iTransaction( &aTransaction )

 	{}

 RDbTransaction::CNotifier::~CNotifier()

 //

 // Cancel any outstanding request and extract from the transaction

 //

 	{

 	Cancel();

 	if ( iTransaction )

 		{

 		__ASSERT( iTransaction->iNotifier == this );

 		iTransaction->iNotifier = 0;

 		}

 	}

 //void RDbTransaction::CNotifier::Complete( TInt aStatus )

 //	{

 //	if ( iStatus )

 //		{

 //		iPending = 0;

 //		User::RequestComplete( iStatus, aStatus );

 //		}

 //	}

 //void RDbTransaction::CNotifier::Notify( CDbNotifier::TType aType, TRequestStatus& aStatus )

 ////

 //// Request for future notification. If the database is closed complete immediately

 ////

 //	{

 //	__ASSERT( !iStatus );

 //	__ASSERT( iPending >= 0 );

 //	iStatus = &aStatus;

 //	if ( iPending > RDbNotifier::EUnlock )

 //		Complete( iPending );

 //	else if ( !iTransaction )

 //		Complete( RDbNotifier::EClose );

 //	else

 //		{

 //		iPending = aType;

 //		aStatus = KRequestPending;

 //		}

 //	}

 void RDbTransaction::CNotifier::Cancel()

 	{

 //	Complete( KErrCancel );

 	}

 //void RDbTransaction::CNotifier::Event( RDbNotifier::TEvent aEvent )

 //	{

 //	if ( aEvent == RDbNotifier::EClose )

 //		iTransaction = 0;

 //	if ( iStatus )

 //		{

 //		__ASSERT( iPending < 0 );

 //		if (aEvent == RDbNotifier::EUnlock && iPending == CDbNotifier::EChange )

 //			;	// not interested in unlock events

 //		else

 //			Complete( aEvent );

 //		}

 //	else

 //		{

 //		__ASSERT( iPending >= 0 );

 //		if ( aEvent > iPending )

 //			iPending = aEvent;		// save the event

 //		}

 //	}

 // Class RDbTransaction

 #ifdef _ASSERTIONS

 //void RDbTransaction::_Invariant() const

 ////

 //// Invariance test

 ////

 //	{

 //	if ( iLockCount == 0 )

 //		{	// nothing must be happening in this state

 //		__ASSERT( iLockState == EDbReadLock );

 //		__ASSERT( iAction == EDbReadLock );

 //		__ASSERT( iUpdaters == 0 );

 //		return;

 //		}

 //	switch ( iLockState & EState )

 //		{

 //	default:

 //		__ASSERT( 0 );

 //	case EDbReadLock:

 //		{

 //		__ASSERT( iAction == EDbReadLock );

 //		__ASSERT( iLockCount > 0 );		// someone must have a lock

 //		__ASSERT( iLockCount <= iMaxLock );

 //		__ASSERT( iUpdaters == 0 );

 //		__ASSERT( iPrimary.iState != 0 );

 //		for (TInt ii = iLockCount - 1; --ii >= 0; )

 //			__ASSERT( iSharers[ii].iState != 0 );

 //		}

 //		break;

 //	case EDbCompactLock:		// not allowed in user-transactions

 //	case EDbRecoveryLock:

 //		__ASSERT( iAction == iLockState );

 //		__ASSERT( iLockCount == 1 );	// exactly one lock allowed

 //		__ASSERT( iUpdaters == 0 );

 //		__ASSERT( iPrimary.iState == 0 );

 //		break;

 //	case EDbXReadLock:	// intention to write. No updates but exclusive

 //		__ASSERT( iLockCount == 1 );	// exactly one lock allowed

 //		switch ( iAction )

 //			{

 //		default:

 //			__ASSERT( 0 );

 //		case EDbReadLock:	// must be in a transaction: cannot commit a write/schema mod when releasing a read lock

 //			__ASSERT( iUpdaters == 0 );

 //			__ASSERT( iPrimary.iState & static_cast<TUint>( ETransactionLock ) );

 //			break;

 //		case EDbWriteLock:

 //			__ASSERT( iUpdaters > 0 );

 //			break;

 //			}

 //		break;

 //	case EDbWriteLock:

 //	case EDbSchemaLock:

 //		__ASSERT( iLockCount == 1 );	// exactly one lock allowed

 //		switch ( iAction )

 //			{

 //		default:

 //			__ASSERT( 0 );

 //		case EDbReadLock:	// must be in a transaction: cannot commit a write/schema mod when releasing a read lock

 //			__ASSERT( iUpdaters == 0 );

 //			__ASSERT( iPrimary.iState & static_cast<TUint>( ETransactionLock ) );

 //			break;

 //		case EDbWriteLock:

 //			__ASSERT( iUpdaters > 0 );

 //			__ASSERT( ( iLockState & EState ) == EDbWriteLock || ( iPrimary.iState & static_cast<TUint>( ETransactionLock ) ) );

 //			break;

 //		case EDbSchemaLock:

 //			__ASSERT( ( iLockState & EState ) == EDbSchemaLock );

 //			__ASSERT( iUpdaters == 0 );

 //			break;

 //			}

 //		break;

 //		}

 //	}

 //template <class T> struct _InvariantFunc

 //	{

 //	static void Invariant( TAny* aPtr ) { ( (const T*)aPtr )->_Invariant(); }

 //	};

 //

 //template <class T> inline TCleanupOperation _InvariantFunction( T* )

 //	{ return _InvariantFunc<T>::Invariant; }

 //

 //struct _Invariant

 //	{

 //	inline _Invariant( TCleanupOperation aOp, TAny* aPtr )

 //	 :	iOp( aOp ), iPtr( aPtr )

 //		{ aOp( aPtr ); }

 //	inline ~_Invariant()

 //		{ iOp( iPtr ); }

 //private:

 //	TCleanupOperation iOp;

 //	TAny* iPtr;

 //	};

 #ifndef __LEAVE_EQUALS_THROW

 //struct _InvariantL

 //	{

 //	inline _InvariantL( TCleanupOperation aOp, TAny* aPtr )

 //		{ aOp( aPtr ); CleanupStack::PushL( TCleanupItem( aOp, aPtr ) ); }

 //	inline ~_InvariantL()

 //        { CleanupStack::PopAndDestroy(); }

 //	};

 #endif //__LEAVE_EQUALS_THROW__

 //#define __INVARIANT   struct _Invariant _invariant( _InvariantFunction( this ), this );

 //#ifdef __LEAVE_EQUALS_THROW__

 //	#define __INVARIANT_L __INVARIANT

 //#else

 //	#define __INVARIANT_L struct _InvariantL _invariant( _InvariantFunction( this ), this );

 //#endif //__LEAVE_EQUALS_THROW__

 #define __INVARIANT   ( (void)0 )

 #define __INVARIANT_L ( (void)0 )

 #else // _ASSERTIONS

 #define __INVARIANT   ( (void)0 )

 #define __INVARIANT_L ( (void)0 )

 #endif // _ASSERTIONS

 inline TDbLockType RDbTransaction::LockState() const

 	{ return TDbLockType( iLockState & EState ); }

 void RDbTransaction::Close()

 	{

 	__ASSERT( !IsLocked() );

 	User::Free( iSharers );

 //	Event( RDbNotifier::EClose );

 	}

 void RDbTransaction::DoCommitL()

 //

 // Commit any changes

 //

 	{

 	__ASSERT_ALWAYS( ( iPrimary.iState & ~ETransactionLock ) == 0, Panic( EDbStreamsPendingOnCommit ) );

 	iLockState |= EFailed;

 	Database().FlushL( LockState() );

 	Database().SynchL( LockState() );

 	Unlock( RDbNotifier::ECommit );

 	}

 void RDbTransaction::DoRollback()

 //

 // Rollback any changes

 //

 	{

 	__ASSERT_ALWAYS( ( iPrimary.iState & ~ETransactionLock ) == 0, Panic( EDbStreamsPendingOnRollback ) );

 	Database().Revert( LockState() );

 	Database().Abandon( LockState() );

 	if ( LockState() >= EDbWriteLock )

 		++iRollback;

 	Unlock( RDbNotifier::ERollback );

 	}

 // explicit transactions

 void RDbTransaction::BeginL( const CDbObject& aObject )

 //

 // begin a user transaction. This first gains a shared read-lock

 //

 	{

 	__INVARIANT_L;

 	__ASSERT_ALWAYS( GetLock( aObject ) == 0, Panic( EDbBeginNestedTransaction ) );

 	ReadyL();

 	PrepareSLockL( aObject, TUint( ETransactionLock ) );

 	__ASSERT( iAction == EDbReadLock );

 	__ASSERT( iLockState == EDbReadLock );

 	++iLockCount;

 	}

 void RDbTransaction::CommitL( const CDbObject& aObject )

 //

 // Commit a user transaction and release the lock

 // All updates must be complete for a write-lock

 //

 	{

 	__INVARIANT_L;

 	__ASSERT_ALWAYS( InTransaction( aObject ), Panic( EDbNoCurrentTransaction ) );

 	ReadyL();

 	if ( iLockCount > 1 )

 		{

 		TLock* lock = GetLock( aObject );

 		__ASSERT( lock );

 		__ASSERT_ALWAYS( lock->iState == static_cast<TUint>( ETransactionLock ), Panic( EDbStreamsPendingOnCommit ) );

 		Unlock( *lock );

 		}

 	else

 		{

 		__ASSERT_ALWAYS( iAction == EDbReadLock, Panic( EDbUpdatesPendingOnCommit ) );

 		DoCommitL();

 		}

 	}

 void RDbTransaction::Rollback( const CDbObject& aObject )

 //

 // Rollback a user transaction and release the lock

 // All updates must be complete/aborted for a write-lock

 //

 	{

 	__INVARIANT;

 	__ASSERT_ALWAYS( InTransaction( aObject ), Panic( EDbNoCurrentTransaction ) );

 	if ( iLockCount > 1 )

 		{

 		TLock* lock = GetLock( aObject );

 		__ASSERT( lock );

 		__ASSERT_ALWAYS( lock->iState == static_cast<TUint>( ETransactionLock ), Panic( EDbStreamsPendingOnRollback ) );

 		Unlock( *lock );

 		}

 	else

 		{

 		__ASSERT_ALWAYS( iAction == EDbReadLock, Panic( EDbUpdatesPendingOnRollback ) );

 		DoRollback();

 		}

 	}

 void RDbTransaction::PrepareSLockL( const CDbObject& aObject, TUint aInitState )

 //

 // prepare to acquire a shared read lock

 // if any holder has an exclusive lock this fails

 //

 	{

 	__ASSERT( GetLock( aObject ) == 0 );	// cannot get a 2nd shared lock

 //

 	THolder h = aObject.Context();

 	if ( iLockCount == 0 )

 		{

 		iPrimary.iHolder = h;				// first lock, no other checks required

 		iPrimary.iState = aInitState;

 		}

 	else if ( iLockState != EDbReadLock )

 		__LEAVE( KErrLocked );

 	else

 		{						// allocate a Sharers-slot

 		TLock* share = iSharers;

 		if ( iLockCount == iMaxLock )

 			{

 			TInt newsize = iMaxLock + ELockListGranularity;

 			if ( newsize > EMaxLock )

 				{

 				__LEAVE( KErrLocked );

 				return;

 				}

 			iSharers = share = ( TLock* )User::ReAllocL( share, ( newsize - 1 ) * sizeof( TLock ) );

 			iMaxLock = TUint8( newsize );

 			}

 		share += iLockCount - 1;

 		share->iHolder = h;

 		share->iState = aInitState;

 		}

 	}

 void RDbTransaction::PrepareXLockL( const CDbObject& aObject )

 //

 // prepare to acquire an exclusive lock

 // if any other holder has a lock this fails

 //

 	{

 	THolder h = aObject.Context();

 	switch ( iLockCount )

 		{

 	case 0:					// no other holders, acquire the lock

 		iPrimary.iHolder = h;

 		iPrimary.iState = 0;		// this is not a transaction lock

 		break;

 	case 1:					// check we are the single Lock holder

 		if (iPrimary.iHolder != h)

 			__LEAVE( KErrLocked );

 		break;

 	default:				// cannot get XLock

 		__LEAVE( KErrLocked );

 		break;

 		}

 	}

 void RDbTransaction::Unlock( RDbNotifier::TEvent aEvent )

 //

 // Remove the last lock and signal an event to the Notifier

 //

 	{

 	__ASSERT( iLockCount == 1 );

 	__ASSERT( ( iPrimary.iState & ~ETransactionLock ) == 0 );

 	TDbLockType ls = LockState();

 	Event( ls == EDbReadLock || ls == EDbXReadLock ? RDbNotifier::EUnlock : aEvent );

 	iLockCount = 0;

 	iAction = iLockState = EDbReadLock;

 	iUpdaters = 0;

 	Database().CheckIdle();

 	}

 void RDbTransaction::Unlock( RDbTransaction::TLock& aLock )

 //

 // Remove a shared lock holder from the list

 //

 	{

 	__ASSERT( iLockCount > 1 );

 	__ASSERT( LockState() == EDbReadLock );

 	__ASSERT( ( aLock.iState & ~ETransactionLock ) == 0 );

 	aLock = iSharers[--iLockCount - 1];

 	}

 RDbTransaction::TLock* RDbTransaction::GetLock( const CDbObject& aObject )

 //

 // Test if aObject holds any lock, and return it

 //

 	{

 	const THolder h = aObject.Context();

 	TInt lc = iLockCount;

 	if ( --lc >= 0 )

 		{

 		if ( iPrimary.iHolder == h )

 			return &iPrimary;

 		if ( lc > 0 )

 			{

 			TLock* const base = iSharers;

 			TLock* l = base + lc;

 			do	{

 				if ( ( --l )->iHolder == h )

 					return l;

 				} while ( l > base );

 			}

 		}

 	return 0;

 	}

 TBool RDbTransaction::InTransaction( const CDbObject& aObject )

 //

 // Test if aObject holds a non-auto transaction

 //

 	{

 	__INVARIANT;

 	TLock* lock = GetLock( aObject );

 	return lock ? lock->iState & static_cast<TUint>( ETransactionLock ) : 0;

 	}

 void RDbTransaction::ReadPrepareL( const CDbObject& aObject )

 //

 // Check that aObject can gain a shared read lock and allocate required resources

 //

 	{

 	__INVARIANT_L;

 	if ( GetLock( aObject ) == 0 )

 		PrepareSLockL( aObject, 0 );		// prepare a S-Lock for the read

 	else if ( iAction == EDbCompactLock )	// Cannot already hold a compaction lock

 		__LEAVE( KErrAccessDenied );

 	}

 void RDbTransaction::ReadBegin( const CDbObject& aObject )

 //

 // Take a read-lock: ReadPrepareL(aObject) _must_ already have been called

 //

 	{

 	__INVARIANT;

 	TLock* lock = GetLock( aObject );

 	if ( !lock )

 		{

 		++iLockCount;

 		lock = GetLock( aObject );

 		__ASSERT( lock );

 		}

 	++lock->iState;

 	}

 void RDbTransaction::ReadRelease( const CDbObject& aObject )

 	{

 	__INVARIANT;

 	TLock* lock = GetLock( aObject );

 	__ASSERT( lock );

 	__ASSERT( ( lock->iState & ~ETransactionLock ) > 0 );

 	if ( --lock->iState == 0 )

 		{	// not transaction-lock

 		if ( iLockCount > 1 )

 			Unlock( *lock );

 		else if ( iAction == EDbReadLock )	// no other locks to this client

 			Unlock( RDbNotifier::EUnlock );

 		}

 	}

 void RDbTransaction::DMLCheckL()

 //

 // Check that we can open a new rowset

 //

 	{

 	__INVARIANT_L;

 	ReadyL();

 	if ( iAction > EDbCompactLock )	

 		__LEAVE( KErrAccessDenied );

 	}

 void RDbTransaction::DMLPrepareL( const CDbObject& aObject )

 //

 // Check that we can do DML, this should be called immediately prior to DMLBegin

 //

 	{

 	__INVARIANT_L;

 	PrepareXLockL( aObject );

 	if ( iAction>EDbWriteLock )

 		__LEAVE( KErrAccessDenied );

 	}

 void RDbTransaction::DMLBegin()

 //

 // A Rowset begins an update

 //

 	{

 	__INVARIANT;

 	__ASSERT( iAction == EDbReadLock || iAction == EDbWriteLock );

 	__ASSERT( ( iLockState & EFailed ) == 0 );

 	__ASSERT( iLockCount <= 1 );

 	if ( iAction == EDbReadLock )

 		iAction = EDbWriteLock;

 	if (iLockState == EDbReadLock )

 		iLockState = EDbXReadLock;		// escalate lock to exclusive as we are now writing

 	++iUpdaters;

 	iLockCount = 1;

 	}

 void RDbTransaction::DMLTouch()

 //

 // This must be called prior to putting DML updates

 //

 	{

 	__ASSERT( iAction == EDbWriteLock );

 	__ASSERT( iUpdaters > 0 );

 	TInt ls = iLockState;

 	if ( ls == EDbXReadLock )

 		ls = EDbWriteLock | EFailed;

 	else

 		ls |= EFailed;

 	iLockState = TUint8( ls );

 	}

 void RDbTransaction::DMLBeginLC()

 	{

 	DMLBegin();

 	CleanupStack::PushL( TCleanupItem( DMLAbandon, this ) );

 	DMLTouch();

 	}

 void RDbTransaction::DMLCommitL()

 //

 // A rowset has completed an update

 //

 	{

 	__INVARIANT_L;

 	__ASSERT( iAction == EDbWriteLock && ( iLockState & EFailed ) );

 	TInt updaters = iUpdaters - 1;

 	if ( updaters == 0 )

 		{

 		if ( ( iPrimary.iState & static_cast<TUint>( ETransactionLock ) ) == 0 )

 			{

 			__ASSERT( iLockState == ( EDbWriteLock | EFailed ) );

 			DoCommitL();		// automatic write-commit, release auto-lock

 			return;

 			}

 		iAction = EDbReadLock;

 		}

 	iUpdaters = updaters;

 	iLockState &= ~EFailed;

 	}

 void RDbTransaction::DMLRollback()

 //

 // Rollback a DML operation

 //

 	{

 	__INVARIANT;

 	__ASSERT( iAction == EDbWriteLock );

 	TInt updates = iUpdaters - 1;

 	if ( updates == 0 )

 		{

 		if ( ( iPrimary.iState & static_cast<TUint>( ETransactionLock ) ) == 0 )

 			{

 			__ASSERT( LockState() == EDbWriteLock || LockState() == EDbXReadLock );

 			DoRollback();		// automatic rollback now (may panic)

 			return;

 			}

 		iAction = EDbReadLock;

 		}

 	iUpdaters = updates;

 	}

 void RDbTransaction::DMLAbandon( TAny* aPtr )

 	{

 	STATIC_CAST( RDbTransaction*, aPtr )->DMLRollback();

 	}

 void RDbTransaction::DDLPrepareL( const CDbObject& aObject )

 //

 // Check that we can use the database for ddl and flush out any tables

 // should be called before DDLBegin

 //

 	{

 	__INVARIANT_L;

 	ReadyL();

 	PrepareXLockL( aObject );

 	if ( iAction != EDbReadLock || ( IsLocked() && iPrimary.iState != static_cast<TUint>( ETransactionLock ) ) )

 		__LEAVE( KErrAccessDenied );	// Cannot take sole ownership of the database

 	TInt ls = iLockState;

 	if ( ls >= EDbWriteLock )

 		{	// ensure all table data is flushed as they may be "released"

 		iLockState = TUint8( ls | EFailed );

 		Database().FlushL( EDbWriteLock );

 		iLockState = TUint8( ls );

 		}

 	}

 void RDbTransaction::DDLBegin()

 //

 // A DDL object is about to start ops

 //

 	{

 	__INVARIANT;

 	__ASSERT( iAction == EDbReadLock );

 	__ASSERT( ( iLockState & EFailed ) == 0 );

 	__ASSERT( iLockCount <= 1 );

 	iLockState = iAction = EDbSchemaLock;

 	iLockCount = 1;

 	}

 void RDbTransaction::DDLBeginLC()

 	{

 	DDLBegin();

 	CleanupStack::PushL( TCleanupItem( DDLAbandon, this ) );

 	}

 void RDbTransaction::DDLCommitL()

 //

 // A DDL incremental object has completed

 //

 	{

 	__INVARIANT_L;

 	__ASSERT( iAction == EDbSchemaLock );

 	if ( ( iPrimary.iState & static_cast<TUint>( ETransactionLock ) ) == 0 )

 		{

 		__ASSERT( iLockState == EDbSchemaLock );

 		DoCommitL();	// release auto-lock

 		}

 	else

 		iAction = EDbReadLock;

 	}

 void RDbTransaction::DDLRollback()

 //

 // Rollback a DDL operation

 //

 	{

 	__INVARIANT;

 	__ASSERT( iAction == EDbSchemaLock );

 	iLockState |= EFailed;

 	if ( ( iPrimary.iState & static_cast<TUint>( ETransactionLock ) ) == 0 )

 		{

 		__ASSERT( iLockState == ( EDbSchemaLock | EFailed ) );

 		DoRollback();		// release auto-lock

 		}

 	else

 		iAction = EDbReadLock;

 	}

 void RDbTransaction::DDLAbandon( TAny* aPtr )

 	{

 	STATIC_CAST( RDbTransaction*, aPtr )->DDLRollback();

 	}

 // recovery. Nothing else can be done at the same time as this

 void RDbTransaction::UtilityPrepareL( const CDbObject& aObject )

 //

 // Check that we are in a state to run a utility

 //

 	{

 	__INVARIANT_L;

 	ReadyL();

 	PrepareXLockL( aObject );

 	if ( IsLocked() )			// utilities not allowed in user transaction

 		__LEAVE( KErrAccessDenied );

 	}

 void RDbTransaction::UtilityBegin( CDbDatabase::TUtility aType )

 //

 // Database Recovery object is about to start

 //

 	{

 	__INVARIANT;

 	__ASSERT( !IsLocked() );

 	if ( aType == CDbDatabase::ERecover )

 		iLockState = iAction = EDbRecoveryLock;

 	else

 		iLockState = iAction = EDbCompactLock;

 	iLockCount = 1;

 	}

 void RDbTransaction::UtilityCommitL()

 //

 // Database Recovery has completed

 //

 	{

 	__INVARIANT_L;

 	Database().SynchL( LockState() );

 	Unlock( iAction == EDbRecoveryLock ? RDbNotifier::ERecover : RDbNotifier::EUnlock );	// release auto-lock

 	}

 void RDbTransaction::UtilityRollback()

 	{

 	__INVARIANT;

 	Database().Revert( LockState() );

 	Unlock( RDbNotifier::EUnlock );	// release auto-lock

 	}

 CDbNotifier* RDbTransaction::NotifierL()

 //

 // Only support a single notifier for the database (server multiplexes)

 //

 	{

 	if ( iNotifier )

 		__LEAVE( KErrNotSupported );

 	return iNotifier = new( ELeave ) CNotifier( *this );

 	}

 void RDbTransaction::Event( RDbNotifier::TEvent aEvent )

 //

 // Report an event to the Notifier

 // If the lock was less than a write lock, report unlock only: no commit or rollback

 //

 	{

 //	if ( iNotifier )

 //		iNotifier->Event( aEvent );

 	}