Decorator Design Patter Using Swift

-

Decorator Design Pattern

It allows you to add behavior to an individual object.
It helps to add such behavior changes, dynamically without affecting the behavior of the other objects from the same parent class.

Decorator design pattern strong holds to Single Responsibility principle. i.e a Base concrete Object.

It is somewhat similar to chain or responsibility design pattern (ex: UIViewController,UIView) where exactly one of the class handles the responsibility, ex: touch events to UITextField, the iOS infrastructure tries to find the responder who can respond to it, if you have implemented a delegate or a IBAction change event , it is directed to that root UIView -> UIViewController -> UIWindow -> UIApplication.

In case of the Decorator Design pattern all classes handle the request which we will see in the example listed below.

A simple example to understand with this would be creating a "Simple Coffee" object and "Coffee Latte".

I will try to make a parent struct to hold a Simple Coffee object. From this structure we can derive CoffeeLatte with the help of a Decorator.

You can download the Code from GitHub

Below Steps is what we need to follow in order to achieve a solution.

- Create a Protocol which defines the basic behavior i.e CoffeeProtocol

This includes cost and ingredients of the Coffee.

protocol CoffeeProtocol {
    var cost : Float { get }
    var ingredients:String { get }

}

- Create a concrete Implementation of this Behavior i.e SimpleCoffee

Here will assign some basic cost and ingredients to make a simple coffee. Example it cost's $1 and ingredients coffee.

struct SimpleCoffee: CoffeeProtocol {
    var cost: Float = 1.0
    
    var ingredients: String = "Coffee"

}

- We need to Implement a CoffeeLatte which will be derived from CoffeeProtocol. How?  that's a good question explained Further.

* Create a decorator protocol which simply takes in a SimpleCoffee. This decorator Protocol (i.e CoffeeDecoratorProtocol) extends from basic behavior protocol(CoffeeProtcol)

protocol CoffeeDecoratorProtocol:CoffeeProtocol {
    var simpleCoffe: SimpleCoffee { get  }
}

* Create a concrete structure by implementing decorator protocol. i.e CoffeeLatte

As mentioned previously all class handle the request. We call the base class and add a cost of 1.0 to the CoffeeLatte and ingredients as milk.


struct CoffeLatte:CoffeeDecoratorProtocol {
    var simpleCoffe: SimpleCoffee
    
    
    var cost: Float {
        return simpleCoffe.cost +  1.0
    }
    
    var ingredients: String {
        return simpleCoffe.ingredients + ", Milk"
    }
}



So far we have accomplished our objective of flexibility. But, what about extensibility?

I would like to add coffee latte with flavor. ex: Coffee Latte with Strawberry Flavor.

For this we need this to our basic behavior i.e add flavor to CoffeeProtocol.

protocol CoffeeProtocol {
    var cost : Float { get }
    var ingredients:String { get }
    
    var flavor:String {get} // Added to create Coffee Latter Strawberry Flavor

}

SimpleCoffee and CoffeeLatte would not have flavor's. So it will be blank for them.

But the new CoffeeLatteStrawberry will have it with the help of Decorator protocol.

if notice here the behavior of the existing structure SimpleCoffee and CoffeeLatte is unchanged.


struct CoffeeLatteStrawberry:CoffeeDecoratorProtocol {
    var simpleCoffe: SimpleCoffee
    
    var cost: Float {
        return simpleCoffe.cost + 2.0
    }
    
    var ingredients: String {
        return simpleCoffe.ingredients + ", Milk , Strawberry syrup"
    }
    
    var flavor: String {
        return simpleCoffe.flavor + "Strawberry"
    }
    
    
}
The final code with implementation in AppDelegate will print below lines of code in the console.

Coffee  (flavor ) =  1.0
Coffee, Milk  (flavor ) =  2.0

Coffee, Milk , Strawberry syrup  (flavor Strawberry) =  3.0


Comments

Post a Comment

Popular posts from this blog

hitTest on iOS to identify the view being hit

-
Image
HitTest on iOS Use hitTest, to identify the view being tapped. The below method allows us to identify the view being selected. We can use it, to identify the view from which we would like to hide the touch events or identify the view we are interested into. Example: In the below case when we tap on Black View we can show an alert like "Black View tapped!" , if we tap on Red View , we can show an alert  "You are not allowed to tap on Red View" .  override func hitTest ( _ point: CGPoint , with event: UIEvent ?) -> UIView ? { } Here is a simple implementation of the method, to identify the view being hit. View hierarchy being used is listed below:- Blue(parent) - Red(child) - Green(child) - Yellow (child) - Orange (child) - Black (child) - White (child) So lets' start with override of hitTest method.      override func hitTest ( _ point: CGPoint , with event: UIEvent ?) -> UIView ? {         //1         if let viewAvailable = findPoin
Read more

CMTimeMakeWithSeconds explained

-
Image
CMTime  is structure which has two main components,  timeScale  and  value. CMTIME = VALUE  / TIMESCALE where, TimeScale =  fraction of a second each unit in numerator occupies. CMTIME = Value / TimeScale 1)  public   func  CMTimeMake( _  value:  Int64 ,  _  timescale:  Int32 ) ->  CMTime CMTimeMake ( 6000 ,  10 ) Means, there are 6000 units , each unit occupies 1/10 of a second 2)  public   func  CMTimeMakeWithSeconds( _  seconds:  Float64 ,  _  preferredTimescale:  Int32 ) ->  CMTime CMTimeMakeWithSeconds(10.0,500) 10.0 = VALUE /500 Therefore VALUE = 5000 So, there are 5000 units, each occupy 1/500 of a second
Read more

Custom Editing Control for UITableViewCell , like iPhone Mail Appliation

-
Image
Dear Friends, Today, while I was developing a application, I found that I am in need to a custom Editing control. Custom Editing Control are displayed on the left side of the screen. IOS sdk provides two of such kind which we use most of the time UITableViewCellEditingStyleDelete & UITableViewCellEditingStyleInsert  . I will be now discussing the third one, UITableViewCellEditingStyleNone. This can be used to design our own Editing control. How this is going to look like can be fond from below screen shot. Steps to achieve this can be found below: STEP 1: Create A subclass of UITabelViewCell First create a subclass of UITableViewCell, where when the cell object is initialised we will have to add a UIButton to its view. You will also need a offset variable, whose value will be 32.0 in all iPhones. -( id ) initWithCoder:( NSCoder *)aDecoder{          self =[ super initWithCoder :aDecoder];          if ( self ){         offset =32.0;        
Read more