Template Method

abstract class Game {
  void initialize();
  void makeMove();
  void endGame();

  void play() {
    initialize();
    makeMove();
    endGame();
  }
}

class Cricket extends Game {
  @override
  void initialize() {
    print('Cricket Game Initializing: Setting up players and pitch.');
  }

  @override
  void makeMove() {
    print('Cricket Game: Batsman bats, Bowler bowls.');
  }

  @override
  void endGame() {
    print('Cricket Game Finished: Declaring the winner.');
  }
}

class Football extends Game {
  @override
  void initialize() {
    print('Football Game Initializing: Setting up teams and field.');
  }

  @override
  void makeMove() {
    print('Football Game: Players dribble and pass the ball.');
  }

  @override
  void endGame() {
    print('Football Game Finished: Declaring the winning team.');
  }
}

void main() {
  var cricketGame = Cricket();
  cricketGame.play();

  var footballGame = Football();
  footballGame.play();
}

// Template Method Pattern in Scala

abstract class Game {
  abstract def makeMove(player: String): String
  abstract def isGameOver(): Boolean
  abstract def getResult(player: String): String

  def play(): Unit = {
    println("Game Initialized")
    var currentPlayer = "Player 1"
    while (!isGameOver()) {
      println(s"$currentPlayer's turn")
      val moveResult = makeMove(currentPlayer)
      println(moveResult)
      currentPlayer = if (currentPlayer == "Player 1") "Player 2" else "Player 1"
    }
    println("Game Over")
    println(getResult(currentPlayer))
  }
}

class Chess extends Game {
  override def makeMove(player: String): String = {
    s"${player} made a chess move."
  }

  override def isGameOver(): Boolean = {
    // Simplified game over condition for demonstration
    scala.util.Random.nextBoolean()
  }

  override def getResult(player: String): String = {
    s"${player} wins the chess game!"
  }
}

class Monopoly extends Game {
  override def makeMove(player: String): String = {
    s"${player} rolled the dice and moved."
  }

  override def isGameOver(): Boolean = {
    // Simplified game over condition for demonstration
    scala.util.Random.nextBoolean()
  }

  override def getResult(player: String): String = {
    s"${player} bankrupts everyone and wins Monopoly!"
  }
}

object Main {
  def main(args: Array[String]): Unit = {
    val chessGame = new Chess()
    println("Playing Chess:")
    chessGame.play()

    val monopolyGame = new Monopoly()
    println("\nPlaying Monopoly:")
    monopolyGame.play()
  }
}

<?php

abstract class Report {
  abstract protected function getData();

  public function displayReport() {
    $this->displayTitle();
    $data = $this->getData();
    $this->displayData($data);
    $this->displayFooter();
  }

  protected function displayTitle() {
    echo "<h1>Report Title</h1>\n";
  }

  abstract protected function displayData($data);

  protected function displayFooter() {
    echo "<p>Copyright 2023</p>\n";
  }
}

class HtmlReport extends Report {
  protected function getData() {
    return "<ul><li>Item 1</li><li>Item 2</li></ul>";
  }

  protected function displayData($data) {
    echo $data . "\n";
  }
}

class PlainTextReport extends Report {
  protected function getData() {
    return "Item 1\nItem 2\n";
  }

  protected function displayData($data) {
    echo $data . "\n";
  }
}

// Usage
$htmlReport = new HtmlReport();
$htmlReport->displayReport();

$plainTextReport = new PlainTextReport();
$plainTextReport->displayReport();

?>

# report.rb

class Report
  def template_method
    output_header
    output_body
    output_footer
  end

  def output_header
    raise NotImplementedError, "Subclasses must implement output_header"
  end

  def output_body
    raise NotImplementedError, "Subclasses must implement output_body"
  end

  def output_footer
    puts "Report generated on #{Time.now}"
  end
end

class TextReport < Report
  def output_header
    puts "--- Text Report ---"
  end

  def output_body
    puts "This is the body of the text report."
    puts "It contains important information."
  end
end

