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