Exemple #1
0
        protected void EndComputation()
        {
            Contract.Requires(
                this.State == ComputationState.Running ||
                this.State == ComputationState.Aborted);
            lock (this.syncRoot)
            {
                switch (this.state)
                {
                case ComputationState.Running:
                    this.state = ComputationState.Finished;
                    this.OnFinished(EventArgs.Empty);
                    break;

                case ComputationState.PendingAbortion:
                    this.state = ComputationState.Aborted;
                    this.OnAborted(EventArgs.Empty);
                    break;

                default:
                    throw new InvalidOperationException();
                }
                this.Services.CancelManager.ResetCancel();
                this.OnStateChanged(EventArgs.Empty);
            }
        }
Exemple #2
0
        private void EndComputation()
        {
            Debug.Assert(
                State == ComputationState.Running
                ||
                State == ComputationState.PendingAbortion);

            lock (SyncRoot)
            {
                switch (_state)
                {
                case ComputationState.Running:
                    _state = ComputationState.Finished;
                    OnFinished(EventArgs.Empty);
                    break;

                case ComputationState.PendingAbortion:
                    _state = ComputationState.Aborted;
                    OnAborted(EventArgs.Empty);
                    break;

                default:
                    throw new InvalidOperationException();
                }

                Services.CancelManager.ResetCancel();
                OnStateChanged(EventArgs.Empty);
            }
        }
Exemple #3
0
 public static void AssertAlgorithmState(
     [NotNull] AlgorithmBase algorithm,
     ComputationState state = ComputationState.NotRunning)
 {
     Assert.IsNotNull(algorithm.SyncRoot);
     Assert.AreEqual(state, algorithm.State);
 }
Exemple #4
0
 protected void BeginComputation()
 {
     Contract.Requires(this.State == ComputationState.NotRunning);
     lock (this.syncRoot)
     {
         this.state = ComputationState.Running;
         this.Services.CancelManager.ResetCancel();
         this.OnStarted(EventArgs.Empty);
         this.OnStateChanged(EventArgs.Empty);
     }
 }
Exemple #5
0
 public static void AssertAlgorithmState <TGraph>(
     [NotNull] AlgorithmBase <TGraph> algorithm,
     [NotNull] TGraph treatedGraph,
     ComputationState state = ComputationState.NotRunning)
 {
     Assert.IsNotNull(treatedGraph);
     Assert.AreSame(treatedGraph, algorithm.VisitedGraph);
     Assert.IsNotNull(algorithm.Services);
     Assert.IsNotNull(algorithm.SyncRoot);
     Assert.AreEqual(state, algorithm.State);
 }
Exemple #6
0
        private void BeginComputation()
        {
            Debug.Assert(State == ComputationState.NotRunning);

            lock (SyncRoot)
            {
                _state = ComputationState.Running;
                Services.CancelManager.ResetCancel();
                OnStarted(EventArgs.Empty);
                OnStateChanged(EventArgs.Empty);
            }
        }
        protected void BeginComputation()
        {
            lock ( syncRoot )
            {
                //if ( state != ComputationState.NotRunning )
                //	throw new InvalidOperationException();

                state = ComputationState.Running;
                cancelling = 0;
                OnStarted( EventArgs.Empty );
                OnStateChanged( EventArgs.Empty );
            }
        }
Exemple #8
0
        protected void BeginComputation()
        {
            lock ( syncRoot )
            {
                //if ( state != ComputationState.NotRunning )
                //	throw new InvalidOperationException();

                state      = ComputationState.Running;
                cancelling = 0;
                OnStarted(EventArgs.Empty);
                OnStateChanged(EventArgs.Empty);
            }
        }
        protected void BeginComputation()
        {
            lock (this.syncRoot)
            {
                if (this.state != ComputationState.NotRunning)
                {
                    throw new InvalidOperationException();
                }

                this.state      = ComputationState.Running;
                this.cancelling = 0;
                this.OnStarted(EventArgs.Empty);
                this.OnStateChanged(EventArgs.Empty);
            }
        }
        protected void BeginComputation()
        {
            lock (this.syncRoot)
            {
                if (this.state != ComputationState.NotRunning)
                {
                    throw new InvalidOperationException();
                }

                this.state = ComputationState.Running;
                this.Services.CancelManager.ResetCancel();
                this.OnStarted(EventArgs.Empty);
                this.OnStateChanged(EventArgs.Empty);
            }
        }
 public virtual void Abort()
 {
     bool raise = false;
     lock ( syncRoot )
     {
         if ( state == ComputationState.Running )
         {
             state = ComputationState.PendingAbortion;
             System.Threading.Interlocked.Increment( ref cancelling );
             raise = true;
         }
     }
     if ( raise )
         OnStateChanged( EventArgs.Empty );
 }
Exemple #12
0
        private void BeginComputation()
        {
            Debug.Assert(
                State == ComputationState.NotRunning ||
                State == ComputationState.Finished ||
                State == ComputationState.Aborted);

            lock (SyncRoot)
            {
                _state      = ComputationState.Running;
                _cancelling = 0;
                OnStarted(EventArgs.Empty);
                OnStateChanged(EventArgs.Empty);
            }
        }
Exemple #13
0
        public virtual void Abort()
        {
            bool raise = false;

            lock (this.syncRoot)
            {
                if (this.state == ComputationState.Running)
                {
                    this.state = ComputationState.PendingAbortion;
                    System.Threading.Interlocked.Increment(ref this.cancelling);
                    raise = true;
                }
            }
            if (raise)
            {
                this.OnStateChanged(EventArgs.Empty);
            }
        }
        public void Abort()
        {
            bool raise = false;

            lock (this.syncRoot)
            {
                if (this.state == ComputationState.Running)
                {
                    this.state = ComputationState.PendingAbortion;
                    this.Services.CancelManager.Cancel();
                    raise = true;
                }
            }
            if (raise)
            {
                this.OnStateChanged(EventArgs.Empty);
            }
        }
Exemple #15
0
        public virtual void Abort()
        {
            bool raise = false;

            lock (_syncRoot)
            {
                if (_state == ComputationState.Running)
                {
                    _state = ComputationState.PendingAbortion;
                    Interlocked.Increment(ref _cancelling);
                    raise = true;
                }
            }
            if (raise)
            {
                OnStateChanged(EventArgs.Empty);
            }
        }
Exemple #16
0
        protected void EndComputation()
        {
            lock (this.syncRoot)
            {
                switch (this.state)
                {
                case ComputationState.Running:
                    this.state = ComputationState.Finished;
                    this.OnFinished(EventArgs.Empty);
                    break;

                case ComputationState.PendingAbortion:
                    this.state = ComputationState.Aborted;
                    this.OnAborted(EventArgs.Empty);
                    break;

                default:
                    throw new InvalidOperationException();
                }
                this.cancelling = 0;
                this.OnStateChanged(EventArgs.Empty);
            }
        }
 protected void EndComputation()
 {
     lock ( syncRoot )
     {
         switch ( state )
         {
             case ComputationState.Running:
                 state = ComputationState.Finished;
                 OnFinished( EventArgs.Empty );
                 break;
             case ComputationState.PendingAbortion:
                 state = ComputationState.Aborted;
                 OnAborted( EventArgs.Empty );
                 break;
             default:
                 throw new InvalidOperationException();
         }
         cancelling = 0;
         OnStateChanged( EventArgs.Empty );
     }
 }