mcs/class/System/System.Text.RegularExpressions/cache.cs

   1 //
   2 // assembly:    System
   3 // namespace:   System.Text.RegularExpressions
   4 // file:        cache.cs
   5 //
   6 // author:      Dan Lewis (dlewis@gmx.co.uk)
   7 //              (c) 2002
   8
   9 //
  10 // Permission is hereby granted, free of charge, to any person obtaining
  11 // a copy of this software and associated documentation files (the
  12 // "Software"), to deal in the Software without restriction, including
  13 // without limitation the rights to use, copy, modify, merge, publish,
  14 // distribute, sublicense, and/or sell copies of the Software, and to
  15 // permit persons to whom the Software is furnished to do so, subject to
  16 // the following conditions:
  17 //
  18 // The above copyright notice and this permission notice shall be
  19 // included in all copies or substantial portions of the Software.
  20 //
  21 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
  22 // EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  23 // MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
  24 // NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
  25 // LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
  26 // OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
  27 // WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  28 //
  29
  30 using System;
  31 using System.Collections;
  32
  33 namespace System.Text.RegularExpressions {
  34
  35         class FactoryCache {
  36                 public FactoryCache (int capacity) {
  37                         this.capacity = capacity;
  38                         this.factories = new Hashtable (capacity);
  39                         this.mru_list = new MRUList ();
  40                 }
  41
  42                 public void Add (string pattern, RegexOptions options, IMachineFactory factory) {
  43                         lock (this) {
  44                                 Key k = new Key (pattern, options);
  45
  46                                 while (factories.Count >= capacity) {
  47                                         object victim = mru_list.Evict ();
  48                                         if (victim != null)
  49                                                 factories.Remove ((Key)victim);
  50                                 }
  51
  52                                 factories[k] = factory;
  53                                 mru_list.Use (k);
  54                         }
  55                 }
  56
  57                 public IMachineFactory Lookup (string pattern, RegexOptions options) {
  58                         lock (this) {
  59                                 Key k = new Key (pattern, options);
  60                                 if (factories.Contains (k)) {
  61                                         mru_list.Use (k);
  62                                         return (IMachineFactory)factories[k];
  63                                 }
  64                         }
  65
  66                         return null;
  67                 }
  68
  69                 private int capacity;
  70                 private Hashtable factories;
  71                 private MRUList mru_list;
  72
  73                 class Key {
  74                         public string pattern;
  75                         public RegexOptions options;
  76
  77                         public Key (string pattern, RegexOptions options) {
  78                                 this.pattern = pattern;
  79                                 this.options = options;
  80                         }
  81
  82                         public override int GetHashCode () {
  83                                 return pattern.GetHashCode () ^ (int)options;
  84                         }
  85
  86                         public override bool Equals (object o) {
  87                                 if (o == null || !(o is Key))
  88                                         return false;
  89
  90                                 Key k = (Key)o;
  91                                 return options == k.options && pattern.Equals (k.pattern);
  92                         }
  93
  94                         public override string ToString () {
  95                                 return "('" + pattern + "', [" + options + "])";
  96                         }
  97                 }
  98         }
  99
 100         class MRUList {
 101                 public MRUList () {
 102                         head = tail = null;
 103                 }
 104
 105                 public void Use (object o) {
 106                         Node node;
 107
 108                         if (head == null) {
 109                                 node = new Node (o);
 110                                 head = tail = node;
 111                                 return;
 112                         }
 113
 114                         node = head;
 115                         while (node != null && !o.Equals (node.value))
 116                                 node = node.previous;
 117
 118                         if (node == null)
 119                                 node = new Node (o);
 120                         else {
 121                                 if (node == head)
 122                                         return;
 123
 124                                 if (node == tail)
 125                                         tail = node.next;
 126                                 else
 127                                         node.previous.next = node.next;
 128
 129                                 node.next.previous = node.previous;
 130                         }
 131
 132                         head.next = node;
 133                         node.previous = head;
 134                         node.next = null;
 135                         head = node;
 136                 }
 137
 138                 public object Evict () {
 139                         if (tail == null)
 140                                 return null;
 141
 142                         object o = tail.value;
 143                         tail = tail.next;
 144
 145                         if (tail == null)
 146                                 head = null;
 147                         else
 148                                 tail.previous = null;
 149
 150                         return o;
 151                 }
 152
 153                 private Node head, tail;
 154
 155                 private class Node {
 156                         public object value;
 157                         public Node previous, next;
 158
 159                         public Node (object value) {
 160                                 this.value = value;
 161                         }
 162                 }
 163         }
 164 }