class HTMLReport < Report
  def output_header
    puts "<html><head><title>HTML Report</title></head><body>"
  end

  def output_body
    puts "<h1>HTML Report</h1>"
    puts "<p>This is the body of the HTML report.</p>"
    puts "<p>It contains important information.</p>"
  end

  def output_footer
    puts "</body></html>"
  end
end

# Example Usage
text_report = TextReport.new
text_report.template_method

html_report = HTMLReport.new
html_report.template_method

// CaffeineBeverage.swift

protocol Beverage {
    func brew()
    func addCondiments()
    func addMilk() -> Bool
    func prepareBeverage()
}

class CaffeineBeverage: Beverage {
    func prepareBeverage() {
        brew()
        addCondiments()
        if addMilk() {
            println("Adding milk")
        }
    }

    func brew() {
        fatalError("Brew must be overridden by subclasses")
    }

    func addCondiments() {
        fatalError("Add condiments must be overridden by subclasses")
    }

    func addMilk() -> Bool {
        return false
    }
}

class Coffee: CaffeineBeverage {
    override func brew() {
        println("Brewing coffee")
    }

    override func addCondiments() {
        println("Adding sugar and cream to coffee")
    }
}

class Tea: CaffeineBeverage {
    override func brew() {
        println("Brewing tea")
    }

    override func addCondiments() {
        println("Adding lemon to tea")
    }

    override func addMilk() -> Bool {
        return true
    }
}

// Example Usage
let coffee = Coffee()
coffee.prepareBeverage()

let tea = Tea()
tea.prepareBeverage()

abstract class Game {
    abstract fun initialize()
    abstract fun start()
    abstract fun run()
    abstract fun end()

    fun play() {
        println("Game: Starting...")
        initialize()
        start()
        run()
        end()
        println("Game: Finished.")
    }
}

class Cricket : Game() {
    override fun initialize() {
        println("Cricket: Initializing the game...")
    }

    override fun start() {
        println("Cricket: Starting the match...")
    }

    override fun run() {
        println("Cricket: Playing the innings...")
    }

    override fun end() {
        println("Cricket: Match ended.")
    }
}

class Football : Game() {
    override fun initialize() {
        println("Football: Preparing the field...")
    }

    override fun start() {
        println("Football: Kickoff!")
    }

    override fun run() {
        println("Football: Playing two halves...")
    }

    override fun end() {
        println("Football: Game over.")
    }
}

fun main() {
    val cricketGame = Cricket()
    cricketGame.play()

    println("\n--- Next Game ---\n")

    val footballGame = Football()
    footballGame.play()
}

// Define the abstract template method
trait Algorithm {
    fn step1(&self) -> String;
    fn step2(&self) -> String;
    fn step3(&self) -> String;

    // The template method itself - defines the algorithm's structure
    fn run(&self) -> String {
        let result = self.step1();
        println!("{}", result);
        let result = self.step2();
        println!("{}", result);
        let result = self.step3();
        println!("{}", result);
        "Algorithm completed".to_string()
    }
}

// Concrete implementation 1
struct ConcreteAlgorithmA;

impl Algorithm for ConcreteAlgorithmA {
    fn step1(&self) -> String {
        "ConcreteAlgorithmA - Step 1".to_string()
    }

    fn step2(&self) -> String {
        "ConcreteAlgorithmA - Step 2".to_string()
    }

    fn step3(&self) -> String {
        "ConcreteAlgorithmA - Step 3".to_string()
    }
}

// Concrete implementation 2
struct ConcreteAlgorithmB;

impl Algorithm for ConcreteAlgorithmB {
    fn step1(&self) -> String {
        "ConcreteAlgorithmB - Step 1".to_string()
    }

    fn step2(&self) -> String {
        "ConcreteAlgorithmB - Step 2".to_string()
    }

    fn step3(&self) -> String {
        "ConcreteAlgorithmB - Step 3".to_string()
    }
}

fn main() {
    let algo_a = ConcreteAlgorithmA;
    let algo_b = ConcreteAlgorithmB;

    algo_a.run();
    algo_b.run();
}

// worker.go

package main

import "fmt"

// Worker defines the interface for different types of work.
type Worker interface {
	DoWork()
}

