Swift adapter design sample – The.Swift.Dev.

Fist of all let me emphasize that, that is the true world illustration of what we’re going to construct on this little Swift adapter sample tutorial:

Adapter is a structural design sample that permits objects with incompatible interfaces to work collectively. In different phrases, it transforms the interface of an object to adapt it to a distinct object.

So adapter can rework one factor into one other, typically it’s referred to as wrapper, as a result of it wraps the article and gives a brand new interface round it. It’s like a software program dongle for particular interfaces or legacy courses. (Dongle haters: it’s time to go away the previous behind!) 😂

Adapter design sample implementation

Creating an adapter in Swift is definitely a brilliant straightforward job to do. You simply have to make a brand new object, “field” the outdated one into it and implement the required interface in your new class or struct. In different phrases, a wrapper object shall be our adapter to implement the goal interface by wrapping an different adaptee object. So once more:

Adaptee

The item we’re adapting to a selected goal (e.g. old-school USB-A port).

Adapter

An object that wraps the unique one and produces the brand new necessities specified by some goal interface (this does the precise work, aka. the little dongle above).

Goal

It’s the object we need to use adaptee with (our USB-C socket).

The best way to use the adapter sample in Swift?

You need to use an adapter if you wish to combine a third-party library in your code, however it’s interface doesn’t match along with your necessities. For instance you’ll be able to create a wrapper round a complete SDK or backend API endpoints to be able to create a standard denominator. 👽

In my instance, I’m going to wrap an EKEvent object with an adapter class to implement a model new protocol. 📆

import Basis
import EventKit

// our goal protocol
protocol Occasion {
    var title: String { get }
    var startDate: String { get }
    var endDate: String { get }
}

// adapter (wrapper class)
class EventAdapter {

    personal lazy var dateFormatter: DateFormatter = {
        let dateFormatter = DateFormatter()
        dateFormatter.dateFormat = "yyyy. MM. dd. HH:mm"
        return dateFormatter
    }()

    personal var occasion: EKEvent

    init(occasion: EKEvent) {
        self.occasion = occasion
    }
}

// precise adapter implementation
extension EventAdapter: Occasion {

    var title: String {
        return self.occasion.title
    }
    var startDate: String {
        return self.dateFormatter.string(from: occasion.startDate)
    }
    var endDate: String {
        return self.dateFormatter.string(from: occasion.endDate)
    }
}

// let's create an EKEvent adaptee occasion
let dateFormatter = DateFormatter()
dateFormatter.dateFormat = "MM/dd/yyyy HH:mm"

let calendarEvent = EKEvent(eventStore: EKEventStore())
calendarEvent.title = "Adapter tutorial deadline"
calendarEvent.startDate = dateFormatter.date(from: "07/30/2018 10:00")
calendarEvent.endDate = dateFormatter.date(from: "07/30/2018 11:00")

// now we are able to use the adapter class as an Occasion protocol, as a substitute of an EKEvent
let adapter = EventAdapter(occasion: calendarEvent)
// adapter.title
// adapter.startDate
// adapter.endDate

One other use case is when you need to use a number of current ultimate courses or structs however they lack some performance and also you need to construct a brand new goal interface on prime of them. Typically it’s a good selection to implement an wrapper to deal with this messy scenario. 🤷‍♂️

That’s all concerning the adapter design sample. Normally it’s very easy to implement it in Swift – or in another programming language – however it’s tremendous helpful and typically unavoidable.

Youngsters, bear in mind: don’t go too onerous on dongles! 😉 #himym