bludgeon/Toolbox.cs

   1 using System;
   2 using System.Collections;
   3 using System.Reflection;
   4
   5 using Beagle.Util;
   6
   7 namespace Bludgeon {
   8
   9         public class Toolbox {
  10
  11                 private class Pair {
  12                         public HammerAttribute Attribute;
  13                         public Type Type;
  14
  15                         public IHammer CreateInstance () {
  16                                 return Activator.CreateInstance (Type) as IHammer;
  17                         }
  18                 }
  19
  20                 static ArrayList all_pairs = new ArrayList ();
  21                 static Hashtable pairs_by_name = new Hashtable ();
  22
  23                 /////////////////////////////////////////////////////
  24
  25                 private Toolbox () { } // This is a static class
  26
  27                 static Toolbox ()
  28                 {
  29                         LoadAllPairs (Assembly.GetExecutingAssembly ());
  30                 }
  31
  32                 // These are strings
  33                 static public ICollection HammerNames {
  34                         get { return pairs_by_name.Keys; }
  35                 }
  36
  37                 /////////////////////////////////////////////////////
  38
  39                 private class MixedHammer : IHammer {
  40                         Random random = new Random ();
  41                         ArrayList hammers = new ArrayList ();
  42
  43                         public void Add (IHammer hammer)
  44                         {
  45                                 hammers.Add (hammer);
  46                         }
  47
  48                         public int Count {
  49                                 get { return hammers.Count; }
  50                         }
  51
  52                         public bool HammerOnce (DirectoryObject dir, EventTracker tracker)
  53                         {
  54                                 // We randomly pick an IHammer, and call HammerOnce on it.
  55                                 // If it returns false, we try the next IHammer until we
  56                                 // find one that returns true or until we've exhausted
  57                                 // all possibilities.
  58                                 int i;
  59                                 i = random.Next (hammers.Count);
  60
  61                                 for (int j = 0; j < hammers.Count; ++j) {
  62                                         int k = (i + j) % hammers.Count;
  63                                         IHammer hammer;
  64                                         hammer = hammers [k] as IHammer;
  65                                         if (hammer.HammerOnce (dir, tracker))
  66                                                 return true;
  67                                 }
  68
  69                                 return false;
  70                         }
  71                 }
  72
  73                 static private IHammer GetMixedHammer (string name)
  74                 {
  75                         string [] parts;
  76                         parts = name.Split (',');
  77
  78                         MixedHammer mixed;
  79                         mixed = new MixedHammer ();
  80                         foreach (string part in parts) {
  81                                 IHammer hammer;
  82
  83                                 if (part.IndexOf ('*') != -1) {
  84                                         foreach (IHammer match in GetMatchingHammers (part))
  85                                                 mixed.Add (match);
  86                                         continue;
  87                                 }
  88
  89                                 hammer = GetHammer (part);
  90                                 if (hammer != null)
  91                                         mixed.Add (hammer);
  92                         }
  93
  94                         return mixed.Count > 0 ? mixed : null;
  95                 }
  96
  97                 static public IHammer GetHammer (string name)
  98                 {
  99                         if (name.IndexOf (',') != -1 || name.IndexOf ('*') != -1)
 100                                 return GetMixedHammer (name);
 101
 102                         Pair pair;
 103                         pair = pairs_by_name [name] as Pair;
 104                         if (pair == null)
 105                                 return null; // should probably throw exception
 106
 107                         return pair.CreateInstance ();
 108                 }
 109
 110                 static public ICollection GetMatchingHammers (string pattern)
 111                 {
 112                         ArrayList matches;
 113                         matches = new ArrayList ();
 114
 115                         foreach (Pair pair in all_pairs)
 116                                 if (StringFu.GlobMatch (pattern, pair.Attribute.Name))
 117                                         matches.Add (pair.CreateInstance ());
 118
 119                         return matches;
 120                 }
 121
 122                 /////////////////////////////////////////////////////
 123
 124                 // Yuck.
 125
 126                 static bool ThisApiSoVeryIsBroken (Type m, object criteria)
 127                 {
 128                         return m == (Type) criteria;
 129                 }
 130
 131                 static bool TypeImplementsInterface (Type t, Type iface)
 132                 {
 133                         Type[] impls = t.FindInterfaces (new TypeFilter (ThisApiSoVeryIsBroken),
 134                                                          iface);
 135                         return impls.Length > 0;
 136                 }
 137
 138                 static private void LoadAllPairs (Assembly assembly)
 139                 {
 140                         foreach (Type type in assembly.GetTypes ()) {
 141
 142                                 if (TypeImplementsInterface (type, typeof (IHammer))) {
 143
 144                                         object [] attributes;
 145                                         attributes = Attribute.GetCustomAttributes (type);
 146
 147                                         foreach (object obj in attributes) {
 148                                                 HammerAttribute attr;
 149                                                 attr = obj as HammerAttribute;
 150                                                 if (attr != null) {
 151
 152                                                         Pair pair;
 153                                                         pair = new Pair ();
 154                                                         pair.Attribute = attr;
 155                                                         pair.Type = type;
 156
 157                                                         all_pairs.Add (pair);
 158                                                         pairs_by_name [pair.Attribute.Name] = pair;
 159
 160                                                         break;
 161                                                 }
 162                                         }
 163                                 }
 164                         }
 165                 }
 166         }
 167 }