extras/MonoDevelop.Debugger.Mdb/Mono.Debugging.Server.Mdb/AsyncEvaluationTracker.cs

   1 // AsyncEvaluationTracker.cs
   2 //
   3 // Author:
   4 //   Lluis Sanchez Gual <lluis@novell.com>
   5 //
   6 // Copyright (c) 2008 Novell, Inc (http://www.novell.com)
   7 //
   8 // Permission is hereby granted, free of charge, to any person obtaining a copy
   9 // of this software and associated documentation files (the "Software"), to deal
  10 // in the Software without restriction, including without limitation the rights
  11 // to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
  12 // copies of the Software, and to permit persons to whom the Software is
  13 // furnished to do so, subject to the following conditions:
  14 //
  15 // The above copyright notice and this permission notice shall be included in
  16 // all copies or substantial portions of the Software.
  17 //
  18 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  19 // IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  20 // FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
  21 // AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  22 // LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
  23 // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
  24 // THE SOFTWARE.
  25 //
  26 //
  27
  28 using System;
  29 using System.Collections.Generic;
  30 using Mono.Debugging.Client;
  31 using Mono.Debugging.Backend;
  32
  33 namespace DebuggerServer
  34 {
  35         public delegate ObjectValue ObjectEvaluatorDelegate ();
  36
  37         public class AsyncEvaluationTracker: RemoteFrameObject, IObjectValueUpdater
  38         {
  39                 Dictionary<string, UpdateCallback> asyncCallbacks = new Dictionary<string, UpdateCallback> ();
  40                 Dictionary<string, ObjectValue> asyncResults = new Dictionary<string, ObjectValue> ();
  41                 int asyncCounter = 0;
  42                 int cancelTimestamp = 0;
  43                 TimedEvaluator runner = new TimedEvaluator ();
  44
  45                 public ObjectValue Run (string name, ObjectValueFlags flags, ObjectEvaluatorDelegate evaluator)
  46                 {
  47                         string id;
  48                         int tid;
  49                         lock (asyncCallbacks) {
  50                                 tid = asyncCounter++;
  51                                 id = tid.ToString ();
  52                         }
  53
  54                         ObjectValue val = null;
  55                         bool done = runner.Run (delegate {
  56                                         if (tid >= cancelTimestamp)
  57                                                 val = evaluator ();
  58                         },
  59                         delegate {
  60                                 if (tid >= cancelTimestamp)
  61                                         OnEvaluationDone (id, val);
  62                         });
  63
  64                         if (done)
  65                                 return val;
  66                         else
  67                                 return ObjectValue.CreateEvaluating (this, new ObjectPath (id, name), flags);
  68                 }
  69
  70                 public void Stop ()
  71                 {
  72                         lock (asyncCallbacks) {
  73                                 cancelTimestamp = asyncCounter;
  74                                 runner.CancelAll ();
  75                                 asyncCallbacks.Clear ();
  76                                 asyncResults.Clear ();
  77                         }
  78                 }
  79
  80                 public void WaitForStopped ()
  81                 {
  82                         runner.WaitForStopped ();
  83                 }
  84
  85                 void OnEvaluationDone (string id, ObjectValue val)
  86                 {
  87                         if (val == null)
  88                                 val = ObjectValue.CreateUnknown (null);
  89                         UpdateCallback cb = null;
  90                         lock (asyncCallbacks) {
  91                                 if (asyncCallbacks.TryGetValue (id, out cb)) {
  92                                         cb.UpdateValue (val);
  93                                         asyncCallbacks.Remove (id);
  94                                 }
  95                                 else
  96                                         asyncResults [id] = val;
  97                         }
  98                 }
  99
 100                 void IObjectValueUpdater.RegisterUpdateCallbacks (UpdateCallback[] callbacks)
 101                 {
 102                         foreach (UpdateCallback c in callbacks) {
 103                                 lock (asyncCallbacks) {
 104                                         ObjectValue val;
 105                                         string id = c.Path[0];
 106                                         if (asyncResults.TryGetValue (id, out val)) {
 107                                                 c.UpdateValue (val);
 108                                                 asyncResults.Remove (id);
 109                                         } else {
 110                                                 asyncCallbacks [id] = c;
 111                                         }
 112                                 }
 113                         }
 114                 }
 115         }
 116 }