// AbstractWorker provides the template method.
type AbstractWorker struct{}

// Execute defines the overall workflow.  This is the template method.
func (w *AbstractWorker) Execute() {
	w.PreWork()
	w.ActualWork()
	w.PostWork()
}

// PreWork performs setup before the actual work.
func (w *AbstractWorker) PreWork() {
	fmt.Println("AbstractWorker: Performing pre-work...")
}

// PostWork performs cleanup after the actual work.
func (w *AbstractWorker) PostWork() {
	fmt.Println("AbstractWorker: Performing post-work...")
}

// ActualWork is a placeholder for the specific work to be done.
// Subclasses should override this method.
func (w *AbstractWorker) ActualWork() {
	fmt.Println("AbstractWorker: Performing default work...")
}

// ConcreteWorkerA implements the ActualWork method for a specific task.
type ConcreteWorkerA struct{}

func (w *ConcreteWorkerA) ActualWork() {
	fmt.Println("ConcreteWorkerA: Performing specific work A...")
}

// ConcreteWorkerB implements the ActualWork method for another task.
type ConcreteWorkerB struct{}

func (w *ConcreteWorkerB) ActualWork() {
	fmt.Println("ConcreteWorkerB: Performing specific work B...")
}

func main() {
	workerA := &ConcreteWorkerA{}
	workerB := &ConcreteWorkerB{}

	fmt.Println("Executing Worker A:")
	workerA.DoWork() // Calls Execute() which calls PreWork, ActualWork, PostWork

	fmt.Println("\nExecuting Worker B:")
	workerB.DoWork() // Calls Execute() which calls PreWork, ActualWork, PostWork
}

// DoWork is a method to satisfy the Worker interface.
func (w *AbstractWorker) DoWork() {
	w.Execute()
}

func (w *ConcreteWorkerA) DoWork() {
	w.Execute()
}

func (w *ConcreteWorkerB) DoWork() {
	w.Execute()
}

#include <stdio.h>

// Abstract Class
typedef struct AbstractOperation {
    void (*performOperation)(struct AbstractOperation* self); // Function pointer
    void (*step1)(struct AbstractOperation* self);
    void (*step2)(struct AbstractOperation* self);
} AbstractOperation;

void abstract_operation_step1(AbstractOperation* self) {
    printf("AbstractOperation: Step 1\n");
}

void abstract_operation_step2(AbstractOperation* self) {
    printf("AbstractOperation: Step 2\n");
}

void abstract_operation_execute(AbstractOperation* self) {
    self->step1(self);
    self->performOperation(self);
    self->step2(self);
}

// Concrete Class A
typedef struct ConcreteOperationA : AbstractOperation {
    void (*performOperation)(struct AbstractOperation* self);
};

void concrete_operation_a_performOperation(AbstractOperation* self) {
    printf("ConcreteOperationA: Performing operation A\n");
}

void concrete_operation_a_init(struct ConcreteOperationA* op) {
    op->performOperation = concrete_operation_a_performOperation;
}

// Concrete Class B
typedef struct ConcreteOperationB : AbstractOperation {
    void (*performOperation)(struct AbstractOperation* self);
};

void concrete_operation_b_performOperation(AbstractOperation* self) {
    printf("ConcreteOperationB: Performing operation B\n");
}

void concrete_operation_b_init(struct ConcreteOperationB* op) {
    op->performOperation = concrete_operation_b_performOperation;
}


int main() {
    struct ConcreteOperationA opA;
    opA.step1 = abstract_operation_step1;
    opA.step2 = abstract_operation_step2;
    concrete_operation_a_init(&opA);

    printf("Executing Concrete Operation A:\n");
    abstract_operation_execute(&opA);
    printf("\n");

    struct ConcreteOperationB opB;
    opB.step1 = abstract_operation_step1;
    opB.step2 = abstract_operation_step2;
    concrete_operation_b_init(&opB);

    printf("Executing Concrete Operation B:\n");
    abstract_operation_execute(&opB);

    return 0;
}

#include <iostream>
#include <string>

