Category Archives: General

General

Facade Pattern

Facade pattern hides the complexities of the system and provides an interface to the client using which the client can access the system. This type of design pattern comes under structural pattern as this pattern adds an interface to existing system to hide its complexities.

class Compiler:
    def __init__(self, path):
        self.path = path
    def compile(self):
        tokenizer = Tokenizer(self.path).tokenize()
        parser = Parser(tokenizer).parse()
        builder = IRBuilder(parser).build()
        optimizer = Optimizer(builder).optimize()
        codegenerator = CodeGenerator(optimizer).generate()
        linker = Linker(codegenerator).link()
        return linker
class Tokenizer:
    def __init__(self, path):
        self.path = path
    def tokenize(self):
        print(f"tokenizing {self.path}")
        return self
    def __str__(self):
        return "Tokenizer"
class Parser:
    def __init__(self,  tokenizer):
        self.tokenizer = tokenizer
    def parse(self):
        print("parsinging", end=" ")
        print(self.tokenizer)
        return self
    def __str__(self):
        return "Parser"
class IRBuilder:
    def __init__(self, parser):
        self.parser = parser
    def build(self):
        print("IRbuilding", end=" ")
        print(self.parser)
        return self
    def __str__(self):
        return "IRBuilder"
class Optimizer:
    def __init__(self, builder):
        self.builder = builder
    def optimize(self):
        print("optimizing", end=" ")
        print(self.builder)
        return self
    def __str__(self):
        return "Optimizer"
class CodeGenerator:
    def __init__(self, optimizer):
        self.optimizer = optimizer
    def generate(self):
        print("generating code", end=" ")
        print(self.optimizer)
        return self
    def __str__(self):
        return "CodeGenerator"
class Linker:
    def __init__(self, generator):
        self.codegenerator = generator
    def link(self):
        print("linking",end=" ")
        print(self.codegenerator)
        return self
    def __str__(self):
        return "Linker"
compiler = Compiler("sample.py")
compiler.compile()
class Washing:
    '''Subsystem # 1'''
    def wash(self):
        print("Washing...")


class Rinsing:
    '''Subsystem # 2'''
    def rinse(self):
        print("Rinsing...")


class Spinning:
    '''Subsystem # 3'''
    def spin(self):
        print("Spinning...")

class WashingMachine:
    '''Facade'''

    def __init__(self):
        self.washing = Washing()
        self.rinsing = Rinsing()
        self.spinning = Spinning()

    def startWashing(self):
        self.washing.wash()
        self.rinsing.rinse()
        self.spinning.spin()
General

Decorator Pattern

import abc
class Shape(abc.ABC):
    @abc.abstractmethod
    def draw(self):
        pass

class Triangle(Shape):
    def draw(self):
        print("Triangle")

class Circle(Shape):
    def draw(self):
        print("Circle")

# Decorator was not needed to be inherited from Shape in Python.But you can enforce the draw function
# In Java, inheritance forces to implement parent methods to child Decorators.
class Decorator(Shape):
    def __init__(self, shape):
        self.shape = shape

class ColorDecorator(Decorator):
    def __init__(self, shape, color):
        super().__init__(shape)
        self.color = color

    def draw(self):
        print(self.color)
        self.shape.draw()
        print(self.color)

class PatternDecorator(Decorator):
    def __init__(self, shape, pattern):
        super().__init__(shape)
        self.pattern = pattern

    def draw(self):
        print(self.pattern)
        self.shape.draw()
        print(self.pattern)

s = Circle()
s.draw()
cd = ColorDecorator(s, "red")
cd.draw()
pd = PatternDecorator(Triangle(), "Polca dot")
pd.draw()
redPolcaDorCircle = PatternDecorator(cd, "Polca dot")
redPolcaDorCircle.draw()
General

State Pattern

# Allowing an object to alter behavior
# when its internal state changes so that it appears to change its class

class Phone:
    def __init__(self):
        self.ring_state = SoundState()
    def volumeUp(self):
        self.ring_state = self.ring_state.nextVolumeUp()
    def volumeDown(self):
        self.ring_state = self.ring_state.nextVolumeDown()
    def ring(self):
        self.ring_state.ring()

import abc

class RingState(abc.ABC):
    @abc.abstractmethod
    def ring(self):
        pass
    @abc.abstractmethod
    def nextVolumeUp(self):
        pass
    @abc.abstractmethod
    def nextVolumeDown(self):
        pass

class SoundState(RingState):
    def ring(self):
        print("Phone is ringing")
    def nextVolumeUp(self):
        return self
    def nextVolumeDown(self):
        return VibrateState()

class VibrateState(RingState):
    def ring(self):
        print("Phone is vibrating")
    def nextVolumeUp(self):
        return SoundState()
    def nextVolumeDown(self):
        return SilentState()

class SilentState(RingState):
    def ring(self):
        print("Phone is silent")
    def nextVolumeUp(self):
        return VibrateState()
    def nextVolumeDown(self):
        return self

phone = Phone()
phone.ring()
phone.volumeDown()
phone.ring()
phone.volumeDown()
phone.ring()
phone.volumeDown()
phone.ring()
phone.volumeUp()
phone.ring()
phone.volumeUp()
phone.ring()