Introduction
Imagine we want to implement a sort of postal system, where messages can be sent from someone to the post office; where it will be accordingly dispatched to the right destination.
Beginning
We could go ahead and define a simple data model, that represents a message.
This entity holds the actual message (we'll call it content), and some meta-data, i.e. data about the message itself.
Since we want this message to be immutable and we don't want shared references of it, we can make it a struct, as opposed to a class:
struct Message {
// the meta-data; who is sending this message
let sender: String
// also meta-data; the receiver of the message
let to: String
// the actual content of the message
let content: String
}
The Dispatcher
Now that we have a data model, which will be a shared entity between sender (a person) and dispatcher (the postal office).
We can go ahead and imagine our dispatcher:
class Dispatcher {
public func dispatch(_ message: Message) {
print("Sending \(message.content) to \(message.to) from \(message.from)")
}
}
The Sender
Finally let's imagine the person sending the message:
class Person {
private unowned let dispatcher: Dispatcher
let name: String
init(dispatcher: Dispatcher, ) {
self.dispatcher = dispatcher
self.name = name
}
public func sendMessage(of message: Message) {
dispacher.dispatch(message)
}
}
Example
This looks ok. Let's see how it will look in practice:
let dispatcher = Dispatcher()
let helvidius = Person(dispatcher: dispatcher, name: "Helvidius")
let jovinian = Person(dispatcher: dispatcher, name: "Jovinian")
helvidius.sendMessage(of: Message(sender: helvidius.name, to: "Jovinian", content: "Hi Jovinian! How are you?"))
The actual problem
Notice however, it's a bit odd that Bob has to specify he's the sender.
A person has a name, and if a person sends a message, he's always going to be the sender.
In fact, the current code could be exploited, supposing we'd offer anyone the ability to send messages (i.e. Person class would be a public API):
let dispatcher = Dispatcher()
let evilMike = Person(dispatcher: dispatcher, name: "Evil Mike")
evilMike.sendMessage(of: Message(sender: "Andy", to: "Sandy", content: "Hi Sandy! I'm Andy, and I think you look ugly!"))
The solution!
Protocols could make our lives much more easy. To start, we've noticed every person has a name; it also s seems maybe not just persons can send messages. why not have machines be able to send messages as well? All we need after all, besides the content and receiver, is for the sender to identify himself.
We could use Swift's UUID type, and that would be a great idea! However, for the sake of simplicity, well stick to a name field, of type string:
protocol Sender {
var name: String { get }
}
Great! Now we could have a ton of other types that can be senders, like machines:
class Machine: Sender {
let name: String
let dispacher: Dispatcher
init(name: String, dispathcer: Dispathcer) {
self.name = name
self.dispathcer = dispatcher
}
public sendHappyNewYear() {
let date = Date.now
let components = Calendar.current.dateComponents([.month, .day], from: date)
if components.day == 1 && components.month == 1 {
dispatcher.dispatch(Message(sender: "Robot1", to: "Sandy", content: "Happy new Year Sandy!"))
}
}
}
However, the actual problem still remains, just about anyone can create a message and pretend to be someone else!
So here's where POP (Protocol Oriented Programming) comes more handy in place.
We can make the initializer (or constructor, if you will) of Message entity fileprivate!
struct Message {
// the meta-data; who is sending this message
let sender: String
// also meta-data; the receiver of the message
let to: String
// the actual content of the message
let content: String
fileprivate init(sender: String, to: String, content: String) {
self.sender = sender
self.to = to
self.content = content
}
}
Great, now we can define an extension method on the Sender protocol. That is a method that anyone who's a sender, can automatically benefit from, even retroactively! I.e. entities that already conform to the Sender protocol before the extension method is introduced can benefit from!:
struct Message {
...
}
extension Sender {
func createMessage(to receiver: String, content message: Message) -> Message {
Message(sender: self.name, to: receiver, content: message)
}
}
Now any sender can call the createMessage
method, that will automatically use the name the Sender
has, because remember, the only thing we know about a Sender
is that he has a name, and we can make use of that name in protocol extensions.
Top comments (0)