// Abstract class
class HouseBuilder {
public:
  virtual ~HouseBuilder() {}

  void buildHouse() {
    buildWalls();
    buildRoof();
    installWindows();
    installDoors();
    paintHouse();
  }

protected:
  virtual void buildWalls() = 0;
  virtual void buildRoof() = 0;
  virtual void installWindows() = 0;
  virtual void installDoors() = 0;
  virtual void paintHouse() = 0;
};

// Concrete class 1
class WoodenHouseBuilder : public HouseBuilder {
protected:
  void buildWalls() override {
    std::cout << "Building wooden walls" << std::endl;
  }

  void buildRoof() override {
    std::cout << "Building a wooden roof" << std::endl;
  }

  void installWindows() override {
    std::cout << "Installing wooden windows" << std::endl;
  }

  void installDoors() override {
    std::cout << "Installing wooden doors" << std::endl;
  }

  void paintHouse() override {
    std::cout << "Painting the wooden house" << std::endl;
  }
};

// Concrete class 2
class ConcreteHouseBuilder : public HouseBuilder {
protected:
  void buildWalls() override {
    std::cout << "Building concrete walls" << std::endl;
  }

  void buildRoof() override {
    std::cout << "Building a concrete roof" << std::endl;
  }

  void installWindows() override {
    std::cout << "Installing concrete windows" << std::endl;
  }

  void installDoors() override {
    std::cout << "Installing concrete doors" << std::endl;
  }

  void paintHouse() override {
    std::cout << "Painting the concrete house" << std::endl;
  }
};

int main() {
  WoodenHouseBuilder woodenBuilder;
  ConcreteHouseBuilder concreteBuilder;

  woodenBuilder.buildHouse();
  std::cout << std::endl;
  concreteBuilder.buildHouse();

  return 0;
}

// TemplateMethod.cs
using System;

// Abstract class defining the template method
public abstract class AbstractWorkflow
{
    public abstract void Download();
    public abstract void Process();
    public abstract void Upload();

    // Template method defines the algorithm's structure
    public void TemplateMethod()
    {
        Console.WriteLine("Starting Workflow...");
        Download();
        Process();
        Upload();
        Console.WriteLine("Workflow Complete.");
    }
}

// Concrete workflow 1
public class DownloadAndProcessWorkflow : AbstractWorkflow
{
    public override void Download()
    {
        Console.WriteLine("Downloading data...");
    }

    public override void Process()
    {
        Console.WriteLine("Processing downloaded data...");
    }

    public override void Upload()
    {
        Console.WriteLine("Upload not required for this workflow.");
    }
}

// Concrete workflow 2
public class UploadAndProcessWorkflow : AbstractWorkflow
{
    public override void Download()
    {
        Console.WriteLine("Download not required for this workflow.");
    }

    public override void Process()
    {
        Console.WriteLine("Processing uploaded data...");
    }

    public override void Upload()
    {
        Console.WriteLine("Uploading data...");
    }
}

public class Program
{
    public static void Main(string[] args)
    {
        AbstractWorkflow workflow1 = new DownloadAndProcessWorkflow();
        workflow1.TemplateMethod();

        Console.WriteLine("\n");

        AbstractWorkflow workflow2 = new UploadAndProcessWorkflow();
        workflow2.TemplateMethod();
    }
}

// Template Method Pattern in TypeScript

// Abstract class defining the template method
abstract class CoffeeMaker {
  abstract brew(): void;
  abstract addIngredients(): void;

  public makeCoffee(): void {
    this.boilWater();
    this.brew();
    this.addIngredients();
    this.pour();
  }

  private boilWater(): void {
    console.log("Boiling water...");
  }

  private pour(): void {
    console.log("Pouring coffee...");
  }
}

// Concrete class: Simple Coffee
class SimpleCoffee extends CoffeeMaker {
  brew(): void {
    console.log("Brewing simple coffee...");
  }

  addIngredients(): void {
    console.log("Adding sugar and milk...");
  }
}

// Concrete class: Espresso
class Espresso extends CoffeeMaker {
  brew(): void {
    console.log("Brewing espresso...");
  }

