Skip to content

Commit 89f24ca

Browse files
oschrenkoschrenk
committed
♻️ Split up OrderComparator
1 parent 66e3bcb commit 89f24ca

File tree

2 files changed

+142
-65
lines changed

2 files changed

+142
-65
lines changed

‎Sources/Model/Order.swift

-65
Original file line numberDiff line numberDiff line change
@@ -63,68 +63,3 @@ final class Order: ArgumentParser.ExpressibleByArgument, Hashable {
6363
enum Direction: String, ExpressibleByArgument {
6464
case asc, desc
6565
}
66-
67-
class OrderComparator: SortComparator {
68-
let field: String
69-
var order: SortOrder
70-
71-
init(order: Order) {
72-
field = order.field
73-
if order.direction == Direction.asc {
74-
self.order = SortOrder.forward
75-
} else {
76-
self.order = SortOrder.reverse
77-
}
78-
}
79-
80-
func hash(into hasher: inout Hasher) {
81-
hasher.combine(field)
82-
hasher.combine(order)
83-
}
84-
85-
static func == (lhs: OrderComparator, rhs: OrderComparator) -> Bool {
86-
return lhs.field == rhs.field
87-
}
88-
89-
func compare(_ lhs: Event, _ rhs: Event) -> ComparisonResult {
90-
let maybeLeftV = try? Object.valueForKeyPath(lhs, field)
91-
let maybeRightV = try? Object.valueForKeyPath(rhs, field)
92-
93-
switch (maybeLeftV, maybeRightV) {
94-
case let (.some(leftV), .some(rightV)):
95-
if let leftValue = leftV as? Int, let rightValue = rightV as? Int {
96-
if leftValue < rightValue {
97-
return .orderedAscending
98-
} else if leftValue > rightValue {
99-
return .orderedDescending
100-
} else {
101-
return .orderedSame
102-
}
103-
} else if let leftValue = leftV as? String, let rightValue = rightV as? String {
104-
if leftValue < rightValue {
105-
return .orderedAscending
106-
} else if leftValue > rightValue {
107-
return .orderedDescending
108-
} else {
109-
return .orderedSame
110-
}
111-
} else if let leftValue = leftV as? Date, let rightValue = rightV as? Date {
112-
if leftValue < rightValue {
113-
return .orderedAscending
114-
} else if leftValue > rightValue {
115-
return .orderedDescending
116-
} else {
117-
return .orderedSame
118-
}
119-
} else {
120-
// not future proof
121-
// we might silently sort on new non-existing types
122-
return .orderedSame
123-
}
124-
default:
125-
// not future proof
126-
// we might silently sort on new non-existing types
127-
return .orderedSame
128-
}
129-
}
130-
}

‎Sources/Model/OrderComparator.swift

+142
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,142 @@
1+
import Foundation
2+
3+
class OrderComparator: SortComparator {
4+
let field: String
5+
var order: SortOrder
6+
7+
init(order: Order) {
8+
field = order.field
9+
if order.direction == Direction.asc {
10+
self.order = SortOrder.forward
11+
} else {
12+
self.order = SortOrder.reverse
13+
}
14+
}
15+
16+
func hash(into hasher: inout Hasher) {
17+
hasher.combine(field)
18+
hasher.combine(order)
19+
}
20+
21+
static func == (lhs: OrderComparator, rhs: OrderComparator) -> Bool {
22+
return lhs.field == rhs.field
23+
}
24+
25+
func compare(_ lhs: Event, _ rhs: Event) -> ComparisonResult {
26+
let maybeLeftV = try? Object.valueForKeyPath(lhs, field)
27+
let maybeRightV = try? Object.valueForKeyPath(rhs, field)
28+
29+
switch (maybeLeftV, maybeRightV) {
30+
case let (.some(leftV), .some(rightV)):
31+
if let leftValue = leftV as? Int, let rightValue = rightV as? Int {
32+
return IntComparator(order: order).compare(leftValue, rightValue)
33+
} else if let leftValue = leftV as? String, let rightValue = rightV as? String {
34+
return StringComparator(order: order).compare(leftValue, rightValue)
35+
} else if let leftValue = leftV as? Date, let rightValue = rightV as? Date {
36+
return DateComparator(order: order).compare(leftValue, rightValue)
37+
} else {
38+
// not future proof
39+
// we might silently sort on new non-existing types
40+
return .orderedSame
41+
}
42+
default:
43+
// not future proof
44+
// we might silently sort on new non-existing types
45+
return .orderedSame
46+
}
47+
}
48+
}
49+
50+
class IntComparator: SortComparator, Hashable {
51+
var order: SortOrder
52+
53+
init(order: SortOrder) {
54+
self.order = order
55+
}
56+
57+
func hash(into hasher: inout Hasher) {
58+
hasher.combine(order)
59+
}
60+
61+
static func == (lhs: IntComparator, rhs: IntComparator) -> Bool {
62+
return lhs.order == rhs.order
63+
}
64+
65+
func compare(_ lhs: Int, _ rhs: Int) -> ComparisonResult {
66+
let result: ComparisonResult
67+
if lhs < rhs {
68+
result = .orderedAscending
69+
} else if lhs > rhs {
70+
result = .orderedDescending
71+
} else {
72+
result = .orderedSame
73+
}
74+
return order == .forward ? result : result.reversed
75+
}
76+
}
77+
78+
class StringComparator: SortComparator, Hashable {
79+
var order: SortOrder
80+
81+
init(order: SortOrder) {
82+
self.order = order
83+
}
84+
85+
func hash(into hasher: inout Hasher) {
86+
hasher.combine(order)
87+
}
88+
89+
static func == (lhs: StringComparator, rhs: StringComparator) -> Bool {
90+
return lhs.order == rhs.order
91+
}
92+
93+
func compare(_ lhs: String, _ rhs: String) -> ComparisonResult {
94+
let result: ComparisonResult
95+
if lhs < rhs {
96+
result = .orderedAscending
97+
} else if lhs > rhs {
98+
result = .orderedDescending
99+
} else {
100+
result = .orderedSame
101+
}
102+
return order == .forward ? result : result.reversed
103+
}
104+
}
105+
106+
class DateComparator: SortComparator, Hashable {
107+
var order: SortOrder
108+
109+
init(order: SortOrder) {
110+
self.order = order
111+
}
112+
113+
func hash(into hasher: inout Hasher) {
114+
hasher.combine(order)
115+
}
116+
117+
static func == (lhs: DateComparator, rhs: DateComparator) -> Bool {
118+
return lhs.order == rhs.order
119+
}
120+
121+
func compare(_ lhs: Date, _ rhs: Date) -> ComparisonResult {
122+
let result: ComparisonResult
123+
if lhs < rhs {
124+
result = .orderedAscending
125+
} else if lhs > rhs {
126+
result = .orderedDescending
127+
} else {
128+
result = .orderedSame
129+
}
130+
return order == .forward ? result : result.reversed
131+
}
132+
}
133+
134+
extension ComparisonResult {
135+
var reversed: ComparisonResult {
136+
switch self {
137+
case .orderedAscending: return .orderedDescending
138+
case .orderedSame: return .orderedSame
139+
case .orderedDescending: return .orderedAscending
140+
}
141+
}
142+
}

0 commit comments

Comments
 (0)