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
|
//===----------------------------------------------------------*- swift -*-===//
//
// This source file is part of the Swift Argument Parser open source project
//
// Copyright (c) 2020 Apple Inc. and the Swift project authors
// Licensed under Apache License v2.0 with Runtime Library Exception
//
// See https://swift.org/LICENSE.txt for license information
//
//===----------------------------------------------------------------------===//
/// Specifies where a given input came from.
///
/// When reading from the command line, a value might originate from a single
/// index, multiple indices, or from part of an index. For this command:
///
/// struct Example: ParsableCommand {
/// @Flag(name: .short) var verbose = false
/// @Flag(name: .short) var expert = false
///
/// @Option var count: Int
/// }
///
/// ...with this usage:
///
/// $ example -ve --count 5
///
/// The parsed value for the `count` property will come from indices `1` and
/// `2`, while the value for `verbose` will come from index `1`, sub-index `0`.
struct InputOrigin: Equatable, ExpressibleByArrayLiteral {
enum Element: Comparable, Hashable {
/// The input value came from a property's default value, not from a
/// command line argument.
case defaultValue
/// The input value came from the specified index in the argument string.
case argumentIndex(SplitArguments.Index)
var baseIndex: Int? {
switch self {
case .defaultValue:
return nil
case .argumentIndex(let i):
return i.inputIndex.rawValue
}
}
var subIndex: Int? {
switch self {
case .defaultValue:
return nil
case .argumentIndex(let i):
switch i.subIndex {
case .complete: return nil
case .sub(let n): return n
}
}
}
}
private var _elements: Set<Element> = []
var elements: [Element] {
Array(_elements).sorted()
}
init() {
}
init(elements: [Element]) {
_elements = Set(elements)
}
init(element: Element) {
_elements = Set([element])
}
init(arrayLiteral elements: Element...) {
self.init(elements: elements)
}
init(argumentIndex: SplitArguments.Index) {
self.init(element: .argumentIndex(argumentIndex))
}
mutating func insert(_ other: Element) {
guard !_elements.contains(other) else { return }
_elements.insert(other)
}
func inserting(_ other: Element) -> Self {
guard !_elements.contains(other) else { return self }
var result = self
result.insert(other)
return result
}
mutating func formUnion(_ other: InputOrigin) {
_elements.formUnion(other._elements)
}
func forEach(_ closure: (Element) -> Void) {
_elements.forEach(closure)
}
}
extension InputOrigin {
var isDefaultValue: Bool {
return _elements.count == 1 && _elements.first == .defaultValue
}
}
extension InputOrigin.Element {
static func < (lhs: Self, rhs: Self) -> Bool {
switch (lhs, rhs) {
case (.argumentIndex(let l), .argumentIndex(let r)):
return l < r
case (.argumentIndex, .defaultValue):
return true
case (.defaultValue, _):
return false
}
}
}
|
