CODEWITHSUNDEEP
swift
MH175
MH175

Reputation: 2334

Swift Implicitly pass self as inout parameter for reference type

Is it possible to implicitly pass self as an inout parameter to modify a reference variable in place?

Here is a method which can convert an abstract base class into one of its concrete subclasses. My question is, must I always have that first argument, obj: inout AbstractBaseClass, or can I implicitly pass self. I realize that this might also be expressed as a static method.

    func convertTo(_ obj: inout AbstractBaseClass, _ type: ConcreteClassTypes) {
        switch type {
        case .concreteClass1: obj = ConreteClass1()
        case .concreteClass2: obj = ConcreteClass2()
        }
    }

Here is the full code:

class AbstractClass {

    enum ConcreteType {
        case concreteClass1
        case concreteClass2
    }

    var id: Int = 0

    fileprivate init() { }

    func convert(_ obj: inout AbstractClass, to type: ConcreteType) {

        let oldId = obj.id

        switch type {
        case .concreteClass1: obj = ConcreteClass1()
        case .concreteClass2: obj = ConcreteClass2()
        }

        obj.id = oldId
    }

    class ConcreteClass1: AbstractClass {

        override init() { super.init() }
    }

    class ConcreteClass2: AbstractClass {

        override init() { super.init() }

    }

}

var obj: AbstractClass = AbstractClass.ConcreteClass1()
obj.convert(&obj, to: .concreteClass2) //is there any way to eliminate this first argument?

Upvotes: 0

Views: 1672

Answers (3)

matt
matt

Reputation: 535222

I'm going to propose a completely different way of looking at what you're trying to do.

Don't have an abstract superclass. Don't have multiple subclasses. Have one class with multiple functional variants. The functional variants are expressed by a helper object — a struct — owned by the class instance.

So to change functionalities, you just set the helper to a different type of helper. Basically, you give your object a personality transplant.

I have an app that works that way. I have four view controllers that present slightly different info in slightly different ways. But in fact they are one view controller and an enum with four cases that dictates those differences. Thus, at any time the view controller can manifest itself as any of the four types.

Upvotes: 0

Hamish
Hamish

Reputation: 80811

Like matt, I'm not convinced that inout is the right tool for the job in this case.

Although that being said, if you insist on it, one way to achieve what you want is to (ab)use protocol extensions. They allow the definition of mutating methods, which pass the implicit self parameter as inout (to allow the mutation of adopting value types).

So you could say:

protocol AbstractClassProtocol {}

class AbstractClass : AbstractClassProtocol {

    enum ConcreteType {
        case concreteClass1
        case concreteClass2
    }

    fileprivate init() {}

    class ConcreteClass1: AbstractClass {
        override init() { super.init() }
    }

    class ConcreteClass2: AbstractClass {
        override init() { super.init() }
    }
}

extension AbstractClassProtocol where Self == AbstractClass {

    mutating func convert(to type: AbstractClass.ConcreteType) {
        switch type {
        case .concreteClass1:
            self = AbstractClass.ConcreteClass1()
        case .concreteClass2:
            self = AbstractClass.ConcreteClass2()
        }
    }
}

var obj: AbstractClass = AbstractClass.ConcreteClass1()
obj.convert(to: .concreteClass2)
print(obj) // AbstractClass.ConcreteClass2

But it's a bit of a hack, and I'd be wary about using it.

Upvotes: 2

matt
matt

Reputation: 535222

...to modify a reference variable in place? Here is a method which can convert an abstract base class into one of its concrete subclasses...

You are not "modifying" or "converting" anything. You are substituting one object for another. Thus, there is no self that could be passed here; the idea of what you are doing is to destroy one self and provide another in its place.

That said, it's a little unclear what the inout variable is for. Why don't you just assign the new object in place of the old object?

func giveMeA( _ type: AbstractClass.ConcreteType) -> AbstractClass {
    switch type {
    case .concreteClass1: return AbstractClass.ConcreteClass1()
    case .concreteClass2: return AbstractClass.ConcreteClass2()
    }
}

var obj: AbstractClass = AbstractClass.ConcreteClass1()
obj = giveMeA(.concreteClass2)

The effect is identical to what you're doing. If you think it's not, you're just kidding yourself about what the inout parameter is doing.

Upvotes: 1

Related Questions