  addIngredients(): void {
    console.log("Adding hot water...");
  }
}

// Usage
const simpleCoffeeMaker = new SimpleCoffee();
simpleCoffeeMaker.makeCoffee();

const espressoMaker = new Espresso();
espressoMaker.makeCoffee();

// CaffeineBeverage.js
class CaffeineBeverage {
  prepareBeverage() {
    this.boilWater();
    this.brew();
    this.pourInCup();
    this.addCondiments();
    return "Enjoy your " + this.getName();
  }

  boilWater() {
    console.log("Boiling water...");
  }

  pourInCup() {
    console.log("Pouring into cup...");
  }

  addCondiments() {
    console.log("Adding condiments...");
  }

  getName() {
    return "beverage";
  }
}

// Coffee.js
class Coffee extends CaffeineBeverage {
  brew() {
    console.log("Brewing coffee...");
  }

  addCondiments() {
    console.log("Adding sugar and milk...");
  }

  getName() {
    return "coffee";
  }
}

// Tea.js
class Tea extends CaffeineBeverage {
  brew() {
    console.log("Steeping tea...");
  }

  addCondiments() {
    console.log("Adding lemon...");
  }

  getName() {
    return "tea";
  }
}

// App.js
const coffee = new Coffee();
const tea = new Tea();

console.log(coffee.prepareBeverage());
console.log(tea.prepareBeverage());

from abc import ABC, abstractmethod

class AbstractWorkflow(ABC):
    def template_method(self):
        self.step1()
        self.step2()
        self.step3()

    def step3(self):
        print("Step 3: Common logic")

    @abstractmethod
    def step1(self):
        pass

    @abstractmethod
    def step2(self):
        pass

class ConcreteWorkflowA(AbstractWorkflow):
    def step1(self):
        print("ConcreteWorkflowA: Step 1")

    def step2(self):
        print("ConcreteWorkflowA: Step 2")

class ConcreteWorkflowB(AbstractWorkflow):
    def step1(self):
        print("ConcreteWorkflowB: Step 1 - Different implementation")

    def step2(self):
        print("ConcreteWorkflowB: Step 2 - Different implementation")


if __name__ == "__main__":
    workflow_a = ConcreteWorkflowA()
    workflow_a.template_method()

    workflow_b = ConcreteWorkflowB()
    workflow_b.template_method()

// Template Method Pattern

// Abstract class defining the template
abstract class Game {

    // Template method - defines the algorithm's structure
    public void play() {
        initialize();
        startGame();
        while (notEnd()) {
            takeTurn();
        }
        endGame();
    }

    // Concrete methods (common steps)
    public void takeTurn() {
        System.out.println("Taking a turn...");
    }

    public boolean notEnd() {
        return true; //Placeholder, subclasses should define end condition
    }

    // Abstract methods (to be implemented by subclasses)
    protected abstract void initialize();
    protected abstract void startGame();
    protected abstract void endGame();
}

// Concrete class - Cricket
class Cricket extends Game {

    @Override
    protected void initialize() {
        System.out.println("Cricket: Initializing the game with bats and balls.");
    }

    @Override
    protected void startGame() {
        System.out.println("Cricket: Starting the cricket match.");
    }

    @Override
    protected void endGame() {
        System.out.println("Cricket: Ending the cricket match. Declaring the winner.");
    }

    @Override
    public boolean notEnd() {
        return Math.random() < 0.9; //Simulate game ending randomly
    }
}

// Concrete class - Football
class Football extends Game {

    @Override
    protected void initialize() {
        System.out.println("Football: Initializing the game with players and field.");
    }

    @Override
    protected void startGame() {
        System.out.println("Football: Starting the football match.");
    }

    @Override
    protected void endGame() {
        System.out.println("Football: Ending the football match. Declaring the winner.");
    }
}

// Main class to demonstrate
public class TemplateMethodDemo {
    public static void main(String[] args) {
        Game cricketGame = new Cricket();
        cricketGame.play();

        System.out.println("---");

        Game footballGame = new Football();
        footballGame.play();
    }
}