How to access inner object's properties from superclass without boilerplate - swift

Question

Is there a way to create accessors of inner object properties without having boilerplate?
Here's an example of a class with the boilerplate
public class Foo {
internal let bar: Bar
internal init(bar: Bar) {
self.bar = bar
}
private struct Bar: Codable {
let id: Int
let name: String
}
// MARK: - Boilerplate
public var id: Int {
return self.bar.id
}
public var name: String {
return self.bar.name
}
}
// Usage
do {
let bar: Bar = try data.decoded()
let foo = Foo(bar: bar)
print(foo.id)
print(foo.name)
} catch {
...
}
Is there a way to do this without having to write the boilerplate? For larger objects with more properties this could be really helpful
Take Note: The Access Control Modifiers are important

Answer 1

New in Swift 5.1, you can use dynamic member lookup with a key path. This works brilliantly for this sort of "has-a" situation, because key paths maintain full type checking. Here's a simplified example (with no attempt to mirror your actual situation):
struct Dog {
let name : String
}
#dynamicMemberLookup
struct Kennel {
let dog : Dog
subscript(dynamicMember kp:KeyPath<Dog,String>) -> String {
self.dog[keyPath:kp]
}
}
The result is that, given a Kennel k, we can get k.name as a way of getting k.dog.name.
But saying k.xxx would be illegal, because a Dog has no String xxx property; that's what I mean when I say that full type checking is maintained.
The old way would be to use protocols. That way you can use protocol extension to inject the boilerplate.
protocol HasNameAndId {
var id: Int {get}
var name: String {get}
}
protocol WrapperOfHasNameAndId {
associatedtype T : HasNameAndId
var bar: T {get}
}
extension WrapperOfHasNameAndId { // boilerplate
var id: Int {
return self.bar.id
}
var name: String {
return self.bar.name
}
}
// ==============
struct Bar: HasNameAndId {
let id: Int
let name: String
}
class Foo : WrapperOfHasNameAndId {
let bar: Bar
init(bar: Bar) {
self.bar = bar
}
}
// =======
let f = Foo(bar: Bar(id: 1, name: "howdy"))
print(f.id) // 1
print(f.name) // "howdy"