search/SortedTileList.cs

   1 using System;
   2 using System.Collections;
   3
   4 namespace Search {
   5
   6         public class SortedTileList : IEnumerable, ICloneable {
   7
   8                 ArrayList tiles;
   9
  10                 public SortedTileList (Search.SortType sort) : this (sort, new ArrayList ()) {}
  11
  12                 SortedTileList (Search.SortType sort, ArrayList tiles)
  13                 {
  14                         this.tiles = tiles;
  15                         Sort = sort;
  16                 }
  17
  18                 public int Add (Tiles.Tile tile)
  19                 {
  20                         int index = tiles.BinarySearch (tile, comparer);
  21                         if (index >= 0)
  22                                 throw new ArgumentException ("duplicate");
  23
  24                         tiles.Insert (~index, tile);
  25                         return ~index;
  26                 }
  27
  28                 public void Clear ()
  29                 {
  30                         tiles.Clear ();
  31                 }
  32
  33                 public bool Contains (Tiles.Tile tile)
  34                 {
  35                         return tiles.Contains (tile);
  36                 }
  37
  38                 public int IndexOf (Tiles.Tile tile)
  39                 {
  40                         return tiles.IndexOf (tile);
  41                 }
  42
  43                 public void Remove (Tiles.Tile tile)
  44                 {
  45                         int index = tiles.BinarySearch (tile, comparer);
  46                         if (index >= 0)
  47                                 tiles.RemoveAt (index);
  48                 }
  49
  50                 public void RemoveAt (int index)
  51                 {
  52                         tiles.RemoveAt (index);
  53                 }
  54
  55                 public Tiles.Tile this[int index] {
  56                         get {
  57                                 return (Tiles.Tile)tiles[index];
  58                         }
  59                 }
  60
  61                 public int Count {
  62                         get {
  63                                 return tiles.Count;
  64                         }
  65                 }
  66
  67                 public IEnumerator GetEnumerator ()
  68                 {
  69                         return tiles.GetEnumerator ();
  70                 }
  71
  72                 public object Clone ()
  73                 {
  74                         return new SortedTileList (sort, (ArrayList)tiles.Clone ());
  75                 }
  76
  77                 public IList GetRange (int index, int count)
  78                 {
  79                         return tiles.GetRange (index, count);
  80                 }
  81
  82                 Search.SortType sort;
  83                 IComparer comparer;
  84
  85                 public Search.SortType Sort {
  86                         get {
  87                                 return sort;
  88                         }
  89                         set {
  90                                 sort = value;
  91                                 switch (sort) {
  92                                 case SortType.Relevance:
  93                                 default:
  94                                         comparer = new RelevanceComparer ();
  95                                         break;
  96                                 case SortType.Name:
  97                                         comparer = new NameComparer ();
  98                                         break;
  99                                 case SortType.Modified:
 100                                         comparer = new DateComparer ();
 101                                         break;
 102                                 }
 103
 104                                 tiles.Sort (comparer);
 105                         }
 106                 }
 107         }
 108
 109         abstract class TileComparer : IComparer {
 110                 public int Compare (object x, object y)
 111                 {
 112                         Tiles.Tile tx = (Tiles.Tile)x, ty = (Tiles.Tile)y;
 113                         int ret;
 114
 115                         ret = Compare (tx, ty);
 116                         if (ret == 0)
 117                                 ret = -tx.Timestamp.CompareTo (ty.Timestamp);
 118                         if (ret == 0)
 119                                 ret = tx.GetHashCode ().CompareTo (ty.GetHashCode ());
 120                         return ret;
 121                 }
 122
 123                 public abstract int Compare (Tiles.Tile tx, Tiles.Tile ty);
 124         }
 125
 126         class RelevanceComparer : TileComparer {
 127                 public override int Compare (Tiles.Tile tx, Tiles.Tile ty)
 128                 {
 129                         return -tx.Score.CompareTo (ty.Score);
 130                 }
 131         }
 132
 133         class NameComparer : TileComparer {
 134                 public override int Compare (Tiles.Tile tx, Tiles.Tile ty)
 135                 {
 136                         return String.Compare (tx.Title, ty.Title, true);
 137                 }
 138         }
 139
 140         class DateComparer : TileComparer {
 141                 public override int Compare (Tiles.Tile tx, Tiles.Tile ty)
 142                 {
 143                         return -tx.Timestamp.CompareTo (ty.Timestamp);
 144                 }
 145         }
 146 }