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
|
/*
This source file is part of the Swift.org open source project
Copyright (c) 2022 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
See https://swift.org/CONTRIBUTORS.txt for Swift project authors
*/
import Foundation
protocol _ChildDirectiveProtocol {
var storedAsArray: Bool { get }
var storedAsOptional: Bool { get }
var requirements: ChildDirectiveRequirements { get }
var directiveConvertible: DirectiveConvertible.Type { get }
func setProperty(
on containingDirective: some AutomaticDirectiveConvertible,
named propertyName: String,
to any: Any
)
}
enum ChildDirectiveRequirements {
case zeroOrOne
case one
case zeroOrMore
case oneOrMore
}
/// A property wrapper that represents a child directive.
///
/// This property wrapper is used internally in Swift-DocC when declaring directives
/// that support specific child directives.
///
/// class Row: Semantic, AutomaticDirectiveConvertible {
/// let originalMarkup: BlockDirective
///
/// @ChildDirective
/// private(set) var columns: [Column]
///
/// static var keyPaths: [String : AnyKeyPath] = [
/// "columns" : \Row._columns,
/// ]
///
/// init(originalMarkup: BlockDirective) {
/// self.originalMarkup = originalMarkup
/// }
/// }
///
/// > Warning: This property wrapper is exposed as public API of SwiftDocC so that clients
/// > have access to its projected value, but it is unsupported to attach this property
/// > wrapper to new declarations outside of SwiftDocC.
@propertyWrapper
public struct ChildDirective<Value>: _ChildDirectiveProtocol {
let storedAsArray: Bool
let storedAsOptional: Bool
var parsedValue: Value?
let requirements: ChildDirectiveRequirements
let directiveConvertible: DirectiveConvertible.Type
public var wrappedValue: Value {
get {
parsedValue!
}
set {
parsedValue = newValue
}
}
@available(*, unavailable,
message: "The value type must conform to 'DirectiveConvertible'."
)
public init() {
fatalError()
}
func setProperty<T>(
on containingDirective: T,
named propertyName: String,
to any: Any
) where T: AutomaticDirectiveConvertible {
let path = T.keyPaths[propertyName] as! ReferenceWritableKeyPath<T, ChildDirective<Value>>
let wrappedValuePath = path.appending(path: \Self.parsedValue)
containingDirective[keyPath: wrappedValuePath] = any as! Value?
}
}
extension ChildDirective where Value: DirectiveConvertible {
init() {
self.parsedValue = nil
self.requirements = .one
self.storedAsOptional = false
self.storedAsArray = false
self.directiveConvertible = Value.self
}
}
protocol OptionallyWrappedDirectiveConvertible: OptionallyWrapped {}
extension Optional: OptionallyWrappedDirectiveConvertible where Wrapped: DirectiveConvertible {}
extension ChildDirective where Value: OptionallyWrappedDirectiveConvertible {
init(wrappedValue: Value, requirements: ChildDirectiveRequirements = .zeroOrOne) {
self.parsedValue = wrappedValue
self.requirements = requirements
self.storedAsOptional = true
self.storedAsArray = false
self.directiveConvertible = Value.baseType() as! DirectiveConvertible.Type
}
}
protocol CollectionWrappedDirectiveConvertible: CollectionWrapped {}
extension Array: CollectionWrappedDirectiveConvertible where Element: DirectiveConvertible {}
extension ChildDirective where Value: CollectionWrappedDirectiveConvertible {
init(requirements: ChildDirectiveRequirements = .zeroOrMore) {
self.parsedValue = nil
self.requirements = requirements
self.storedAsOptional = false
self.storedAsArray = true
self.directiveConvertible = Value.baseType() as! DirectiveConvertible.Type
}
}
protocol OptionallyWrappedCollectionWrappedDirectiveConvertible: OptionallyWrapped {}
extension Optional: OptionallyWrappedCollectionWrappedDirectiveConvertible where Wrapped: CollectionWrapped {}
extension ChildDirective where Value: OptionallyWrappedCollectionWrappedDirectiveConvertible {
init(wrappedValue: Value) {
self.parsedValue = wrappedValue
self.requirements = .zeroOrMore
self.storedAsOptional = true
self.storedAsArray = true
self.directiveConvertible = (Value.baseType() as! CollectionWrapped.Type).baseType() as! DirectiveConvertible.Type
}
}
|
