crashanalysercmd/PerfToolsSharedLibraries/Engine/SymbianUtils/SerializedOperations/SerializedOperation.cs
Version 1.0.13. The most important changes are:
-detailed defect hash added
-panic descriptions updated
-release build is working
-simple command line usage added
/*
* Copyright (c) 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:
*
*/
using System;
using System.Collections.Generic;
using System.Text;
using System.Threading;
using System.ComponentModel;
namespace SymbianUtils.SerializedOperations
{
public abstract class SerializedOperation : DisposableObject, IComparable<SerializedOperation>
{
#region Delegates & events
public delegate void EventHandler( SerializedOperation aOperation );
public event EventHandler Started;
public event EventHandler Completed;
#endregion
#region Constructors
protected SerializedOperation()
: this( true )
{
}
protected SerializedOperation( bool aEnabled )
{
Enabled = aEnabled;
//
iWorker.DoWork += new DoWorkEventHandler( DoWork );
}
#endregion
#region Framework API
protected abstract void PerformOperation();
public virtual long Priority
{
get { return 0; }
}
#endregion
#region API
public void EnableAndWait()
{
Trace( "[{0}] EnableAndWait() - START - enabled: {1}, busy: {2}", this.GetType().Name, Enabled, IsBusy );
System.Diagnostics.Debug.Assert( Enabled == false );
System.Diagnostics.Debug.Assert( !IsBusy );
if ( IsBusy )
{
while ( IsBusy )
{
Trace( "[{0}] EnableAndWait() - still busy?: {1}", this.GetType().Name, IsBusy );
Thread.Sleep( 10 );
}
}
else
{
SymbianUtils.SymDebug.SymDebugger.Assert( iWaitForCompletion == null );
using ( iWaitForCompletion = new AutoResetEvent( false ) )
{
// Enable the operation
Trace( "[{0}] EnableAndWait() - enabling item...", this.GetType().Name );
Enabled = true;
// And now block until it completes
Trace( "[{0}] EnableAndWait() - sleeping...", this.GetType().Name );
iWaitForCompletion.WaitOne();
Trace( "[{0}] EnableAndWait() - slept!", this.GetType().Name );
}
}
Trace( "[{0}] EnableAndWait() - END", this.GetType().Name );
}
#endregion
#region Properties
public object Tag
{
get { return iTag; }
set { iTag = value; }
}
public bool IsBusy
{
get { return iWorker.IsBusy; }
}
public bool Enabled
{
get { return iEnabled; }
set
{
lock ( iEnabledLock )
{
if ( value != iEnabled )
{
iEnabled = value;
if ( OperationManager != null )
{
OperationManager.OnOperationEnabledStatusChanged( this );
}
}
}
}
}
internal SerializedOperationManager OperationManager
{
get { return iManager; }
set { iManager = value; }
}
#endregion
#region Event handlers
private void DoWork( object aSender, DoWorkEventArgs aArgs )
{
System.Diagnostics.Debug.Assert( OperationManager != null );
NotifyStarted();
//
try
{
PerformOperation();
}
catch ( Exception opException )
{
OperationManager.Trace( string.Format( "OPERATION EXCEPTION MSG - op: {0} ({1}) - msg: {2}", this.ToString(), this.GetType(), opException.Message ) );
OperationManager.Trace( string.Format( "OPERATION EXCEPTION STK {0}", opException.StackTrace ) );
}
//
NotifyCompleted();
}
private void WorkerCompleted()
{
Trace( "[{0}] WorkerCompleted() - START", this.GetType().Name );
//
System.Diagnostics.Debug.Assert( OperationManager != null );
OperationManager.OperationCompleted( this );
//
if ( iWaitForCompletion != null )
{
Trace( "[{0}] WorkerCompleted() - unblocking main thread...", this.GetType().Name );
iWaitForCompletion.Set();
}
//
Trace( "[{0}] WorkerCompleted() - END", this.GetType().Name );
}
#endregion
#region Internal methods
protected void Trace( string aMessage )
{
iManager.Trace( aMessage );
}
protected void Trace( string aFormat, params object[] aParams )
{
iManager.Trace( aFormat, aParams );
}
internal void Start()
{
Start( null );
}
internal void Start( object aParameter )
{
System.Diagnostics.Debug.Assert( Enabled );
iWorker.RunWorkerAsync( aParameter );
}
private void NotifyStarted()
{
try
{
if ( Started != null )
{
Started( this );
}
}
catch ( Exception )
{
}
}
private void NotifyCompleted()
{
try
{
if ( Completed != null )
{
Completed( this );
}
try
{
WorkerCompleted();
}
catch ( Exception )
{
}
}
catch ( Exception )
{
}
}
#endregion
#region From IComparable<SerializedOperation>
public int CompareTo( SerializedOperation aOther )
{
int ret = 1;
//
if ( aOther != null )
{
ret = this.Priority.CompareTo( aOther.Priority );
}
//
return ret;
}
#endregion
#region From DisposableObject
protected override void CleanupManagedResources()
{
try
{
base.CleanupManagedResources();
}
finally
{
if ( iWaitForCompletion != null )
{
iWaitForCompletion.Close();
iWaitForCompletion = null;
}
if ( iWorker != null )
{
iWorker.Dispose();
iWorker = null;
}
}
}
#endregion
#region From System.Object
public override string ToString()
{
return this.GetType().Name;
}
#endregion
#region Data members
private object iTag = null;
private object iEnabledLock = new object();
private bool iEnabled = true;
private SerializedOperationManager iManager = null;
private BackgroundWorker iWorker = new BackgroundWorker();
private AutoResetEvent iWaitForCompletion = null;
#endregion
}
}