1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16 package org.joda.time;
17
18 import java.io.Serializable;
19 import java.util.Comparator;
20
21 import org.joda.time.convert.ConverterManager;
22 import org.joda.time.convert.InstantConverter;
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 public class DateTimeComparator implements Comparator<Object>, Serializable {
49
50
51 private static final long serialVersionUID = -6097339773320178364L;
52
53
54 private static final DateTimeComparator ALL_INSTANCE = new DateTimeComparator(null, null);
55
56 private static final DateTimeComparator DATE_INSTANCE = new DateTimeComparator(DateTimeFieldType.dayOfYear(), null);
57
58 private static final DateTimeComparator TIME_INSTANCE = new DateTimeComparator(null, DateTimeFieldType.dayOfYear());
59
60
61 private final DateTimeFieldType iLowerLimit;
62
63 private final DateTimeFieldType iUpperLimit;
64
65
66
67
68
69
70
71 public static DateTimeComparator getInstance() {
72 return ALL_INSTANCE;
73 }
74
75
76
77
78
79
80
81
82 public static DateTimeComparator getInstance(DateTimeFieldType lowerLimit) {
83 return getInstance(lowerLimit, null);
84 }
85
86
87
88
89
90
91
92
93
94
95
96
97 public static DateTimeComparator getInstance(DateTimeFieldType lowerLimit, DateTimeFieldType upperLimit) {
98 if (lowerLimit == null && upperLimit == null) {
99 return ALL_INSTANCE;
100 }
101 if (lowerLimit == DateTimeFieldType.dayOfYear() && upperLimit == null) {
102 return DATE_INSTANCE;
103 }
104 if (lowerLimit == null && upperLimit == DateTimeFieldType.dayOfYear()) {
105 return TIME_INSTANCE;
106 }
107 return new DateTimeComparator(lowerLimit, upperLimit);
108 }
109
110
111
112
113
114
115
116 public static DateTimeComparator getDateOnlyInstance() {
117 return DATE_INSTANCE;
118 }
119
120
121
122
123
124
125
126 public static DateTimeComparator getTimeOnlyInstance() {
127 return TIME_INSTANCE;
128 }
129
130
131
132
133
134
135
136 protected DateTimeComparator(DateTimeFieldType lowerLimit, DateTimeFieldType upperLimit) {
137 super();
138 iLowerLimit = lowerLimit;
139 iUpperLimit = upperLimit;
140 }
141
142
143
144
145
146
147
148 public DateTimeFieldType getLowerLimit() {
149 return iLowerLimit;
150 }
151
152
153
154
155
156
157 public DateTimeFieldType getUpperLimit() {
158 return iUpperLimit;
159 }
160
161
162
163
164
165
166
167
168
169
170
171
172
173 public int compare(Object lhsObj, Object rhsObj) {
174 InstantConverter conv = ConverterManager.getInstance().getInstantConverter(lhsObj);
175 Chronology lhsChrono = conv.getChronology(lhsObj, (Chronology) null);
176 long lhsMillis = conv.getInstantMillis(lhsObj, lhsChrono);
177
178 conv = ConverterManager.getInstance().getInstantConverter(rhsObj);
179 Chronology rhsChrono = conv.getChronology(rhsObj, (Chronology) null);
180 long rhsMillis = conv.getInstantMillis(rhsObj, rhsChrono);
181
182 if (iLowerLimit != null) {
183 lhsMillis = iLowerLimit.getField(lhsChrono).roundFloor(lhsMillis);
184 rhsMillis = iLowerLimit.getField(rhsChrono).roundFloor(rhsMillis);
185 }
186
187 if (iUpperLimit != null) {
188 lhsMillis = iUpperLimit.getField(lhsChrono).remainder(lhsMillis);
189 rhsMillis = iUpperLimit.getField(rhsChrono).remainder(rhsMillis);
190 }
191
192 if (lhsMillis < rhsMillis) {
193 return -1;
194 } else if (lhsMillis > rhsMillis) {
195 return 1;
196 } else {
197 return 0;
198 }
199 }
200
201
202
203
204
205
206
207 private Object readResolve() {
208 return getInstance(iLowerLimit, iUpperLimit);
209 }
210
211
212
213
214
215
216
217 public boolean equals(Object object) {
218 if (object instanceof DateTimeComparator) {
219 DateTimeComparator other = (DateTimeComparator) object;
220 return (iLowerLimit == other.getLowerLimit() ||
221 (iLowerLimit != null && iLowerLimit.equals(other.getLowerLimit()))) &&
222 (iUpperLimit == other.getUpperLimit() ||
223 (iUpperLimit != null && iUpperLimit.equals(other.getUpperLimit())));
224 }
225 return false;
226 }
227
228
229
230
231
232
233 public int hashCode() {
234 return (iLowerLimit == null ? 0 : iLowerLimit.hashCode()) +
235 (123 * (iUpperLimit == null ? 0 : iUpperLimit.hashCode()));
236 }
237
238
239
240
241
242
243 public String toString() {
244 if (iLowerLimit == iUpperLimit) {
245 return "DateTimeComparator["
246 + (iLowerLimit == null ? "" : iLowerLimit.getName())
247 + "]";
248 } else {
249 return "DateTimeComparator["
250 + (iLowerLimit == null ? "" : iLowerLimit.getName())
251 + "-"
252 + (iUpperLimit == null ? "" : iUpperLimit.getName())
253 + "]";
254 }
255 }
256
257 }