main
1// Copyright (c) 2015, Emir Pasic. All rights reserved.
2// Use of this source code is governed by a BSD-style
3// license that can be found in the LICENSE file.
4
5package utils
6
7import "time"
8
9// Comparator will make type assertion (see IntComparator for example),
10// which will panic if a or b are not of the asserted type.
11//
12// Should return a number:
13// negative , if a < b
14// zero , if a == b
15// positive , if a > b
16type Comparator func(a, b interface{}) int
17
18// StringComparator provides a fast comparison on strings
19func StringComparator(a, b interface{}) int {
20 s1 := a.(string)
21 s2 := b.(string)
22 min := len(s2)
23 if len(s1) < len(s2) {
24 min = len(s1)
25 }
26 diff := 0
27 for i := 0; i < min && diff == 0; i++ {
28 diff = int(s1[i]) - int(s2[i])
29 }
30 if diff == 0 {
31 diff = len(s1) - len(s2)
32 }
33 if diff < 0 {
34 return -1
35 }
36 if diff > 0 {
37 return 1
38 }
39 return 0
40}
41
42// IntComparator provides a basic comparison on int
43func IntComparator(a, b interface{}) int {
44 aAsserted := a.(int)
45 bAsserted := b.(int)
46 switch {
47 case aAsserted > bAsserted:
48 return 1
49 case aAsserted < bAsserted:
50 return -1
51 default:
52 return 0
53 }
54}
55
56// Int8Comparator provides a basic comparison on int8
57func Int8Comparator(a, b interface{}) int {
58 aAsserted := a.(int8)
59 bAsserted := b.(int8)
60 switch {
61 case aAsserted > bAsserted:
62 return 1
63 case aAsserted < bAsserted:
64 return -1
65 default:
66 return 0
67 }
68}
69
70// Int16Comparator provides a basic comparison on int16
71func Int16Comparator(a, b interface{}) int {
72 aAsserted := a.(int16)
73 bAsserted := b.(int16)
74 switch {
75 case aAsserted > bAsserted:
76 return 1
77 case aAsserted < bAsserted:
78 return -1
79 default:
80 return 0
81 }
82}
83
84// Int32Comparator provides a basic comparison on int32
85func Int32Comparator(a, b interface{}) int {
86 aAsserted := a.(int32)
87 bAsserted := b.(int32)
88 switch {
89 case aAsserted > bAsserted:
90 return 1
91 case aAsserted < bAsserted:
92 return -1
93 default:
94 return 0
95 }
96}
97
98// Int64Comparator provides a basic comparison on int64
99func Int64Comparator(a, b interface{}) int {
100 aAsserted := a.(int64)
101 bAsserted := b.(int64)
102 switch {
103 case aAsserted > bAsserted:
104 return 1
105 case aAsserted < bAsserted:
106 return -1
107 default:
108 return 0
109 }
110}
111
112// UIntComparator provides a basic comparison on uint
113func UIntComparator(a, b interface{}) int {
114 aAsserted := a.(uint)
115 bAsserted := b.(uint)
116 switch {
117 case aAsserted > bAsserted:
118 return 1
119 case aAsserted < bAsserted:
120 return -1
121 default:
122 return 0
123 }
124}
125
126// UInt8Comparator provides a basic comparison on uint8
127func UInt8Comparator(a, b interface{}) int {
128 aAsserted := a.(uint8)
129 bAsserted := b.(uint8)
130 switch {
131 case aAsserted > bAsserted:
132 return 1
133 case aAsserted < bAsserted:
134 return -1
135 default:
136 return 0
137 }
138}
139
140// UInt16Comparator provides a basic comparison on uint16
141func UInt16Comparator(a, b interface{}) int {
142 aAsserted := a.(uint16)
143 bAsserted := b.(uint16)
144 switch {
145 case aAsserted > bAsserted:
146 return 1
147 case aAsserted < bAsserted:
148 return -1
149 default:
150 return 0
151 }
152}
153
154// UInt32Comparator provides a basic comparison on uint32
155func UInt32Comparator(a, b interface{}) int {
156 aAsserted := a.(uint32)
157 bAsserted := b.(uint32)
158 switch {
159 case aAsserted > bAsserted:
160 return 1
161 case aAsserted < bAsserted:
162 return -1
163 default:
164 return 0
165 }
166}
167
168// UInt64Comparator provides a basic comparison on uint64
169func UInt64Comparator(a, b interface{}) int {
170 aAsserted := a.(uint64)
171 bAsserted := b.(uint64)
172 switch {
173 case aAsserted > bAsserted:
174 return 1
175 case aAsserted < bAsserted:
176 return -1
177 default:
178 return 0
179 }
180}
181
182// Float32Comparator provides a basic comparison on float32
183func Float32Comparator(a, b interface{}) int {
184 aAsserted := a.(float32)
185 bAsserted := b.(float32)
186 switch {
187 case aAsserted > bAsserted:
188 return 1
189 case aAsserted < bAsserted:
190 return -1
191 default:
192 return 0
193 }
194}
195
196// Float64Comparator provides a basic comparison on float64
197func Float64Comparator(a, b interface{}) int {
198 aAsserted := a.(float64)
199 bAsserted := b.(float64)
200 switch {
201 case aAsserted > bAsserted:
202 return 1
203 case aAsserted < bAsserted:
204 return -1
205 default:
206 return 0
207 }
208}
209
210// ByteComparator provides a basic comparison on byte
211func ByteComparator(a, b interface{}) int {
212 aAsserted := a.(byte)
213 bAsserted := b.(byte)
214 switch {
215 case aAsserted > bAsserted:
216 return 1
217 case aAsserted < bAsserted:
218 return -1
219 default:
220 return 0
221 }
222}
223
224// RuneComparator provides a basic comparison on rune
225func RuneComparator(a, b interface{}) int {
226 aAsserted := a.(rune)
227 bAsserted := b.(rune)
228 switch {
229 case aAsserted > bAsserted:
230 return 1
231 case aAsserted < bAsserted:
232 return -1
233 default:
234 return 0
235 }
236}
237
238// TimeComparator provides a basic comparison on time.Time
239func TimeComparator(a, b interface{}) int {
240 aAsserted := a.(time.Time)
241 bAsserted := b.(time.Time)
242
243 switch {
244 case aAsserted.After(bAsserted):
245 return 1
246 case aAsserted.Before(bAsserted):
247 return -1
248 default:
249 return 0
250 }
251}