from abc import ABC, abstractmethod


class Door(ABC):
    @abstractmethod
    def getWidth(self):
        ...

    @abstractmethod
    def getHeight(self):
        ...


class WoodenDoor(Door):
    def __init__(self, width, height):
        self.width = width
        self.height = height

    def getWidth(self):
        return self.width

    def getHeight(self):
        return self.height


class DoorFactory:
    @staticmethod
    def makeDoor(width, height):
        return WoodenDoor(width, height)


# ----------------------------
door = DoorFactory.makeDoor(90, 210)
print(door.getHeight())
print(door.getWidth())

interface Door {
    getWidth(): number;
    getHeight(): number;
}

class WoodenDoor implements Door {
    private width: number;
    private height: number;

    constructor(width: number, height: number) {
        this.width = width;
        this.height = height;
    }

    getWidth(): number {
        return this.width;
    }

    getHeight(): number {
        return this.height;
    }
}

class DoorFactory {
    static makeDoor(width: number, height: number): Door {
        return new WoodenDoor(width, height);
    }
}

// ----------------------------

const door: Door = DoorFactory.makeDoor(90, 210);
console.log(door.getHeight());
console.log(door.getWidth());

class Door {
    getWidth() {
        throw new Error("not implemented");
    }

    getHeight() {
        throw new Error("not implemented");
    }
}

class WoodenDoor extends Door {
    constructor(width, height) {
        super();
        this.width = width;
        this.height = height;
    }

    getWidth() {
        return this.width;
    }

    getHeight() {
        return this.height;
    }
}

class DoorFactory {
    static makeDoor(width, height) {
        return new WoodenDoor(width, height);
    }
}


const door = DoorFactory.makeDoor(90, 210);
console.log(door.getHeight());
console.log(door.getWidth());

using System;

public interface IDoor
{
    int GetHeight();
    int GetWidth();
}

public class WoodenDoor : IDoor
{
    private int Height { get; set; }
    private int Width { get; set; }

    public WoodenDoor(int width, int height)
    {
        this.Width = width;
        this.Height = height;
    }

    public int GetHeight()
    {
        return this.Height;
    }
    public int GetWidth()
    {
        return this.Width;
    }
}

public static class DoorFactory
{
    public static IDoor MakeDoor(int width, int height)
    {
        return new WoodenDoor(width, height);
    }
}


// ----------------------------

var door = DoorFactory.MakeDoor(90, 210);
Console.WriteLine(door.GetHeight());
Console.WriteLine(door.GetWidth());

interface DoorInterface {
    public function getHeight();
    public function getWidth();
}

class WoodenDoor implements DoorInterface {
    private $width;
    private $height;

    public function __construct($width, $height) {
        $this->width = $width;
        $this->height = $height;
    }

    public function getHeight() {
        return $this->height;
    }
    public function getWidth() {
        return $this->width;
    }
}

class DoorFactory {
    public static function makeDoor($width, $height) {
        return new WoodenDoor($width, $height);
    }
}

$door = DoorFactory::makeDoor(90, 210);
echo $door->getHeight() . "\n";
echo $door->getWidth() . "\n";

package main

import "fmt"

type Door interface {
	getHeight() int
	getWidth() int
}

type WoodenDoor struct {
	width  int
	height int
}

func NewWoodenDoor(width, height int) *WoodenDoor {
	return &WoodenDoor{width: width, height: height}
}

func (w *WoodenDoor) getHeight() int {
	return w.height
}

func (w *WoodenDoor) getWidth() int {
	return w.width
}

type DoorFactory struct{}

func (df *DoorFactory) makeDoor(width, height int) Door {
	return NewWoodenDoor(width, height)
}

func main() {
	doorFactory := &DoorFactory{}
	door := doorFactory.makeDoor(90, 210)
	fmt.Println(door.getHeight())
	fmt.Println(door.getWidth())
}

public interface Door {
    int getHeight();
    int getWidth();
}

public class WoodenDoor implements Door {
    private int width;
    private int height;

    public WoodenDoor(int width, int height) {
        this.width = width;
        this.height = height;
    }

    public int getHeight() {
        return height;
    }
    public int getWidth() {
        return width;
    }
}

public class DoorFactory {
    public static Door makeDoor(int width, int height) {
        return new WoodenDoor(width, height);
    }
}

// ----------------------------

Door door = DoorFactory.makeDoor(90, 210);
System.out.println(door.getHeight());
System.out.println(door.getWidth());

#include <iostream>

// Door interface
class Door {
public:
    virtual ~Door() = default;
    virtual int getWidth() const = 0;
    virtual int getHeight() const = 0;
};

// Wooden door implementation
class WoodenDoor : public Door {
private:
    int width;
    int height;

public:
    WoodenDoor(int width, int height)
        : width(width), height(height) {}

    int getWidth() const override {
        return width;
    }

    int getHeight() const override {
        return height;
    }
};

// Door factory
class DoorFactory {
public:
    static Door* makeDoor(int width, int height) {
        return new WoodenDoor(width, height);
    }
};

// Usage
int main() {
    Door* door = DoorFactory::makeDoor(90, 210);
    std::cout << door->getHeight() << std::endl;
    std::cout << door->getWidth() << std::endl;

    delete door;
    return 0;
}

interface Door {
    fun getWidth(): Int
    fun getHeight(): Int
}

class WoodenDoor(private val width: Int, private val height: Int) : Door {
    override fun getWidth(): Int = width
    override fun getHeight(): Int = height
}

object DoorFactory {
    fun makeDoor(width: Int, height: Int): Door {
        return WoodenDoor(width, height)
    }
}

// ----------------------------

fun main() {
    val door = DoorFactory.makeDoor(90, 210)
    println(door.getHeight())
    println(door.getWidth())
}

abstract class Door {
  int getWidth();
  int getHeight();
}

class WoodenDoor implements Door {
  final int width;
  final int height;

  WoodenDoor(this.width, this.height);

  @override
  int getWidth() => width;

  @override
  int getHeight() => height;
}

class DoorFactory {
  static Door makeDoor(int width, int height) {
    return WoodenDoor(width, height);
  }
}

// ----------------------------

void main() {
  var door = DoorFactory.makeDoor(90, 210);
  print(door.getHeight());
  print(door.getWidth());
}

class Interviewer:
    def askQuestions(self):
        pass


class Developer(Interviewer):
    def askQuestions(self):
        print('Asking about design patterns!')


class CommunityExecutive(Interviewer):
    def askQuestions(self):
        print('Asking about community building')


class HiringManager:
    def makeInterviewer(self):
        pass

    def takeInterview(self):
        interviewer = self.makeInterviewer()
        interviewer.askQuestions()


class DevelopmentManager(HiringManager):
    def makeInterviewer(self):
        return Developer()


class MarketingManager(HiringManager):
    def makeInterviewer(self):
        return CommunityExecutive()


# ----------------------------

devManager = DevelopmentManager()
devManager.takeInterview()

marketingManager = MarketingManager()
marketingManager.takeInterview()

interface Interviewer {
  askQuestions(): void;
}

class Developer implements Interviewer {
  askQuestions(): void {
    console.log("Asking about design patterns!");
  }
}

class CommunityExecutive implements Interviewer {
  askQuestions(): void {
    console.log("Asking about community building");
  }
}

abstract class HiringManager {
  abstract makeInterviewer(): Interviewer;

  takeInterview(): void {
    let interviewer = this.makeInterviewer();
    interviewer.askQuestions();
  }
}

class DevelopmentManager extends HiringManager {
  makeInterviewer(): Developer {
    return new Developer();
  }
}

class MarketingManager extends HiringManager {
  makeInterviewer(): CommunityExecutive {
    return new CommunityExecutive();
  }
}

let devManager = new DevelopmentManager();
devManager.takeInterview();

let marketingManager = new MarketingManager();
marketingManager.takeInterview();

class Developer {
    askQuestions() {
        console.log("Asking about design patterns!");
    }
}

class CommunityExecutive {
    askQuestions() {
        console.log("Asking about community building");
    }
}

class HiringManager {
    takeInterview() {
        const interviewer = this.makeInterviewer();
        interviewer.askQuestions();
    }
}

class DevelopmentManager extends HiringManager {
    makeInterviewer() {
        return new Developer();
    }
}

class MarketingManager extends HiringManager {
    makeInterviewer() {
        return new CommunityExecutive();
    }
}

const devManager = new DevelopmentManager();
devManager.takeInterview();

const marketingManager = new MarketingManager();
marketingManager.takeInterview();

using System;


interface IInterviewer
{
    void AskQuestions();
}

class Developer : IInterviewer
{
    public void AskQuestions()
    {
        Console.WriteLine("Asking about design patterns!");
    }
}

class CommunityExecutive : IInterviewer
{
    public void AskQuestions()
    {
        Console.WriteLine("Asking about community building");
    }
}

abstract class HiringManager
{
    // Factory method
    abstract protected IInterviewer MakeInterviewer();
    public void TakeInterview()
    {
        var interviewer = this.MakeInterviewer();
        interviewer.AskQuestions();
    }
}

class DevelopmentManager : HiringManager
{
    protected override IInterviewer MakeInterviewer()
    {
        return new Developer();
    }
}

class MarketingManager : HiringManager
{
    protected override IInterviewer MakeInterviewer()
    {
        return new CommunityExecutive();
    }
}


// ----------------------------

var devManager = new DevelopmentManager();
devManager.TakeInterview(); //Output : Asking about design patterns!

var marketingManager = new MarketingManager();
marketingManager.TakeInterview();//Output : Asking about community building

interface InterviewerInterface
{
    public function askQuestions();
}

class Developer implements InterviewerInterface
{
    public function askQuestions()
    {
        echo "Asking about design patterns!\n";
    }
}

class CommunityExecutive implements InterviewerInterface
{
    public function askQuestions()
    {
        echo "Asking about community building\n";
    }
}

abstract class HiringManager
{
    // Factory method
    abstract protected function makeInterviewer(): InterviewerInterface;

    public function takeInterview()
    {
        $interviewer = $this->makeInterviewer();
        $interviewer->askQuestions();
    }
}

class DevelopmentManager extends HiringManager
{
    protected function makeInterviewer(): InterviewerInterface
    {
        return new Developer();
    }
}

class MarketingManager extends HiringManager
{
    protected function makeInterviewer(): InterviewerInterface
    {
        return new CommunityExecutive();
    }
}


// Usage
$devManager = new DevelopmentManager();
$devManager->takeInterview(); // Output: Asking about design patterns!

$marketingManager = new MarketingManager();
$marketingManager->takeInterview(); // Output: Asking about community building

package main

import "fmt"

type Interviewer interface {
	AskQuestions()
}

type Developer struct{}

func (d *Developer) AskQuestions() {
	fmt.Println("Asking about design patterns!")
}

type CommunityExecutive struct{}

func (ce *CommunityExecutive) AskQuestions() {
	fmt.Println("Asking about community building")
}

// HiringManager نقش کلاس پدر رو داره: takeInterview فقط یک‌بار اینجا تعریف می‌شه.
// تنها چیزی که توی هر مدیر فرق می‌کنه، فکتوری متد‌ی makeInterviewer هست.
type HiringManager struct {
	makeInterviewer func() Interviewer
}

func (hm *HiringManager) TakeInterview() {
	interviewer := hm.makeInterviewer()
	interviewer.AskQuestions()
}

type DevelopmentManager struct {
	HiringManager
}

func NewDevelopmentManager() *DevelopmentManager {
	return &DevelopmentManager{
		HiringManager{makeInterviewer: func() Interviewer { return &Developer{} }},
	}
}

type MarketingManager struct {
	HiringManager
}

func NewMarketingManager() *MarketingManager {
	return &MarketingManager{
		HiringManager{makeInterviewer: func() Interviewer { return &CommunityExecutive{} }},
	}
}

func main() {
	devManager := NewDevelopmentManager()
	devManager.TakeInterview() // Output: Asking about design patterns!

	marketingManager := NewMarketingManager()
	marketingManager.TakeInterview() // Output: Asking about community building
}

interface Interviewer {
  void askQuestions();
}

class Developer implements Interviewer {

  @Override
  public void askQuestions() {
    System.out.println("Asking about design patterns!");
  }
}

class CommunityExecutive implements Interviewer {

  @Override
  public void askQuestions() {
    System.out.println("Asking about community building");
  }
}

abstract class HiringManager {
  abstract Interviewer makeInterviewer();
  public void takeInterview() {
    Interviewer interviewer = this.makeInterviewer();
    interviewer.askQuestions();
  }
}

class DevelopmentManager extends HiringManager {
  public Developer makeInterviewer() {
    return new Developer();
  }
}

class MarketingManager extends HiringManager {
  public CommunityExecutive makeInterviewer() {
    return new CommunityExecutive();
  }
}

// ----------------------------

DevelopmentManager devManager = new DevelopmentManager();
devManager.takeInterview();

MarketingManager marketingManager = new MarketingManager();
marketingManager.takeInterview();

#include <iostream>
#include <memory>

// Interviewer interface
class Interviewer {
public:
    virtual ~Interviewer() = default;
    virtual void askQuestions() = 0;
};

// Developer interviewer
class Developer : public Interviewer {
public:
    void askQuestions() override {
        std::cout << "Asking about design patterns!" << std::endl;
    }
};

// Community executive interviewer
class CommunityExecutive : public Interviewer {
public:
    void askQuestions() override {
        std::cout << "Asking about community building" << std::endl;
    }
};

// Abstract hiring manager
class HiringManager {
public:
    virtual ~HiringManager() = default;
    virtual std::unique_ptr<Interviewer> makeInterviewer() = 0;
    
    void takeInterview() {
        auto interviewer = makeInterviewer();
        interviewer->askQuestions();
    }
};

// Development manager
class DevelopmentManager : public HiringManager {
public:
    std::unique_ptr<Interviewer> makeInterviewer() override {
        return std::make_unique<Developer>();
    }
};

// Marketing manager
class MarketingManager : public HiringManager {
public:
    std::unique_ptr<Interviewer> makeInterviewer() override {
        return std::make_unique<CommunityExecutive>();
    }
};

// Usage
int main() {
    DevelopmentManager devManager;
    devManager.takeInterview(); // Output: Asking about design patterns!
    
    MarketingManager marketingManager;
    marketingManager.takeInterview(); // Output: Asking about community building
    
    return 0;
}

interface Interviewer {
    fun askQuestions()
}

class Developer : Interviewer {
    override fun askQuestions() {
        println("Asking about design patterns!")
    }
}

class CommunityExecutive : Interviewer {
    override fun askQuestions() {
        println("Asking about community building")
    }
}

abstract class HiringManager {
    abstract fun makeInterviewer(): Interviewer

    fun takeInterview() {
        val interviewer = makeInterviewer()
        interviewer.askQuestions()
    }
}

class DevelopmentManager : HiringManager() {
    override fun makeInterviewer(): Interviewer = Developer()
}

class MarketingManager : HiringManager() {
    override fun makeInterviewer(): Interviewer = CommunityExecutive()
}

// ----------------------------

fun main() {
    val devManager = DevelopmentManager()
    devManager.takeInterview()

    val marketingManager = MarketingManager()
    marketingManager.takeInterview()
}

abstract class Interviewer {
  void askQuestions();
}

class Developer implements Interviewer {
  @override
  void askQuestions() {
    print('Asking about design patterns!');
  }
}

class CommunityExecutive implements Interviewer {
  @override
  void askQuestions() {
    print('Asking about community building');
  }
}

abstract class HiringManager {
  Interviewer makeInterviewer();

  void takeInterview() {
    var interviewer = makeInterviewer();
    interviewer.askQuestions();
  }
}

class DevelopmentManager extends HiringManager {
  @override
  Interviewer makeInterviewer() => Developer();
}

class MarketingManager extends HiringManager {
  @override
  Interviewer makeInterviewer() => CommunityExecutive();
}

// ----------------------------

void main() {
  var devManager = DevelopmentManager();
  devManager.takeInterview();

  var marketingManager = MarketingManager();
  marketingManager.takeInterview();
}

class Door:
    def getDescription(self):
        pass


class WoodenDoor(Door):
    def getDescription(self):
        print('I am a wooden door')


class IronDoor(Door):
    def getDescription(self):
        print('I am an iron door')


class DoorFittingExpert:
    def getDescription(self):
        pass


class Carpenter(DoorFittingExpert):
    def getDescription(self):
        print('I can only fit wooden doors')


class Welder(DoorFittingExpert):
    def getDescription(self):
        print('I can only fit iron doors')


class DoorFactory:
    def makeDoor(self):
        pass

    def makeFittingExpert(self):
        pass


class WoodenDoorFactory(DoorFactory):
    def makeDoor(self):
        return WoodenDoor()

    def makeFittingExpert(self):
        return Carpenter()


class IronDoorFactory(DoorFactory):
    def makeDoor(self):
        return IronDoor()

    def makeFittingExpert(self):
        return Welder()


# ----------------------------

woodenFactory = WoodenDoorFactory()

door = woodenFactory.makeDoor()
expert = woodenFactory.makeFittingExpert()

door.getDescription()    # Output: I am a wooden door
expert.getDescription()  # Output: I can only fit wooden doors

# ----------------------------

ironFactory = IronDoorFactory()

door = ironFactory.makeDoor()
expert = ironFactory.makeFittingExpert()

door.getDescription()    # Output: I am an iron door
expert.getDescription()  # Output: I can only fit iron doors

interface Door {
    getDescription(): void;
}

class WoodenDoor implements Door {
    getDescription(): void {
        console.log("I am a wooden door");
    }
}

class IronDoor implements Door {
    getDescription(): void {
        console.log("I am an iron door");
    }
}

interface DoorFittingExpert {
    getDescription(): void;
}

class Carpenter implements DoorFittingExpert {
    getDescription(): void {
        console.log("I can only fit wooden doors");
    }
}

class Welder implements DoorFittingExpert {
    getDescription(): void {
        console.log("I can only fit iron doors");
    }
}

abstract class DoorFactory {
    abstract makeDoor(): Door;

    abstract makeFittingExpert(): DoorFittingExpert;
}

class WoodenDoorFactory extends DoorFactory {
    makeDoor(): WoodenDoor {
        return new WoodenDoor();
    }

    makeFittingExpert(): Carpenter {
        return new Carpenter();
    }
}

class IronDoorFactory extends DoorFactory {
    makeDoor(): IronDoor {
        return new IronDoor();
    }

    makeFittingExpert(): Welder {
        return new Welder();
    }
}

// ----------------------------

let woodenFactory = new WoodenDoorFactory();

let door = woodenFactory.makeDoor();
let expert = woodenFactory.makeFittingExpert();

door.getDescription();   // Output: I am a wooden door
expert.getDescription(); // Output: I can only fit wooden doors

// ----------------------------

let ironFactory = new IronDoorFactory();

door = ironFactory.makeDoor();
expert = ironFactory.makeFittingExpert();

door.getDescription();   // Output: I am an iron door
expert.getDescription(); // Output: I can only fit iron doors

class WoodenDoor {
    getDescription() {
        console.log("I am a wooden door");
    }
}

class IronDoor {
    getDescription() {
        console.log("I am an iron door");
    }
}

class Carpenter {
    getDescription() {
        console.log("I can only fit wooden doors");
    }
}

class Welder {
    getDescription() {
        console.log("I can only fit iron doors");
    }
}

class DoorFactory {
    makeDoor() {
        throw new Error("makeDoor() must be implemented by subclasses");
    }

    makeFittingExpert() {
        throw new Error("makeFittingExpert() must be implemented by subclasses");
    }
}

class WoodenDoorFactory extends DoorFactory {
    makeDoor() {
        return new WoodenDoor();
    }

    makeFittingExpert() {
        return new Carpenter();
    }
}

class IronDoorFactory extends DoorFactory {
    makeDoor() {
        return new IronDoor();
    }

    makeFittingExpert() {
        return new Welder();
    }
}

// ----------------------------

let woodenFactory = new WoodenDoorFactory();

let door = woodenFactory.makeDoor();
let expert = woodenFactory.makeFittingExpert();

door.getDescription();   // Output: I am a wooden door
expert.getDescription(); // Output: I can only fit wooden doors

// ----------------------------

let ironFactory = new IronDoorFactory();

door = ironFactory.makeDoor();
expert = ironFactory.makeFittingExpert();

door.getDescription();   // Output: I am an iron door
expert.getDescription(); // Output: I can only fit iron doors

using System;


interface IDoor {

  void GetDescription();

}
class WoodenDoor : IDoor
{
  public void GetDescription()
  {
    Console.WriteLine("I am a wooden door");
  }
}

class IronDoor : IDoor
{
  public void GetDescription()
  {
    Console.WriteLine("I am an iron door");
  }
}

interface IDoorFittingExpert
{
  void GetDescription();
}

class Carpenter : IDoorFittingExpert
{
  public void GetDescription()
  {
    Console.WriteLine("I can only fit wooden doors");
  }
}

class Welder : IDoorFittingExpert
{
  public void GetDescription()
  {
    Console.WriteLine("I can only fit iron doors");
  }
}

interface IDoorFactory {
  IDoor MakeDoor();
  IDoorFittingExpert MakeFittingExpert();
}

// Wooden factory to return carpenter and wooden door
class WoodenDoorFactory : IDoorFactory
{
  public IDoor MakeDoor()
  {
    return new WoodenDoor();
  }

  public IDoorFittingExpert MakeFittingExpert()
  {
    return new Carpenter();
  }
}

// Iron door factory to get iron door and the relevant fitting expert
class IronDoorFactory : IDoorFactory
{
  public IDoor MakeDoor()
  {
    return new IronDoor();
  }

  public IDoorFittingExpert MakeFittingExpert()
  {
    return new Welder();
  }
}
// ----------------------------
var woodenFactory = new WoodenDoorFactory();

var woodenDoor = woodenFactory.MakeDoor();
var woodenExpert = woodenFactory.MakeFittingExpert();

woodenDoor.GetDescription();   // Output: I am a wooden door
woodenExpert.GetDescription(); // Output: I can only fit wooden doors

// ----------------------------

var ironFactory = new IronDoorFactory();

var ironDoor = ironFactory.MakeDoor();
var ironExpert = ironFactory.MakeFittingExpert();

ironDoor.GetDescription();   // Output: I am an iron door
ironExpert.GetDescription(); // Output: I can only fit iron doors

interface DoorInterface {
  public function getDescription();
}

class WoodenDoor implements DoorInterface {
  public function getDescription() {
    echo "I am a wooden door";
  }
}

class IronDoor implements DoorInterface {
  public function getDescription() {
    echo "I am an iron door";
  }
}

interface DoorFittingExpertInterface {
  public function getDescription();
}

class Carpenter implements DoorFittingExpertInterface {
  public function getDescription() {
    echo "I can only fit wooden doors";
  }
}

class Welder implements DoorFittingExpertInterface {
  public function getDescription() {
    echo "I can only fit iron doors";
  }
}

interface DoorFactoryInterface {
  public function makeDoor(): DoorInterface;
  public function makeFittingExpert(): DoorFittingExpertInterface;
}

// Wooden factory to return carpenter and wooden door
class WoodenDoorFactory implements DoorFactoryInterface {
  public function makeDoor(): DoorInterface {
    return new WoodenDoor();
  }

  public function makeFittingExpert(): DoorFittingExpertInterface {
    return new Carpenter();
  }
}

// Iron door factory to get iron door and the relevant fitting expert
class IronDoorFactory implements DoorFactoryInterface {
  public function makeDoor(): DoorInterface {
    return new IronDoor();
  }

  public function makeFittingExpert(): DoorFittingExpertInterface {
    return new Welder();
  }
}


// Usage
$woodenFactory = new WoodenDoorFactory();

$woodenDoor = $woodenFactory->makeDoor();
$woodenExpert = $woodenFactory->makeFittingExpert();

$woodenDoor->getDescription();   // Output: I am a wooden door
echo "\n";
$woodenExpert->getDescription(); // Output: I can only fit wooden doors
echo "\n";

$ironFactory = new IronDoorFactory();

$ironDoor = $ironFactory->makeDoor();
$ironExpert = $ironFactory->makeFittingExpert();

$ironDoor->getDescription();   // Output: I am an iron door
echo "\n";
$ironExpert->getDescription(); // Output: I can only fit iron doors
echo "\n";

package main

import "fmt"

type IDoor interface {
	GetDescription()
}

type WoodenDoor struct{}

func (w *WoodenDoor) GetDescription() {
	fmt.Println("I am a wooden door")
}

type IronDoor struct{}

func (i *IronDoor) GetDescription() {
	fmt.Println("I am an iron door")
}

type IDoorFittingExpert interface {
	GetDescription()
}

type Carpenter struct{}

func (c *Carpenter) GetDescription() {
	fmt.Println("I can only fit wooden doors")
}

type Welder struct{}

func (w *Welder) GetDescription() {
	fmt.Println("I can only fit iron doors")
}

type IDoorFactory interface {
	MakeDoor() IDoor
	MakeFittingExpert() IDoorFittingExpert
}

type WoodenDoorFactory struct{}

func (w *WoodenDoorFactory) MakeDoor() IDoor {
	return &WoodenDoor{}
}

func (w *WoodenDoorFactory) MakeFittingExpert() IDoorFittingExpert {
	return &Carpenter{}
}

type IronDoorFactory struct{}

func (i *IronDoorFactory) MakeDoor() IDoor {
	return &IronDoor{}
}

func (i *IronDoorFactory) MakeFittingExpert() IDoorFittingExpert {
	return &Welder{}
}

func main() {
	woodenFactory := &WoodenDoorFactory{}

	woodenDoor := woodenFactory.MakeDoor()
	woodenExpert := woodenFactory.MakeFittingExpert()

	woodenDoor.GetDescription()   // Output: I am a wooden door
	woodenExpert.GetDescription() // Output: I can only fit wooden doors

	ironFactory := &IronDoorFactory{}

	ironDoor := ironFactory.MakeDoor()
	ironExpert := ironFactory.MakeFittingExpert()

	ironDoor.GetDescription()   // Output: I am an iron door
	ironExpert.GetDescription() // Output: I can only fit iron doors
}

interface Door {
    void getDescription();
}

class WoodenDoor implements Door {
    @Override
    public void getDescription() {
        System.out.println("I am a wooden door");
    }
}

class IronDoor implements Door {
    @Override
    public void getDescription() {
        System.out.println("I am an iron door");
    }
}

interface DoorFittingExpert {
    void getDescription();
}

class Carpenter implements DoorFittingExpert {
    @Override
    public void getDescription() {
        System.out.println("I can only fit wooden doors");
    }
}

class Welder implements DoorFittingExpert {
    @Override
    public void getDescription() {
        System.out.println("I can only fit iron doors");
    }
}

interface DoorFactory {
    Door makeDoor();
    DoorFittingExpert makeFittingExpert();
}

class WoodenDoorFactory implements DoorFactory {
    @Override
    public WoodenDoor makeDoor() {
        return new WoodenDoor();
    }

    @Override
    public Carpenter makeFittingExpert() {
        return new Carpenter();
    }
}

class IronDoorFactory implements DoorFactory {
    @Override
    public IronDoor makeDoor() {
        return new IronDoor();
    }

    @Override
    public Welder makeFittingExpert() {
        return new Welder();
    }
}

// ----------------------------

WoodenDoorFactory woodenFactory = new WoodenDoorFactory();
Door woodenDoor = woodenFactory.makeDoor();
DoorFittingExpert woodenExpert = woodenFactory.makeFittingExpert();

woodenDoor.getDescription();   // Output: I am a wooden door
woodenExpert.getDescription(); // Output: I can only fit wooden doors

// ----------------------------

IronDoorFactory ironFactory = new IronDoorFactory();
Door ironDoor = ironFactory.makeDoor();
DoorFittingExpert ironExpert = ironFactory.makeFittingExpert();

ironDoor.getDescription();   // Output: I am an iron door
ironExpert.getDescription(); // Output: I can only fit iron doors

#include <iostream>
#include <memory>

// Door interface
class Door {
public:
    virtual ~Door() = default;
    virtual void getDescription() = 0;
};

// Wooden door
class WoodenDoor : public Door {
public:
    void getDescription() override {
        std::cout << "I am a wooden door" << std::endl;
    }
};

// Iron door
class IronDoor : public Door {
public:
    void getDescription() override {
        std::cout << "I am an iron door" << std::endl;
    }
};

// Door fitting expert interface
class DoorFittingExpert {
public:
    virtual ~DoorFittingExpert() = default;
    virtual void getDescription() = 0;
};

// Carpenter
class Carpenter : public DoorFittingExpert {
public:
    void getDescription() override {
        std::cout << "I can only fit wooden doors" << std::endl;
    }
};

// Welder
class Welder : public DoorFittingExpert {
public:
    void getDescription() override {
        std::cout << "I can only fit iron doors" << std::endl;
    }
};

// Door factory interface
class DoorFactory {
public:
    virtual ~DoorFactory() = default;
    virtual std::unique_ptr<Door> makeDoor() = 0;
    virtual std::unique_ptr<DoorFittingExpert> makeFittingExpert() = 0;
};

// Wooden door factory
class WoodenDoorFactory : public DoorFactory {
public:
    std::unique_ptr<Door> makeDoor() override {
        return std::make_unique<WoodenDoor>();
    }
    
    std::unique_ptr<DoorFittingExpert> makeFittingExpert() override {
        return std::make_unique<Carpenter>();
    }
};

// Iron door factory
class IronDoorFactory : public DoorFactory {
public:
    std::unique_ptr<Door> makeDoor() override {
        return std::make_unique<IronDoor>();
    }
    
    std::unique_ptr<DoorFittingExpert> makeFittingExpert() override {
        return std::make_unique<Welder>();
    }
};

// Usage
int main() {
    WoodenDoorFactory woodenFactory;
    auto woodenDoor = woodenFactory.makeDoor();
    auto woodenExpert = woodenFactory.makeFittingExpert();

    woodenDoor->getDescription();   // Output: I am a wooden door
    woodenExpert->getDescription(); // Output: I can only fit wooden doors

    IronDoorFactory ironFactory;
    auto ironDoor = ironFactory.makeDoor();
    auto ironExpert = ironFactory.makeFittingExpert();

    ironDoor->getDescription();   // Output: I am an iron door
    ironExpert->getDescription(); // Output: I can only fit iron doors

    return 0;
}

interface Door {
    fun getDescription()
}

class WoodenDoor : Door {
    override fun getDescription() {
        println("I am a wooden door")
    }
}

class IronDoor : Door {
    override fun getDescription() {
        println("I am an iron door")
    }
}

interface DoorFittingExpert {
    fun getDescription()
}

class Carpenter : DoorFittingExpert {
    override fun getDescription() {
        println("I can only fit wooden doors")
    }
}

class Welder : DoorFittingExpert {
    override fun getDescription() {
        println("I can only fit iron doors")
    }
}

interface DoorFactory {
    fun makeDoor(): Door
    fun makeFittingExpert(): DoorFittingExpert
}

class WoodenDoorFactory : DoorFactory {
    override fun makeDoor(): Door = WoodenDoor()
    override fun makeFittingExpert(): DoorFittingExpert = Carpenter()
}

class IronDoorFactory : DoorFactory {
    override fun makeDoor(): Door = IronDoor()
    override fun makeFittingExpert(): DoorFittingExpert = Welder()
}

// ----------------------------

fun main() {
    val woodenFactory = WoodenDoorFactory()

    val woodenDoor = woodenFactory.makeDoor()
    val woodenExpert = woodenFactory.makeFittingExpert()

    woodenDoor.getDescription()
    woodenExpert.getDescription()

    val ironFactory = IronDoorFactory()

    val ironDoor = ironFactory.makeDoor()
    val ironExpert = ironFactory.makeFittingExpert()

    ironDoor.getDescription()
    ironExpert.getDescription()
}

abstract class Door {
  void getDescription();
}

class WoodenDoor implements Door {
  @override
  void getDescription() => print('I am a wooden door');
}

class IronDoor implements Door {
  @override
  void getDescription() => print('I am an iron door');
}

abstract class DoorFittingExpert {
  void getDescription();
}

class Carpenter implements DoorFittingExpert {
  @override
  void getDescription() => print('I can only fit wooden doors');
}

class Welder implements DoorFittingExpert {
  @override
  void getDescription() => print('I can only fit iron doors');
}

abstract class DoorFactory {
  Door makeDoor();
  DoorFittingExpert makeFittingExpert();
}

class WoodenDoorFactory implements DoorFactory {
  @override
  Door makeDoor() => WoodenDoor();

  @override
  DoorFittingExpert makeFittingExpert() => Carpenter();
}

class IronDoorFactory implements DoorFactory {
  @override
  Door makeDoor() => IronDoor();

  @override
  DoorFittingExpert makeFittingExpert() => Welder();
}

// ----------------------------

void main() {
  var woodenFactory = WoodenDoorFactory();

  var door = woodenFactory.makeDoor();
  var expert = woodenFactory.makeFittingExpert();

  door.getDescription();
  expert.getDescription();

  var ironFactory = IronDoorFactory();

  door = ironFactory.makeDoor();
  expert = ironFactory.makeFittingExpert();

  door.getDescription();
  expert.getDescription();
}

def __init__(self, size, cheese=True, mushrooms=True, tomato=False): ...

constructor(size: number, cheese: boolean = true, mushrooms: boolean = true, tomato: boolean = false) {}

constructor(size, cheese = true, mushrooms = true, tomato = false) {}

using System;


public Burger(int size, bool cheese, bool mushrooms, bool tomato)

public function __construct(int $size, bool $cheese, bool $mushrooms, bool $tomato)

func Burger(size int, cheese bool, mushrooms bool, tomato bool)

public Burger(int size, boolean cheese, boolean mushrooms, boolean tomato)

class Burger(size: Int, cheese: Boolean, mushrooms: Boolean, tomato: Boolean)

class Burger {
  Burger(int size, bool cheese, bool mushrooms, bool tomato);
}

class Burger:
    def __init__(self, builder):
        self.size = builder.size
        self.cheese = builder.cheese
        self.mushrooms = builder.mushrooms
        self.tomato = builder.tomato

    def get_description(self):
        return (
            f"Burger: size {self.size}, cheese: {str(self.cheese).lower()}, "
            f"mushrooms: {str(self.mushrooms).lower()}, tomato: {str(self.tomato).lower()}"
        )


class BurgerBuilder:
    def __init__(self, size):
        self.size = size
        self.cheese = False
        self.mushrooms = False
        self.tomato = False

    def add_cheese(self):
        self.cheese = True
        return self

    def add_mushrooms(self):
        self.mushrooms = True
        return self

    def add_tomato(self):
        self.tomato = True
        return self

    def build(self):
        return Burger(self)


# ----------------------------

burger = BurgerBuilder(14).add_cheese().add_mushrooms().build()

print(burger.get_description())
# Burger: size 14, cheese: true, mushrooms: true, tomato: false

class Burger {
    private size: number;
    private cheese: boolean;
    private mushrooms: boolean;
    private tomato: boolean;

    constructor(builder: BurgerBuilder) {
        this.size = builder.size;
        this.cheese = builder.cheese;
        this.mushrooms = builder.mushrooms;
        this.tomato = builder.tomato;
    }

    getDescription(): string {
        return `Burger: size ${this.size}, cheese: ${this.cheese}, ` +
            `mushrooms: ${this.mushrooms}, tomato: ${this.tomato}`;
    }
}

class BurgerBuilder {
    size: number;
    cheese: boolean = false;
    mushrooms: boolean = false;
    tomato: boolean = false;

    constructor(size: number) {
        this.size = size;
    }

    addCheese(): this {
        this.cheese = true;
        return this;
    }

    addMushrooms(): this {
        this.mushrooms = true;
        return this;
    }

    addTomato(): this {
        this.tomato = true;
        return this;
    }

    build(): Burger {
        return new Burger(this);
    }
}

// ----------------------------

const burger = new BurgerBuilder(14)
    .addCheese()
    .addMushrooms()
    .build();

console.log(burger.getDescription());
// Burger: size 14, cheese: true, mushrooms: true, tomato: false

class Burger {
    constructor(builder) {
        this.size = builder.size;
        this.cheese = builder.cheese;
        this.mushrooms = builder.mushrooms;
        this.tomato = builder.tomato;
    }

    getDescription() {
        return `Burger: size ${this.size}, cheese: ${this.cheese}, ` +
            `mushrooms: ${this.mushrooms}, tomato: ${this.tomato}`;
    }
}

class BurgerBuilder {
    constructor(size) {
        this.size = size;
        this.cheese = false;
        this.mushrooms = false;
        this.tomato = false;
    }

    addCheese() {
        this.cheese = true;
        return this;
    }

    addMushrooms() {
        this.mushrooms = true;
        return this;
    }

    addTomato() {
        this.tomato = true;
        return this;
    }

    build() {
        return new Burger(this);
    }
}

// ----------------------------

const burger = new BurgerBuilder(14)
    .addCheese()
    .addMushrooms()
    .build();

console.log(burger.getDescription());
// Burger: size 14, cheese: true, mushrooms: true, tomato: false

using System;
using System.Text;

class Burger
{
  private int mSize;
  private bool mCheese;
  private bool mMushrooms;
  private bool mTomato;

  public Burger(BurgerBuilder builder)
  {
    this.mSize = builder.Size;
    this.mCheese = builder.Cheese;
    this.mMushrooms = builder.Mushrooms;
    this.mTomato = builder.Tomato;
  }

  public string GetDescription()
  {
    var sb = new StringBuilder();
    sb.Append($"Burger: size {this.mSize}, ");
    sb.Append($"cheese: {this.mCheese.ToString().ToLower()}, ");
    sb.Append($"mushrooms: {this.mMushrooms.ToString().ToLower()}, ");
    sb.Append($"tomato: {this.mTomato.ToString().ToLower()}");
    return sb.ToString();
  }
}

class BurgerBuilder {
  public int Size;
  public bool Cheese;
  public bool Mushrooms;
  public bool Tomato;

  public BurgerBuilder(int size)
  {
    this.Size = size;
  }

  public BurgerBuilder AddCheese()
  {
    this.Cheese = true;
    return this;
  }

  public BurgerBuilder AddMushrooms()
  {
    this.Mushrooms = true;
    return this;
  }

  public BurgerBuilder AddTomato()
  {
    this.Tomato = true;
    return this;
  }

  public Burger Build()
  {
    return new Burger(this);
  }
}

// ----------------------------

var burger = new BurgerBuilder(14)
                .AddCheese()
                .AddMushrooms()
                .Build();
Console.WriteLine(burger.GetDescription());
// Burger: size 14, cheese: true, mushrooms: true, tomato: false

class Burger {
    private $size;
    private $cheese = false;
    private $mushrooms = false;
    private $tomato = false;

    public function __construct($builder) {
        $this->size = $builder->size;
        $this->cheese = $builder->cheese;
        $this->mushrooms = $builder->mushrooms;
        $this->tomato = $builder->tomato;
    }

    public function getDescription() {
        $cheese = $this->cheese ? 'true' : 'false';
        $mushrooms = $this->mushrooms ? 'true' : 'false';
        $tomato = $this->tomato ? 'true' : 'false';
        return "Burger: size {$this->size}, cheese: {$cheese}, "
            . "mushrooms: {$mushrooms}, tomato: {$tomato}";
    }
}

class BurgerBuilder {
    public $size;
    public $cheese = false;
    public $mushrooms = false;
    public $tomato = false;

    public function __construct($size) {
        $this->size = $size;
    }

    public function addCheese() {
        $this->cheese = true;
        return $this;
    }

    public function addMushrooms() {
        $this->mushrooms = true;
        return $this;
    }

    public function addTomato() {
        $this->tomato = true;
        return $this;
    }

    public function build() {
        return new Burger($this);
    }
}

$burger = (new BurgerBuilder(14))
            ->addCheese()
            ->addMushrooms()
            ->build();

echo $burger->getDescription() . "\n";
// Burger: size 14, cheese: true, mushrooms: true, tomato: false

package main

import (
	"fmt"
)

type Burger struct {
	Size      int
	Cheese    bool
	Mushrooms bool
	Tomato    bool
}

func NewBurger(builder *BurgerBuilder) *Burger {
	return &Burger{
		Size:      builder.Size,
		Cheese:    builder.Cheese,
		Mushrooms: builder.Mushrooms,
		Tomato:    builder.Tomato,
	}
}

func (b *Burger) GetDescription() string {
	return fmt.Sprintf("Burger: size %d, cheese: %t, mushrooms: %t, tomato: %t",
		b.Size, b.Cheese, b.Mushrooms, b.Tomato)
}

type BurgerBuilder struct {
	Size      int
	Cheese    bool
	Mushrooms bool
	Tomato    bool
}

func NewBurgerBuilder(size int) *BurgerBuilder {
	return &BurgerBuilder{Size: size}
}

func (b *BurgerBuilder) AddCheese() *BurgerBuilder {
	b.Cheese = true
	return b
}

func (b *BurgerBuilder) AddMushrooms() *BurgerBuilder {
	b.Mushrooms = true
	return b
}

func (b *BurgerBuilder) AddTomato() *BurgerBuilder {
	b.Tomato = true
	return b
}

func (b *BurgerBuilder) Build() *Burger {
	return NewBurger(b)
}

func main() {
	burger := NewBurgerBuilder(14).AddCheese().AddMushrooms().Build()
	fmt.Println(burger.GetDescription())
	// Burger: size 14, cheese: true, mushrooms: true, tomato: false
}

class Burger {
    private int size;
    private boolean cheese;
    private boolean mushrooms;
    private boolean tomato;

    public Burger(BurgerBuilder builder) {
        this.size = builder.size;
        this.cheese = builder.cheese;
        this.mushrooms = builder.mushrooms;
        this.tomato = builder.tomato;
    }

    public String getDescription() {
        return "Burger: size " + this.size
                + ", cheese: " + this.cheese
                + ", mushrooms: " + this.mushrooms
                + ", tomato: " + this.tomato;
    }
}

class BurgerBuilder {
    public int size;
    public boolean cheese;
    public boolean mushrooms;
    public boolean tomato;

    public BurgerBuilder(int size) {
        this.size = size;
    }

    public BurgerBuilder addCheese() {
        this.cheese = true;
        return this;
    }

    public BurgerBuilder addMushrooms() {
        this.mushrooms = true;
        return this;
    }

    public BurgerBuilder addTomato() {
        this.tomato = true;
        return this;
    }

    public Burger build() {
        return new Burger(this);
    }
}

// ----------------------------

Burger burger = new BurgerBuilder(14)
        .addCheese()
        .addMushrooms()
        .build();

System.out.println(burger.getDescription());
// Burger: size 14, cheese: true, mushrooms: true, tomato: false

#include <iostream>
#include <string>
#include <memory>

class BurgerBuilder;

class Burger {
private:
    int size;
    bool cheese;
    bool mushrooms;
    bool tomato;

public:
    Burger(int size, bool cheese, bool mushrooms, bool tomato)
        : size(size), cheese(cheese), mushrooms(mushrooms), tomato(tomato) {}

    std::string getDescription() const {
        auto b = [](bool v) { return v ? "true" : "false"; };
        return "Burger: size " + std::to_string(size) +
               ", cheese: " + b(cheese) +
               ", mushrooms: " + b(mushrooms) +
               ", tomato: " + b(tomato);
    }
};

class BurgerBuilder {
private:
    int size;
    bool cheese = false;
    bool mushrooms = false;
    bool tomato = false;

public:
    explicit BurgerBuilder(int size) : size(size) {}

    BurgerBuilder& addCheese() {
        this->cheese = true;
        return *this;
    }

    BurgerBuilder& addMushrooms() {
        this->mushrooms = true;
        return *this;
    }

    BurgerBuilder& addTomato() {
        this->tomato = true;
        return *this;
    }

    std::unique_ptr<Burger> build() {
        return std::make_unique<Burger>(size, cheese, mushrooms, tomato);
    }
};

// ----------------------------

int main() {
    auto burger = BurgerBuilder(14)
        .addCheese()
        .addMushrooms()
        .build();

    std::cout << burger->getDescription() << std::endl;
    // Burger: size 14, cheese: true, mushrooms: true, tomato: false

    return 0;
}

class Burger(builder: BurgerBuilder) {
    private val size: Int = builder.size
    private val cheese: Boolean = builder.cheese
    private val mushrooms: Boolean = builder.mushrooms
    private val tomato: Boolean = builder.tomato

    fun getDescription(): String {
        return "Burger: size $size, cheese: $cheese, " +
            "mushrooms: $mushrooms, tomato: $tomato"
    }
}

class BurgerBuilder(val size: Int) {
    var cheese: Boolean = false
    var mushrooms: Boolean = false
    var tomato: Boolean = false

    fun addCheese(): BurgerBuilder {
        cheese = true
        return this
    }

    fun addMushrooms(): BurgerBuilder {
        mushrooms = true
        return this
    }

    fun addTomato(): BurgerBuilder {
        tomato = true
        return this
    }

    fun build(): Burger {
        return Burger(this)
    }
}

// ----------------------------

fun main() {
    val burger = BurgerBuilder(14)
        .addCheese()
        .addMushrooms()
        .build()

    println(burger.getDescription())
}

class Burger {
  final int size;
  final bool cheese;
  final bool mushrooms;
  final bool tomato;

  Burger(BurgerBuilder builder)
      : size = builder.size,
        cheese = builder.cheese,
        mushrooms = builder.mushrooms,
        tomato = builder.tomato;

  String getDescription() {
    return 'Burger: size $size, cheese: $cheese, '
        'mushrooms: $mushrooms, tomato: $tomato';
  }
}

class BurgerBuilder {
  final int size;
  bool cheese = false;
  bool mushrooms = false;
  bool tomato = false;

  BurgerBuilder(this.size);

  BurgerBuilder addCheese() {
    cheese = true;
    return this;
  }

  BurgerBuilder addMushrooms() {
    mushrooms = true;
    return this;
  }

  BurgerBuilder addTomato() {
    tomato = true;
    return this;
  }

  Burger build() => Burger(this);
}

// ----------------------------

void main() {
  var burger = BurgerBuilder(14).addCheese().addMushrooms().build();

  print(burger.getDescription());
}

import copy


class Address:
    def __init__(self, city):
        self.city = city


class Person:
    def __init__(self, name, address):
        self.name = name
        self.address = address  # nested mutable object

    def __copy__(self):
        # Shallow copy: new Person, but the SAME Address object is shared
        return Person(self.name, self.address)

    def __deepcopy__(self, memo):
        # Deep copy: the nested Address is copied too, so it is independent
        return Person(self.name, copy.deepcopy(self.address, memo))


# Shallow clone: shares the nested Address
original = Person("Sara", Address("Tehran"))
shallow = copy.copy(original)
shallow.address.city = "Shiraz"
print(shallow.address.city)    # Shiraz
print(original.address.city)   # Shiraz  -> the original changed too (shared Address)

# Deep clone: gets its own Address
original = Person("Sara", Address("Tehran"))
deep = copy.deepcopy(original)
deep.address.city = "Shiraz"
print(deep.address.city)       # Shiraz
print(original.address.city)   # Tehran  -> the original stayed the same

class Address {
    city: string;

    constructor(city: string) {
        this.city = city;
    }
}

class Person {
    name: string;
    address: Address; // nested mutable object

    constructor(name: string, address: Address) {
        this.name = name;
        this.address = address;
    }

    // Shallow copy: new Person, but the SAME Address object is shared
    shallowCopy(): Person {
        return new Person(this.name, this.address);
    }

    // Deep copy: the nested Address is copied too, so it is independent
    deepCopy(): Person {
        return new Person(this.name, new Address(this.address.city));
    }
}

// Shallow clone: shares the nested Address
let original = new Person("Sara", new Address("Tehran"));
let shallow = original.shallowCopy();
shallow.address.city = "Shiraz";
console.log(shallow.address.city);    // Shiraz
console.log(original.address.city);   // Shiraz  -> the original changed too (shared Address)

// Deep clone: gets its own Address
original = new Person("Sara", new Address("Tehran"));
let deep = original.deepCopy();
deep.address.city = "Shiraz";
console.log(deep.address.city);       // Shiraz
console.log(original.address.city);   // Tehran  -> the original stayed the same

class Address {
    constructor(city) {
        this.city = city;
    }
}

class Person {
    constructor(name, address) {
        this.name = name;
        this.address = address; // nested mutable object
    }

    // Shallow copy: new Person, but the SAME Address object is shared
    shallowCopy() {
        return new Person(this.name, this.address);
    }

    // Deep copy: the nested Address is copied too, so it is independent
    deepCopy() {
        return new Person(this.name, new Address(this.address.city));
    }
}

// Shallow clone: shares the nested Address
let original = new Person("Sara", new Address("Tehran"));
let shallow = original.shallowCopy();
shallow.address.city = "Shiraz";
console.log(shallow.address.city);    // Shiraz
console.log(original.address.city);   // Shiraz  -> the original changed too (shared Address)

// Deep clone: gets its own Address
original = new Person("Sara", new Address("Tehran"));
let deep = original.deepCopy();
deep.address.city = "Shiraz";
console.log(deep.address.city);       // Shiraz
console.log(original.address.city);   // Tehran  -> the original stayed the same

using System;

public class Address
{
    public string City;

    public Address(string city)
    {
        City = city;
    }
}

public class Person
{
    public string Name;
    public Address Address; // nested mutable object

    public Person(string name, Address address)
    {
        Name = name;
        Address = address;
    }

    // Shallow copy: MemberwiseClone keeps the SAME Address reference (shared)
    public Person ShallowCopy()
    {
        return (Person)this.MemberwiseClone();
    }

    // Deep copy: also copy the nested Address, so it is independent
    public Person DeepCopy()
    {
        Person clone = (Person)this.MemberwiseClone();
        clone.Address = new Address(this.Address.City);
        return clone;
    }
}

public class Program
{
    public static void Main()
    {
        // Shallow clone: shares the nested Address
        Person original = new Person("Sara", new Address("Tehran"));
        Person shallow = original.ShallowCopy();
        shallow.Address.City = "Shiraz";
        Console.WriteLine(shallow.Address.City);    // Shiraz
        Console.WriteLine(original.Address.City);   // Shiraz  -> the original changed too (shared Address)

        // Deep clone: gets its own Address
        original = new Person("Sara", new Address("Tehran"));
        Person deep = original.DeepCopy();
        deep.Address.City = "Shiraz";
        Console.WriteLine(deep.Address.City);       // Shiraz
        Console.WriteLine(original.Address.City);   // Tehran  -> the original stayed the same
    }
}

class Address
{
    public string $city;

    public function __construct(string $city)
    {
        $this->city = $city;
    }
}

class Person
{
    public string $name;
    public Address $address; // nested mutable object

    public function __construct(string $name, Address $address)
    {
        $this->name = $name;
        $this->address = $address;
    }

    // Shallow copy: clone keeps the SAME Address object (shared)
    public function shallowCopy(): Person
    {
        return clone $this;
    }

    // Deep copy: also copy the nested Address, so it is independent
    public function deepCopy(): Person
    {
        $clone = clone $this;
        $clone->address = new Address($this->address->city);
        return $clone;
    }
}

// Shallow clone: shares the nested Address
$original = new Person("Sara", new Address("Tehran"));
$shallow = $original->shallowCopy();
$shallow->address->city = "Shiraz";
echo $shallow->address->city . "\n";    // Shiraz
echo $original->address->city . "\n";   // Shiraz  -> the original changed too (shared Address)

// Deep clone: gets its own Address
$original = new Person("Sara", new Address("Tehran"));
$deep = $original->deepCopy();
$deep->address->city = "Shiraz";
echo $deep->address->city . "\n";       // Shiraz
echo $original->address->city . "\n";   // Tehran  -> the original stayed the same

package main

import "fmt"

type Address struct {
	City string
}

type Person struct {
	Name    string
	Address *Address // nested mutable object
}

// Shallow copy: new Person, but the SAME Address pointer is shared
func (p *Person) ShallowCopy() *Person {
	return &Person{Name: p.Name, Address: p.Address}
}

// Deep copy: the nested Address is copied too, so it is independent
func (p *Person) DeepCopy() *Person {
	return &Person{Name: p.Name, Address: &Address{City: p.Address.City}}
}

func main() {
	// Shallow clone: shares the nested Address
	original := &Person{Name: "Sara", Address: &Address{City: "Tehran"}}
	shallow := original.ShallowCopy()
	shallow.Address.City = "Shiraz"
	fmt.Println(shallow.Address.City)  // Shiraz
	fmt.Println(original.Address.City) // Shiraz  -> the original changed too (shared Address)

	// Deep clone: gets its own Address
	original = &Person{Name: "Sara", Address: &Address{City: "Tehran"}}
	deep := original.DeepCopy()
	deep.Address.City = "Shiraz"
	fmt.Println(deep.Address.City)     // Shiraz
	fmt.Println(original.Address.City) // Tehran  -> the original stayed the same
}

class Address {
    String city;

    Address(String city) {
        this.city = city;
    }
}

class Person {
    String name;
    Address address; // nested mutable object

    Person(String name, Address address) {
        this.name = name;
        this.address = address;
    }

    // Shallow copy: new Person, but the SAME Address object is shared
    Person shallowCopy() {
        return new Person(this.name, this.address);
    }

    // Deep copy: the nested Address is copied too, so it is independent
    Person deepCopy() {
        return new Person(this.name, new Address(this.address.city));
    }
}

public class Proto {
    public static void main(String[] args) {
        // Shallow clone: shares the nested Address
        Person original = new Person("Sara", new Address("Tehran"));
        Person shallow = original.shallowCopy();
        shallow.address.city = "Shiraz";
        System.out.println(shallow.address.city);    // Shiraz
        System.out.println(original.address.city);   // Shiraz  -> the original changed too (shared Address)

        // Deep clone: gets its own Address
        original = new Person("Sara", new Address("Tehran"));
        Person deep = original.deepCopy();
        deep.address.city = "Shiraz";
        System.out.println(deep.address.city);       // Shiraz
        System.out.println(original.address.city);   // Tehran  -> the original stayed the same
    }
}

#include <iostream>
#include <string>
#include <memory>

class Address {
public:
    std::string city;
    Address(const std::string& city) : city(city) {}
};

class Person {
public:
    std::string name;
    std::shared_ptr<Address> address; // nested mutable object

    Person(const std::string& name, std::shared_ptr<Address> address)
        : name(name), address(address) {}

    // Shallow copy: new Person, but the SAME Address object is shared
    Person shallowCopy() const {
        return Person(name, address);
    }

    // Deep copy: the nested Address is copied too, so it is independent
    Person deepCopy() const {
        return Person(name, std::make_shared<Address>(address->city));
    }
};

int main() {
    // Shallow clone: shares the nested Address
    Person original("Sara", std::make_shared<Address>("Tehran"));
    Person shallow = original.shallowCopy();
    shallow.address->city = "Shiraz";
    std::cout << shallow.address->city << std::endl;   // Shiraz
    std::cout << original.address->city << std::endl;  // Shiraz  -> the original changed too (shared Address)

    // Deep clone: gets its own Address
    original = Person("Sara", std::make_shared<Address>("Tehran"));
    Person deep = original.deepCopy();
    deep.address->city = "Shiraz";
    std::cout << deep.address->city << std::endl;      // Shiraz
    std::cout << original.address->city << std::endl;  // Tehran  -> the original stayed the same

    return 0;
}

class Address(var city: String)

class Person(val name: String, val address: Address) { // nested mutable object
    // Shallow copy: new Person, but the SAME Address object is shared
    fun shallowCopy(): Person {
        return Person(name, address)
    }

    // Deep copy: the nested Address is copied too, so it is independent
    fun deepCopy(): Person {
        return Person(name, Address(address.city))
    }
}

// ----------------------------

fun main() {
    // Shallow clone: shares the nested Address
    var original = Person("Sara", Address("Tehran"))
    val shallow = original.shallowCopy()
    shallow.address.city = "Shiraz"
    println(shallow.address.city)    // Shiraz
    println(original.address.city)   // Shiraz  -> the original changed too (shared Address)

    // Deep clone: gets its own Address
    original = Person("Sara", Address("Tehran"))
    val deep = original.deepCopy()
    deep.address.city = "Shiraz"
    println(deep.address.city)       // Shiraz
    println(original.address.city)   // Tehran  -> the original stayed the same
}

class Address {
  String city;

  Address(this.city);
}

class Person {
  String name;
  Address address; // nested mutable object

  Person(this.name, this.address);

  // Shallow copy: new Person, but the SAME Address object is shared
  Person shallowCopy() {
    return Person(name, address);
  }

  // Deep copy: the nested Address is copied too, so it is independent
  Person deepCopy() {
    return Person(name, Address(address.city));
  }
}

// ----------------------------

void main() {
  // Shallow clone: shares the nested Address
  var original = Person('Sara', Address('Tehran'));
  var shallow = original.shallowCopy();
  shallow.address.city = 'Shiraz';
  print(shallow.address.city);    // Shiraz
  print(original.address.city);   // Shiraz  -> the original changed too (shared Address)

  // Deep clone: gets its own Address
  original = Person('Sara', Address('Tehran'));
  var deep = original.deepCopy();
  deep.address.city = 'Shiraz';
  print(deep.address.city);       // Shiraz
  print(original.address.city);   // Tehran  -> the original stayed the same
}

class SingletonMeta(type):
    _instances = {}

    def __call__(cls, *args, **kwargs):
        if cls not in cls._instances:
            cls._instances[cls] = super().__call__(*args, **kwargs)
        return cls._instances[cls]


class President(metaclass=SingletonMeta):
    pass


if __name__ == "__main__":
    # The client code.

    a = President()
    b = President()

    print("Same instance?", "True" if a is b else "False")
    # Output: Same instance? True

class President {
    private static instance: President;

    private constructor() {
        // Private constructor prevents direct instantiation
    }

    public static getInstance(): President {
        if (!President.instance) {
            President.instance = new President();
        }
        return President.instance;
    }
}

// ----------------------------

const a = President.getInstance();
const b = President.getInstance();

console.log("Same instance?", Object.is(a, b) ? "True" : "False");
// Output: Same instance? True

class President {
    static #instance;

    static getInstance() {
        if (!President.#instance) {
            President.#instance = new President();
        }
        return President.#instance;
    }
}

const a = President.getInstance();
const b = President.getInstance();

console.log("Same instance?", Object.is(a, b) ? "True" : "False");
// Output: Same instance? True

using System;


public class President
{
  static President instance;

  // Private constructor hides direct instantiation
  private President()
  {
  }

  public static President GetInstance()
  {
    if (instance == null) {
      instance = new President();
    }
    return instance;
  }
}

// ----------------------------

President a = President.GetInstance();
President b = President.GetInstance();

Console.WriteLine($"Same instance? {(a == b ? "True" : "False")}");
// Output: Same instance? True

class President
{
  private static $instance;

  private function __construct()
  {
    // Hiding the Constructor
  }

  public static function getInstance()
  {
    if (self::$instance == null) {
      self::$instance = new President();
    }
    return self::$instance;
  }
}

$a = President::getInstance();
$b = President::getInstance();

echo "Same instance? " . ($a === $b ? "True" : "False") . "\n";
// Output: Same instance? True

type President struct{}

var instance *President

func GetInstance() *President {
  if instance == nil {
    instance = &President{}
  }
  return instance
}

// -----------------------

a := GetInstance()
b := GetInstance()

same := "False"
if a == b {
  same = "True"
}
fmt.Println("Same instance?", same)
// Output: Same instance? True

class President {
    private static President instance;
    // Private constructor
    private President() {
        // Hiding the Constructor
    }

    public static President getInstance() {
        if (instance == null) {
            instance = new President();
        }
        return instance;
    }
}

// ----------------------------

President a = President.getInstance();
President b = President.getInstance();

System.out.println("Same instance? " + (a == b ? "True" : "False"));
// Output: Same instance? True

#include <iostream>

class President {
private:
    // Private constructor
    President() = default;

    // Delete copy constructor and assignment operator
    President(const President&) = delete;
    President& operator=(const President&) = delete;

public:
    // Thread-safe in C++11 and later (Meyers singleton)
    static President& getInstance() {
        static President instance;
        return instance;
    }
};

int main() {
    President& a = President::getInstance();
    President& b = President::getInstance();

    std::cout << "Same instance? " << (&a == &b ? "True" : "False") << std::endl;
    // Output: Same instance? True
    return 0;
}

object President {
    // The single instance is the object itself
}

// ----------------------------

fun main() {
    val a = President
    val b = President

    println("Same instance? " + if (a === b) "True" else "False")
}

class President {
  static final President _instance = President._internal();

  President._internal();

  factory President() {
    return _instance;
  }
}

// ----------------------------

void main() {
  var a = President();
  var b = President();

  print("Same instance? ${identical(a, b) ? "True" : "False"}");
}

class Lion:
    def roar(self) -> str:
        raise NotImplementedError


class AfricanLion(Lion):
    def roar(self) -> str:
        return "Roaaar"


class Hunter:
    def hunt(self, lion: Lion) -> None:
        print("The hunter is hunting...")
        print(lion.roar())


class WildDog:
    def bark(self) -> str:
        return "Woof"


class WildDogAdapter(Lion):
    def __init__(self, dog: WildDog):
        self.dog = dog

    def roar(self) -> str:
        return self.dog.bark()


# ----------------------------

african_lion = AfricanLion()
wild_dog = WildDog()
wild_dog_adapter = WildDogAdapter(wild_dog)

hunter = Hunter()
hunter.hunt(african_lion)       # The hunter is hunting... -> Roaaar
hunter.hunt(wild_dog_adapter)   # The hunter is hunting... -> Woof

# Output:
# The hunter is hunting...
# Roaaar
# The hunter is hunting...
# Woof

interface Lion {
    roar(): string;
}

class AfricanLion implements Lion {
    roar(): string {
        return "Roaaar";
    }
}

class Hunter {
    hunt(lion: Lion): void {
        console.log("The hunter is hunting...");
        console.log(lion.roar());
    }
}

class WildDog {
    bark(): string {
        return "Woof";
    }
}

class WildDogAdapter implements Lion {
    private dog: WildDog;

    constructor(dog: WildDog) {
        this.dog = dog;
    }

    roar(): string {
        return this.dog.bark();
    }
}

// ----------------------------

const africanLion = new AfricanLion();
const wildDog = new WildDog();
const wildDogAdapter = new WildDogAdapter(wildDog);

const hunter = new Hunter();
hunter.hunt(africanLion);      // The hunter is hunting... -> Roaaar
hunter.hunt(wildDogAdapter);   // The hunter is hunting... -> Woof

// Output:
// The hunter is hunting...
// Roaaar
// The hunter is hunting...
// Woof

class Lion {
    roar() {
        return "";
    }
}

class AfricanLion extends Lion {
    roar() {
        return "Roaaar";
    }
}

class Hunter {
    hunt(lion) {
        console.log("The hunter is hunting...");
        console.log(lion.roar());
    }
}

class WildDog {
    bark() {
        return "Woof";
    }
}

class WildDogAdapter extends Lion {
    constructor(dog) {
        super();
        this.dog = dog;
    }

    roar() {
        return this.dog.bark();
    }
}

// ----------------------------

const africanLion = new AfricanLion();
const wildDog = new WildDog();
const wildDogAdapter = new WildDogAdapter(wildDog);

const hunter = new Hunter();
hunter.hunt(africanLion);      // The hunter is hunting... -> Roaaar
hunter.hunt(wildDogAdapter);   // The hunter is hunting... -> Woof

// Output:
// The hunter is hunting...
// Roaaar
// The hunter is hunting...
// Woof

using System;

interface ILion
{
  string Roar();
}

class AfricanLion : ILion
{
  public string Roar()
  {
    return "Roaaar";
  }
}

class Hunter
{
  public void Hunt(ILion lion)
  {
    Console.WriteLine("The hunter is hunting...");
    Console.WriteLine(lion.Roar());
  }
}

// This needs to be added to the game
class WildDog
{
  public string Bark()
  {
    return "Woof";
  }
}

// Adapter around wild dog to make it compatible with our game
class WildDogAdapter : ILion
{
  private WildDog mDog;
  public WildDogAdapter(WildDog dog)
  {
    this.mDog = dog;
  }
  public string Roar()
  {
    return mDog.Bark();
  }
}

// ----------------------------

var africanLion = new AfricanLion();
var wildDog = new WildDog();
var wildDogAdapter = new WildDogAdapter(wildDog);

var hunter = new Hunter();
hunter.Hunt(africanLion);      // The hunter is hunting... -> Roaaar
hunter.Hunt(wildDogAdapter);   // The hunter is hunting... -> Woof

// Output:
// The hunter is hunting...
// Roaaar
// The hunter is hunting...
// Woof

interface Lion {
    public function roar(): string;
}

class AfricanLion implements Lion {
    public function roar(): string {
        return "Roaaar";
    }
}

class Hunter {
    public function hunt(Lion $lion): void {
        echo "The hunter is hunting...\n";
        echo $lion->roar() . "\n";
    }
}

class WildDog {
    public function bark(): string {
        return "Woof";
    }
}

// Adapter around wild dog to make it compatible with our game
class WildDogAdapter implements Lion
{
    private $mDog;
    public function __construct(WildDog $dog)
    {
        $this->mDog = $dog;
    }
    public function roar(): string
    {
        return $this->mDog->bark();
    }
}

$africanLion = new AfricanLion();
$wildDog = new WildDog();
$wildDogAdapter = new WildDogAdapter($wildDog);

$hunter = new Hunter();
$hunter->hunt($africanLion);      // The hunter is hunting... -> Roaaar
$hunter->hunt($wildDogAdapter);   // The hunter is hunting... -> Woof

// Output:
// The hunter is hunting...
// Roaaar
// The hunter is hunting...
// Woof

package main

import "fmt"

type Lion interface {
	Roar() string
}

type AfricanLion struct{}

func (a AfricanLion) Roar() string {
	return "Roaaar"
}

type Hunter struct{}

func (h Hunter) Hunt(lion Lion) {
	fmt.Println("The hunter is hunting...")
	fmt.Println(lion.Roar())
}

type WildDog struct{}

func (w WildDog) Bark() string {
	return "Woof"
}

type WildDogAdapter struct {
	dog WildDog
}

func (w WildDogAdapter) Roar() string {
	return w.dog.Bark()
}

func main() {
	africanLion := AfricanLion{}
	wildDog := WildDog{}
	wildDogAdapter := WildDogAdapter{dog: wildDog}

	hunter := Hunter{}
	hunter.Hunt(africanLion)    // The hunter is hunting... -> Roaaar
	hunter.Hunt(wildDogAdapter) // The hunter is hunting... -> Woof
}

// Output:
// The hunter is hunting...
// Roaaar
// The hunter is hunting...
// Woof

interface Lion {

    String roar();
}

class AfricanLion implements Lion {

    @Override
    public String roar() {
        return "Roaaar";
    }
}

class Hunter {

    public void hunt(Lion lion) {
        System.out.println("The hunter is hunting...");
        System.out.println(lion.roar());
    }
}

class WildDog {

    public String bark() {
        return "Woof";
    }
}

// Adapter around wild dog to make it compatible
class WildDogAdapter implements Lion {
    private WildDog wildDog;

    public WildDogAdapter(WildDog wildDog) {
        this.wildDog = wildDog;
    }

    @Override
    public String roar() {
        return wildDog.bark();
    }
}

// ----------------------------

AfricanLion africanLion = new AfricanLion();
WildDog wildDog = new WildDog();
WildDogAdapter wildDogAdapter = new WildDogAdapter(wildDog);

Hunter hunter = new Hunter();
hunter.hunt(africanLion);      // The hunter is hunting... -> Roaaar
hunter.hunt(wildDogAdapter);   // The hunter is hunting... -> Woof

// Output:
// The hunter is hunting...
// Roaaar
// The hunter is hunting...
// Woof

#include <iostream>
#include <string>

// Lion interface
class Lion {
public:
    virtual ~Lion() = default;
    virtual std::string roar() = 0;
};

// African lion
class AfricanLion : public Lion {
public:
    std::string roar() override {
        return "Roaaar";
    }
};

// Hunter
class Hunter {
public:
    void hunt(Lion* lion) {
        std::cout << "The hunter is hunting..." << std::endl;
        std::cout << lion->roar() << std::endl;
    }
};

// Wild dog (incompatible interface)
class WildDog {
public:
    std::string bark() {
        return "Woof";
    }
};

// Adapter to make WildDog compatible with the Lion interface
class WildDogAdapter : public Lion {
private:
    WildDog* dog;

public:
    WildDogAdapter(WildDog* dog) : dog(dog) {}

    std::string roar() override {
        return dog->bark();
    }
};

// Usage
int main() {
    AfricanLion africanLion;
    WildDog wildDog;
    WildDogAdapter wildDogAdapter(&wildDog);

    Hunter hunter;
    hunter.hunt(&africanLion);      // The hunter is hunting... -> Roaaar
    hunter.hunt(&wildDogAdapter);   // The hunter is hunting... -> Woof

    return 0;
}

// Output:
// The hunter is hunting...
// Roaaar
// The hunter is hunting...
// Woof

interface Lion {
    fun roar(): String
}

class AfricanLion : Lion {
    override fun roar(): String {
        return "Roaaar"
    }
}

class Hunter {
    fun hunt(lion: Lion) {
        println("The hunter is hunting...")
        println(lion.roar())
    }
}

class WildDog {
    fun bark(): String {
        return "Woof"
    }
}

// Adapter around wild dog to make it compatible
class WildDogAdapter(private val wildDog: WildDog) : Lion {
    override fun roar(): String {
        return wildDog.bark()
    }
}

// ----------------------------

fun main() {
    val africanLion = AfricanLion()
    val wildDog = WildDog()
    val wildDogAdapter = WildDogAdapter(wildDog)

    val hunter = Hunter()
    hunter.hunt(africanLion)
    hunter.hunt(wildDogAdapter)
}

abstract class Lion {
  String roar();
}

class AfricanLion implements Lion {
  @override
  String roar() {
    return "Roaaar";
  }
}

class Hunter {
  void hunt(Lion lion) {
    print("The hunter is hunting...");
    print(lion.roar());
  }
}

class WildDog {
  String bark() {
    return "Woof";
  }
}

// Adapter around wild dog to make it compatible
class WildDogAdapter implements Lion {
  final WildDog _wildDog;

  WildDogAdapter(this._wildDog);

  @override
  String roar() {
    return _wildDog.bark();
  }
}

// ----------------------------

void main() {
  var africanLion = AfricanLion();
  var wildDog = WildDog();
  var wildDogAdapter = WildDogAdapter(wildDog);

  var hunter = Hunter();
  hunter.hunt(africanLion);
  hunter.hunt(wildDogAdapter);
}

class Theme:
    def getColor(self):
        pass


class DarkTheme(Theme):
    def getColor(self):
        return "Dark Black"


class LightTheme(Theme):
    def getColor(self):
        return "Off white"


class AquaTheme(Theme):
    def getColor(self):
        return "Light blue"


class WebPage:
    def __init__(self, theme):
        self.theme = theme

    def getContent(self):
        pass


class About(WebPage):
    def getContent(self):
        return "About page in " + self.theme.getColor()


class Careers(WebPage):
    def getContent(self):
        return "Careers page in " + self.theme.getColor()


# ----------------------------

darkTheme = DarkTheme()
aquaTheme = AquaTheme()

about = About(darkTheme)
careers = Careers(aquaTheme)

print(about.getContent())    # About page in Dark Black
print(careers.getContent())  # Careers page in Light blue

interface Theme {
    getColor(): string;
}

class DarkTheme implements Theme {
    getColor(): string {
        return "Dark Black";
    }
}

class LightTheme implements Theme {
    getColor(): string {
        return "Off white";
    }
}

class AquaTheme implements Theme {
    getColor(): string {
        return "Light blue";
    }
}

abstract class WebPage {
    protected theme: Theme;

    constructor(theme: Theme) {
        this.theme = theme;
    }

    abstract getContent(): string;
}

class About extends WebPage {
    getContent(): string {
        return "About page in " + this.theme.getColor();
    }
}

class Careers extends WebPage {
    getContent(): string {
        return "Careers page in " + this.theme.getColor();
    }
}

// ----------------------------

const darkTheme = new DarkTheme();
const aquaTheme = new AquaTheme();

const about = new About(darkTheme);
const careers = new Careers(aquaTheme);

console.log(about.getContent());    // About page in Dark Black
console.log(careers.getContent());  // Careers page in Light blue

class Theme {
    getColor() {
        return "";
    }
}

class DarkTheme extends Theme {
    getColor() {
        return "Dark Black";
    }
}

class LightTheme extends Theme {
    getColor() {
        return "Off white";
    }
}

class AquaTheme extends Theme {
    getColor() {
        return "Light blue";
    }
}

class WebPage {
    constructor(theme) {
        this._theme = theme;
    }

    getContent() {
        return "";
    }
}

class About extends WebPage {
    getContent() {
        return `About page in ${this._theme.getColor()}`;
    }
}

class Careers extends WebPage {
    getContent() {
        return `Careers page in ${this._theme.getColor()}`;
    }
}


const darkTheme = new DarkTheme();
const aquaTheme = new AquaTheme();

const about = new About(darkTheme);
const careers = new Careers(aquaTheme);

console.log(about.getContent());    // About page in Dark Black
console.log(careers.getContent());  // Careers page in Light blue

using System;


interface IWebPage
{
  string GetContent();
}

class About : IWebPage
{
  protected ITheme theme;

  public About(ITheme theme)
  {
    this.theme = theme;
  }

  public string GetContent()
  {
    return $"About page in {theme.GetColor()}";
  }
}

class Careers : IWebPage
{
  protected ITheme theme;

  public Careers(ITheme theme)
  {
    this.theme = theme;
  }

  public string GetContent()
  {
    return $"Careers page in {theme.GetColor()}";
  }
}


interface ITheme
{
  string GetColor();
}

class DarkTheme : ITheme
{
  public string GetColor()
  {
    return "Dark Black";
  }
}

class LightTheme : ITheme
{
  public string GetColor()
  {
    return "Off white";
  }
}

class AquaTheme : ITheme
{
  public string GetColor()
  {
    return "Light blue";
  }
}

// ----------------------------

var darkTheme = new DarkTheme();
var aquaTheme = new AquaTheme();

var about = new About(darkTheme);
var careers = new Careers(aquaTheme);

Console.WriteLine(about.GetContent());   // About page in Dark Black
Console.WriteLine(careers.GetContent()); // Careers page in Light blue

interface WebPageInterface {
  public function getContent();
}

class About implements WebPageInterface {
  protected $theme;

  public function __construct(ThemeInterface $theme) {
    $this->theme = $theme;
  }

  public function getContent() {
    return "About page in " . $this->theme->getColor();
  }
}

class Careers implements WebPageInterface {
  protected $theme;

  public function __construct(ThemeInterface $theme) {
    $this->theme = $theme;
  }

  public function getContent() {
    return "Careers page in " . $this->theme->getColor();
  }
}

interface ThemeInterface {
  public function getColor();
}

class DarkTheme implements ThemeInterface {
  public function getColor() {
    return "Dark Black";
  }
}

class LightTheme implements ThemeInterface {
  public function getColor() {
    return "Off white";
  }
}

class AquaTheme implements ThemeInterface {
  public function getColor() {
    return "Light blue";
  }
}

$darkTheme = new DarkTheme();
$aquaTheme = new AquaTheme();

$about = new About($darkTheme);
$careers = new Careers($aquaTheme);

echo $about->getContent() . "\n";   // About page in Dark Black
echo $careers->getContent() . "\n"; // Careers page in Light blue

package main

import "fmt"

type IWebPage interface {
GetContent() string
}

type About struct {
theme ITheme
}

func NewAbout(theme ITheme) *About {
return &About{theme: theme}
}

func (a *About) GetContent() string {
return fmt.Sprintf("About page in %s", a.theme.GetColor())
}

type Careers struct {
theme ITheme
}

func NewCareers(theme ITheme) *Careers {
return &Careers{theme: theme}
}

func (c *Careers) GetContent() string {
return fmt.Sprintf("Careers page in %s", c.theme.GetColor())
}

type ITheme interface {
GetColor() string
}

type DarkTheme struct{}

func (d *DarkTheme) GetColor() string {
return "Dark Black"
}

type LightTheme struct{}

func (l *LightTheme) GetColor() string {
return "Off white"
}

type AquaTheme struct{}

func (a *AquaTheme) GetColor() string {
return "Light blue"
}

func main() {
darkTheme := &DarkTheme{}
aquaTheme := &AquaTheme{}

about := NewAbout(darkTheme)
careers := NewCareers(aquaTheme)

fmt.Println(about.GetContent())   // About page in Dark Black
fmt.Println(careers.GetContent()) // Careers page in Light blue
}

interface WebPage {
    String getContent();
}

interface Theme {
    String getColor();
}

class About implements WebPage {
    private Theme theme;

    public About(Theme theme) {
        this.theme = theme;
    }

    public String getContent() {
        return "About page in " + theme.getColor();
    }
}

class Careers implements WebPage {
    private Theme theme;

    public Careers(Theme theme) {
        this.theme = theme;
    }

    public String getContent(){
        return "Careers page in "+ theme.getColor();
    }
}

class DarkTheme implements Theme {
    public String getColor() {
        return "Dark Black";
    }
}

class LightTheme implements Theme {
    public String getColor() {
        return "Off white";
    }
}

class AquaTheme implements Theme {
    public String getColor() {
        return "Light blue";
    }
}

// ----------------------------


DarkTheme darkTheme = new DarkTheme();
AquaTheme aquaTheme = new AquaTheme();

About about = new About(darkTheme);
Careers careers = new Careers(aquaTheme);

System.out.println(about.getContent());     // About page in Dark Black
System.out.println(careers.getContent());   // Careers page in Light blue

#include <iostream>
#include <string>
#include <memory>

// Theme interface (Implementor)
class Theme {
public:
    virtual ~Theme() = default;
    virtual std::string getColor() = 0;
};

// Dark theme implementation
class DarkTheme : public Theme {
public:
    std::string getColor() override {
        return "Dark Black";
    }
};

// Light theme implementation
class LightTheme : public Theme {
public:
    std::string getColor() override {
        return "Off white";
    }
};

// Aqua theme implementation
class AquaTheme : public Theme {
public:
    std::string getColor() override {
        return "Light blue";
    }
};

// Web page abstraction
class WebPage {
protected:
    std::unique_ptr<Theme> theme;

public:
    WebPage(std::unique_ptr<Theme> theme) : theme(std::move(theme)) {}
    virtual ~WebPage() = default;
    virtual std::string getContent() = 0;
};

// About page
class About : public WebPage {
public:
    About(std::unique_ptr<Theme> theme) : WebPage(std::move(theme)) {}
    
    std::string getContent() override {
        return "About page in " + theme->getColor();
    }
};

// Careers page
class Careers : public WebPage {
public:
    Careers(std::unique_ptr<Theme> theme) : WebPage(std::move(theme)) {}
    
    std::string getContent() override {
        return "Careers page in " + theme->getColor();
    }
};

// Usage
int main() {
    About about(std::make_unique<DarkTheme>());
    Careers careers(std::make_unique<AquaTheme>());

    std::cout << about.getContent() << std::endl;     // About page in Dark Black
    std::cout << careers.getContent() << std::endl;   // Careers page in Light blue

    return 0;
}

interface Theme {
    fun getColor(): String
}

interface WebPage {
    fun getContent(): String
}

class DarkTheme : Theme {
    override fun getColor() = "Dark Black"
}

class LightTheme : Theme {
    override fun getColor() = "Off white"
}

class AquaTheme : Theme {
    override fun getColor() = "Light blue"
}

class About(private val theme: Theme) : WebPage {
    override fun getContent() = "About page in " + theme.getColor()
}

class Careers(private val theme: Theme) : WebPage {
    override fun getContent() = "Careers page in " + theme.getColor()
}

// ----------------------------

fun main() {
    val darkTheme = DarkTheme()
    val aquaTheme = AquaTheme()

    val about = About(darkTheme)
    val careers = Careers(aquaTheme)

    println(about.getContent())
    println(careers.getContent())
}

abstract class Theme {
  String getColor();
}

abstract class WebPage {
  final Theme theme;

  WebPage(this.theme);

  String getContent();
}

class DarkTheme implements Theme {
  @override
  String getColor() => "Dark Black";
}

class LightTheme implements Theme {
  @override
  String getColor() => "Off white";
}

class AquaTheme implements Theme {
  @override
  String getColor() => "Light blue";
}

class About extends WebPage {
  About(Theme theme) : super(theme);

  @override
  String getContent() => "About page in " + theme.getColor();
}

class Careers extends WebPage {
  Careers(Theme theme) : super(theme);

  @override
  String getContent() => "Careers page in " + theme.getColor();
}

// ----------------------------

void main() {
  var darkTheme = DarkTheme();
  var aquaTheme = AquaTheme();

  var about = About(darkTheme);
  var careers = Careers(aquaTheme);

  print(about.getContent());
  print(careers.getContent());
}

from abc import ABC, abstractmethod
from typing import List


class Employee(ABC):
    @abstractmethod
    def get_name(self) -> str: ...

    @abstractmethod
    def get_salary(self) -> float: ...


class Developer(Employee):
    def __init__(self, name: str, salary: float) -> None:
        self._name = name
        self._salary = salary

    def get_name(self) -> str:
        return self._name

    def get_salary(self) -> float:
        return self._salary


class Designer(Employee):
    def __init__(self, name: str, salary: float) -> None:
        self._name = name
        self._salary = salary

    def get_name(self) -> str:
        return self._name

    def get_salary(self) -> float:
        return self._salary


# Organization is itself an Employee (the Composite); it can hold sub-members
class Organization(Employee):
    def __init__(self, name: str) -> None:
        self._name = name
        self._members: List[Employee] = []

    def add(self, employee: Employee) -> None:
        self._members.append(employee)

    def get_name(self) -> str:
        return self._name

    def get_salary(self) -> float:
        total = 0.0
        for member in self._members:
            total += member.get_salary()  # recurses into sub-organizations
        return total


# ----------------------------

design_team = Organization("Design Team")
design_team.add(Designer("Arya", 4000))

company = Organization("Acme")
company.add(Developer("John", 5000))
company.add(Developer("Jane", 6000))
company.add(design_team)

print(f"Total salary: {company.get_salary():g}")
# Total salary: 15000

interface Employee {
    getName(): string;

    getSalary(): number;
}

class Developer implements Employee {
    constructor(private name: string, private salary: number) {
    }

    getName(): string {
        return this.name;
    }

    getSalary(): number {
        return this.salary;
    }
}

class Designer implements Employee {
    constructor(private name: string, private salary: number) {
    }

    getName(): string {
        return this.name;
    }

    getSalary(): number {
        return this.salary;
    }
}

// Organization is itself an Employee (the Composite); it can hold sub-members
class Organization implements Employee {
    private members: Employee[] = [];

    constructor(private name: string) {
    }

    add(employee: Employee): void {
        this.members.push(employee);
    }

    getName(): string {
        return this.name;
    }

    getSalary(): number {
        let total = 0;
        for (const member of this.members) {
            total += member.getSalary(); // recurses into sub-organizations
        }
        return total;
    }
}

// ----------------------------

const designTeam = new Organization("Design Team");
designTeam.add(new Designer("Arya", 4000));

const company = new Organization("Acme");
company.add(new Developer("John", 5000));
company.add(new Developer("Jane", 6000));
company.add(designTeam);

console.log(`Total salary: ${company.getSalary()}`);
// Total salary: 15000

class Developer {
    constructor(name, salary) {
        this.name = name;
        this.salary = salary;
    }

    getName() {
        return this.name;
    }

    getSalary() {
        return this.salary;
    }
}

class Designer {
    constructor(name, salary) {
        this.name = name;
        this.salary = salary;
    }

    getName() {
        return this.name;
    }

    getSalary() {
        return this.salary;
    }
}

// Organization is itself an Employee (the Composite); it can hold sub-members
class Organization {
    constructor(name) {
        this.name = name;
        this.members = [];
    }

    add(employee) {
        this.members.push(employee);
    }

    getName() {
        return this.name;
    }

    getSalary() {
        let total = 0;
        for (const member of this.members) {
            total += member.getSalary(); // recurses into sub-organizations
        }
        return total;
    }
}

// ----------------------------

const designTeam = new Organization("Design Team");
designTeam.add(new Designer("Arya", 4000));

const company = new Organization("Acme");
company.add(new Developer("John", 5000));
company.add(new Developer("Jane", 6000));
company.add(designTeam);

console.log(`Total salary: ${company.getSalary()}`);
// Total salary: 15000

using System;
using System.Collections.Generic;

interface IEmployee
{
  string GetName();
  float GetSalary();
}

class Developer : IEmployee
{
  private string mName;
  private float mSalary;

  public Developer(string name, float salary)
  {
    this.mName = name;
    this.mSalary = salary;
  }

  public string GetName()
  {
    return this.mName;
  }

  public float GetSalary()
  {
    return this.mSalary;
  }
}

class Designer : IEmployee
{
  private string mName;
  private float mSalary;

  public Designer(string name, float salary)
  {
    this.mName = name;
    this.mSalary = salary;
  }

  public string GetName()
  {
    return this.mName;
  }

  public float GetSalary()
  {
    return this.mSalary;
  }
}

// Organization is itself an IEmployee (the Composite); it can hold sub-members
class Organization : IEmployee
{
  private string mName;
  private List<IEmployee> mMembers = new List<IEmployee>();

  public Organization(string name)
  {
    this.mName = name;
  }

  public void Add(IEmployee employee)
  {
    mMembers.Add(employee);
  }

  public string GetName()
  {
    return this.mName;
  }

  public float GetSalary()
  {
    float total = 0;
    foreach (var member in mMembers)
    {
      total += member.GetSalary(); // recurses into sub-organizations
    }
    return total;
  }
}

// ----------------------------

var designTeam = new Organization("Design Team");
designTeam.Add(new Designer("Arya", 4000));

var company = new Organization("Acme");
company.Add(new Developer("John", 5000));
company.Add(new Developer("Jane", 6000));
company.Add(designTeam);

Console.WriteLine($"Total salary: {company.GetSalary()}");
// Total salary: 15000

interface EmployeeInterface {
  function getName(): string;
  function getSalary(): float;
}

class Developer implements EmployeeInterface {
  private string $name;
  private float $salary;

  public function __construct(string $name, float $salary) {
    $this->name = $name;
    $this->salary = $salary;
  }

  public function getName(): string {
    return $this->name;
  }

  public function getSalary(): float {
    return $this->salary;
  }
}

class Designer implements EmployeeInterface {
  private string $name;
  private float $salary;

  public function __construct(string $name, float $salary) {
    $this->name = $name;
    $this->salary = $salary;
  }

  public function getName(): string {
    return $this->name;
  }

  public function getSalary(): float {
    return $this->salary;
  }
}

// Organization is itself an EmployeeInterface (the Composite); it can hold sub-members
class Organization implements EmployeeInterface {
  private string $name;
  private array $members = array();

  public function __construct(string $name) {
    $this->name = $name;
  }

  public function add(EmployeeInterface $employee): void {
    $this->members[] = $employee;
  }

  public function getName(): string {
    return $this->name;
  }

  public function getSalary(): float {
    $total = 0;
    foreach ($this->members as $member) {
      $total += $member->getSalary(); // recurses into sub-organizations
    }
    return $total;
  }
}

// ----------------------------

$designTeam = new Organization("Design Team");
$designTeam->add(new Designer("Arya", 4000));

$company = new Organization("Acme");
$company->add(new Developer("John", 5000));
$company->add(new Developer("Jane", 6000));
$company->add($designTeam);

echo "Total salary: " . $company->getSalary() . PHP_EOL;
// Total salary: 15000

package main

import "fmt"

type Employee interface {
    GetName() string
    GetSalary() float64
}

type Developer struct {
    Name   string
    Salary float64
}

func (d *Developer) GetName() string {
    return d.Name
}

func (d *Developer) GetSalary() float64 {
    return d.Salary
}

type Designer struct {
    Name   string
    Salary float64
}

func (d *Designer) GetName() string {
    return d.Name
}

func (d *Designer) GetSalary() float64 {
    return d.Salary
}

// Organization is itself an Employee (the Composite); it can hold sub-members
type Organization struct {
    Name    string
    members []Employee
}

func (o *Organization) Add(employee Employee) {
    o.members = append(o.members, employee)
}

func (o *Organization) GetName() string {
    return o.Name
}

func (o *Organization) GetSalary() float64 {
    total := float64(0)
    for _, member := range o.members {
        total += member.GetSalary() // recurses into sub-organizations
    }
    return total
}

func main() {
    designTeam := &Organization{Name: "Design Team"}
    designTeam.Add(&Designer{Name: "Arya", Salary: 4000})

    company := &Organization{Name: "Acme"}
    company.Add(&Developer{Name: "John", Salary: 5000})
    company.Add(&Developer{Name: "Jane", Salary: 6000})
    company.Add(designTeam)

    fmt.Printf("Total salary: %g\n", company.GetSalary())
    // Total salary: 15000
}

import java.util.*;

interface Employee {

    String getName();
    float getSalary();
}

class Developer implements Employee {
    private String name;
    private float salary;

    public Developer(String name, float salary) {
        this.name = name;
        this.salary = salary;
    }

    public String getName() {
        return this.name;
    }
    public float getSalary() {
        return this.salary;
    }
}

class Designer implements Employee {
    private String name;
    private float salary;

    public Designer(String name, float salary) {
        this.name = name;
        this.salary = salary;
    }

    public String getName() {
        return this.name;
    }
    public float getSalary() {
        return this.salary;
    }
}

// Organization is itself an Employee (the Composite); it can hold sub-members
class Organization implements Employee {
    private String name;
    private List<Employee> members = new ArrayList<>();

    public Organization(String name) {
        this.name = name;
    }

    public void add(Employee employee) {
        members.add(employee);
    }

    public String getName() {
        return this.name;
    }

    public float getSalary() {
        float total = 0;
        for (Employee member : members) {
            total += member.getSalary(); // recurses into sub-organizations
        }
        return total;
    }
}

// ----------------------------

Organization designTeam = new Organization("Design Team");
designTeam.add(new Designer("Arya", 4000));

Organization company = new Organization("Acme");
company.add(new Developer("John", 5000));
company.add(new Developer("Jane", 6000));
company.add(designTeam);

System.out.printf("Total salary: %.0f%n", company.getSalary());
// Total salary: 15000

#include <iostream>
#include <string>
#include <vector>
#include <memory>

// Employee interface
class Employee {
public:
    virtual ~Employee() = default;
    virtual std::string getName() const = 0;
    virtual double getSalary() const = 0;
};

// Developer leaf
class Developer : public Employee {
private:
    std::string name;
    double salary;

public:
    Developer(const std::string& name, double salary) : name(name), salary(salary) {}

    std::string getName() const override {
        return name;
    }

    double getSalary() const override {
        return salary;
    }
};

// Designer leaf
class Designer : public Employee {
private:
    std::string name;
    double salary;

public:
    Designer(const std::string& name, double salary) : name(name), salary(salary) {}

    std::string getName() const override {
        return name;
    }

    double getSalary() const override {
        return salary;
    }
};

// Organization is itself an Employee (the Composite); it can hold sub-members
class Organization : public Employee {
private:
    std::string name;
    std::vector<std::shared_ptr<Employee>> members;

public:
    explicit Organization(const std::string& name) : name(name) {}

    void add(std::shared_ptr<Employee> employee) {
        members.push_back(std::move(employee));
    }

    std::string getName() const override {
        return name;
    }

    double getSalary() const override {
        double total = 0.0;
        for (const auto& member : members) {
            total += member->getSalary(); // recurses into sub-organizations
        }
        return total;
    }
};

// Usage
int main() {
    auto designTeam = std::make_shared<Organization>("Design Team");
    designTeam->add(std::make_shared<Designer>("Arya", 4000));

    auto company = std::make_shared<Organization>("Acme");
    company->add(std::make_shared<Developer>("John", 5000));
    company->add(std::make_shared<Developer>("Jane", 6000));
    company->add(designTeam);

    std::cout << "Total salary: " << company->getSalary() << std::endl;
    // Total salary: 15000

    return 0;
}

interface Employee {
    fun getName(): String
    fun getSalary(): Double
}

class Developer(private val name: String, private val salary: Double) : Employee {
    override fun getName() = name
    override fun getSalary() = salary
}

class Designer(private val name: String, private val salary: Double) : Employee {
    override fun getName() = name
    override fun getSalary() = salary
}

// Organization is itself an Employee (the Composite); it can hold sub-members
class Organization(private val name: String) : Employee {
    private val members = mutableListOf<Employee>()

    fun add(employee: Employee) {
        members.add(employee)
    }

    override fun getName() = name

    override fun getSalary(): Double {
        var total = 0.0
        for (member in members) {
            total += member.getSalary() // recurses into sub-organizations
        }
        return total
    }
}

// ----------------------------

fun main() {
    val designTeam = Organization("Design Team")
    designTeam.add(Designer("Arya", 4000.0))

    val company = Organization("Acme")
    company.add(Developer("John", 5000.0))
    company.add(Developer("Jane", 6000.0))
    company.add(designTeam)

    println("Total salary: ${company.getSalary().toInt()}")
}

abstract class Employee {
  String getName();
  double getSalary();
}

class Developer implements Employee {
  final String _name;
  final double _salary;

  Developer(this._name, this._salary);

  @override
  String getName() => _name;

  @override
  double getSalary() => _salary;
}

class Designer implements Employee {
  final String _name;
  final double _salary;

  Designer(this._name, this._salary);

  @override
  String getName() => _name;

  @override
  double getSalary() => _salary;
}

// Organization is itself an Employee (the Composite); it can hold sub-members
class Organization implements Employee {
  final String _name;
  final List<Employee> _members = [];

  Organization(this._name);

  void add(Employee employee) {
    _members.add(employee);
  }

  @override
  String getName() => _name;

  @override
  double getSalary() {
    double total = 0;
    for (var member in _members) {
      total += member.getSalary(); // recurses into sub-organizations
    }
    return total;
  }
}

// ----------------------------

void main() {
  var designTeam = Organization("Design Team");
  designTeam.add(Designer("Arya", 4000));

  var company = Organization("Acme");
  company.add(Developer("John", 5000));
  company.add(Developer("Jane", 6000));
  company.add(designTeam);

  print("Total salary: ${company.getSalary().toInt()}");
}

class Coffee:
    def cost(self):
        pass

    def description(self):
        pass


class SimpleCoffee(Coffee):
    def cost(self):
        return 10

    def description(self):
        return 'Simple coffee'


class MilkDecorator(Coffee):
    def __init__(self, coffee):
        self._coffee = coffee

    def cost(self):
        return self._coffee.cost() + 2

    def description(self):
        return self._coffee.description() + ', milk'


class SugarDecorator(Coffee):
    def __init__(self, coffee):
        self._coffee = coffee

    def cost(self):
        return self._coffee.cost() + 1

    def description(self):
        return self._coffee.description() + ', sugar'


# ----------------------------

coffee = SimpleCoffee()
print(f"{coffee.description()}: {coffee.cost()}")  # Simple coffee: 10

coffee = MilkDecorator(coffee)
print(f"{coffee.description()}: {coffee.cost()}")  # Simple coffee, milk: 12

coffee = SugarDecorator(coffee)
print(f"{coffee.description()}: {coffee.cost()}")  # Simple coffee, milk, sugar: 13

interface Coffee {
    cost(): number;
    description(): string;
}

class SimpleCoffee implements Coffee {
    cost(): number {
        return 10;
    }

    description(): string {
        return "Simple coffee";
    }
}

class MilkDecorator implements Coffee {
    private coffee: Coffee;

    constructor(coffee: Coffee) {
        this.coffee = coffee;
    }

    cost(): number {
        return this.coffee.cost() + 2;
    }

    description(): string {
        return this.coffee.description() + ", milk";
    }
}

class SugarDecorator implements Coffee {
    private coffee: Coffee;

    constructor(coffee: Coffee) {
        this.coffee = coffee;
    }

    cost(): number {
        return this.coffee.cost() + 1;
    }

    description(): string {
        return this.coffee.description() + ", sugar";
    }
}

// ----------------------------

let coffee: Coffee = new SimpleCoffee();
console.log(`${coffee.description()}: ${coffee.cost()}`); // Simple coffee: 10

coffee = new MilkDecorator(coffee);
console.log(`${coffee.description()}: ${coffee.cost()}`); // Simple coffee, milk: 12

coffee = new SugarDecorator(coffee);
console.log(`${coffee.description()}: ${coffee.cost()}`); // Simple coffee, milk, sugar: 13

class Coffee {
    cost() {
        throw new Error("cost() must be implemented by subclasses");
    }

    description() {
        throw new Error("description() must be implemented by subclasses");
    }
}

class SimpleCoffee extends Coffee {
    cost() {
        return 10;
    }

    description() {
        return "Simple coffee";
    }
}

class MilkDecorator extends Coffee {
    constructor(coffee) {
        super();
        this.coffee = coffee;
    }

    cost() {
        return this.coffee.cost() + 2;
    }

    description() {
        return this.coffee.description() + ", milk";
    }
}

class SugarDecorator extends Coffee {
    constructor(coffee) {
        super();
        this.coffee = coffee;
    }

    cost() {
        return this.coffee.cost() + 1;
    }

    description() {
        return this.coffee.description() + ", sugar";
    }
}


let coffee = new SimpleCoffee();
console.log(`${coffee.description()}: ${coffee.cost()}`); // Simple coffee: 10

coffee = new MilkDecorator(coffee);
console.log(`${coffee.description()}: ${coffee.cost()}`); // Simple coffee, milk: 12

coffee = new SugarDecorator(coffee);
console.log(`${coffee.description()}: ${coffee.cost()}`); // Simple coffee, milk, sugar: 13

using System;


interface ICoffee
{
  int Cost();
  string Description();
}

class SimpleCoffee : ICoffee
{
  public int Cost()
  {
    return 10;
  }

  public string Description()
  {
    return "Simple coffee";
  }
}

class MilkDecorator : ICoffee
{
  private readonly ICoffee mCoffee;

  public MilkDecorator(ICoffee coffee)
  {
    mCoffee = coffee ?? throw new ArgumentNullException("coffee", "coffee should not be null");
  }

  public int Cost()
  {
    return mCoffee.Cost() + 2;
  }

  public string Description()
  {
    return String.Concat(mCoffee.Description(), ", milk");
  }
}

class SugarDecorator : ICoffee
{
  private readonly ICoffee mCoffee;

  public SugarDecorator(ICoffee coffee)
  {
    mCoffee = coffee ?? throw new ArgumentNullException("coffee", "coffee should not be null");
  }

  public int Cost()
  {
    return mCoffee.Cost() + 1;
  }

  public string Description()
  {
    return String.Concat(mCoffee.Description(), ", sugar");
  }
}


// ----------------------------

ICoffee coffee = new SimpleCoffee();
Console.WriteLine($"{coffee.Description()}: {coffee.Cost()}"); // Simple coffee: 10

coffee = new MilkDecorator(coffee);
Console.WriteLine($"{coffee.Description()}: {coffee.Cost()}"); // Simple coffee, milk: 12

coffee = new SugarDecorator(coffee);
Console.WriteLine($"{coffee.Description()}: {coffee.Cost()}"); // Simple coffee, milk, sugar: 13

interface CoffeeInterface {
  public function cost();
  public function description();
}

class SimpleCoffee implements CoffeeInterface {
  public function cost() {
    return 10;
  }

  public function description() {
    return "Simple coffee";
  }
}

class MilkDecorator implements CoffeeInterface {
  private $coffee;

  public function __construct(CoffeeInterface $coffee) {
    $this->coffee = $coffee ?? throw new Exception("coffee should not be null");
  }

  public function cost() {
    return $this->coffee->cost() + 2;
  }

  public function description() {
    return $this->coffee->description() . ", milk";
  }
}

class SugarDecorator implements CoffeeInterface {
  private $coffee;

  public function __construct(CoffeeInterface $coffee) {
    $this->coffee = $coffee ?? throw new Exception("coffee should not be null");
  }

  public function cost() {
    return $this->coffee->cost() + 1;
  }

  public function description() {
    return $this->coffee->description() . ", sugar";
  }
}

$coffee = new SimpleCoffee();
echo $coffee->description() . ": " . $coffee->cost() . "\n"; // Simple coffee: 10

$coffee = new MilkDecorator($coffee);
echo $coffee->description() . ": " . $coffee->cost() . "\n"; // Simple coffee, milk: 12

$coffee = new SugarDecorator($coffee);
echo $coffee->description() . ": " . $coffee->cost() . "\n"; // Simple coffee, milk, sugar: 13

package main

import (
	"fmt"
)

type Coffee interface {
	Cost() int
	Description() string
}

type SimpleCoffee struct{}

func (c *SimpleCoffee) Cost() int {
	return 10
}

func (c *SimpleCoffee) Description() string {
	return "Simple coffee"
}

type MilkDecorator struct {
	coffee Coffee
}

func NewMilkDecorator(coffee Coffee) *MilkDecorator {
	if coffee == nil {
		panic("coffee should not be nil")
	}
	return &MilkDecorator{coffee: coffee}
}

func (c *MilkDecorator) Cost() int {
	return c.coffee.Cost() + 2
}

func (c *MilkDecorator) Description() string {
	return fmt.Sprintf("%s, milk", c.coffee.Description())
}

type SugarDecorator struct {
	coffee Coffee
}

func NewSugarDecorator(coffee Coffee) *SugarDecorator {
	if coffee == nil {
		panic("coffee should not be nil")
	}
	return &SugarDecorator{coffee: coffee}
}

func (c *SugarDecorator) Cost() int {
	return c.coffee.Cost() + 1
}

func (c *SugarDecorator) Description() string {
	return fmt.Sprintf("%s, sugar", c.coffee.Description())
}

func main() {
	var coffee Coffee = &SimpleCoffee{}
	fmt.Printf("%s: %d\n", coffee.Description(), coffee.Cost()) // Simple coffee: 10

	coffee = NewMilkDecorator(coffee)
	fmt.Printf("%s: %d\n", coffee.Description(), coffee.Cost()) // Simple coffee, milk: 12

	coffee = NewSugarDecorator(coffee)
	fmt.Printf("%s: %d\n", coffee.Description(), coffee.Cost()) // Simple coffee, milk, sugar: 13
}

interface Coffee {

    int cost();
    String description();
}

class SimpleCoffee implements Coffee {

    public int cost() {
        return 10;
    }

    public String description() {
        return "Simple coffee";
    }
}

class MilkDecorator implements Coffee {
    private final Coffee coffee;

    public MilkDecorator(Coffee coffee) {
        if(coffee == null)
            throw new IllegalArgumentException("coffee should not be null");
        this.coffee = coffee;
    }

    public int cost() {
        return coffee.cost() + 2;
    }

    public String description() {
        return coffee.description() + ", milk";
    }
}

class SugarDecorator implements Coffee {
    private final Coffee coffee;

    public SugarDecorator(Coffee coffee) {
        if(coffee == null)
            throw new IllegalArgumentException("coffee should not be null");
        this.coffee = coffee;
    }

    public int cost() {
        return coffee.cost() + 1;
    }

    public String description() {
        return coffee.description() + ", sugar";
    }
}

// ----------------------------

Coffee coffee = new SimpleCoffee();
System.out.println(coffee.description() + ": " + coffee.cost()); // Simple coffee: 10

coffee = new MilkDecorator(coffee);
System.out.println(coffee.description() + ": " + coffee.cost()); // Simple coffee, milk: 12

coffee = new SugarDecorator(coffee);
System.out.println(coffee.description() + ": " + coffee.cost()); // Simple coffee, milk, sugar: 13

#include <iostream>
#include <string>
#include <memory>

// Coffee interface
class Coffee {
public:
    virtual ~Coffee() = default;
    virtual int cost() const = 0;
    virtual std::string description() const = 0;
};

// Simple coffee
class SimpleCoffee : public Coffee {
public:
    int cost() const override {
        return 10;
    }

    std::string description() const override {
        return "Simple coffee";
    }
};

// Milk decorator
class MilkDecorator : public Coffee {
    std::unique_ptr<Coffee> coffee;

public:
    MilkDecorator(std::unique_ptr<Coffee> coffee) : coffee(std::move(coffee)) {}

    int cost() const override {
        return coffee->cost() + 2;
    }

    std::string description() const override {
        return coffee->description() + ", milk";
    }
};

// Sugar decorator
class SugarDecorator : public Coffee {
    std::unique_ptr<Coffee> coffee;

public:
    SugarDecorator(std::unique_ptr<Coffee> coffee) : coffee(std::move(coffee)) {}

    int cost() const override {
        return coffee->cost() + 1;
    }

    std::string description() const override {
        return coffee->description() + ", sugar";
    }
};

// Usage
int main() {
    std::unique_ptr<Coffee> coffee = std::make_unique<SimpleCoffee>();
    std::cout << coffee->description() << ": " << coffee->cost() << std::endl; // Simple coffee: 10

    coffee = std::make_unique<MilkDecorator>(std::move(coffee));
    std::cout << coffee->description() << ": " << coffee->cost() << std::endl; // Simple coffee, milk: 12

    coffee = std::make_unique<SugarDecorator>(std::move(coffee));
    std::cout << coffee->description() << ": " << coffee->cost() << std::endl; // Simple coffee, milk, sugar: 13

    return 0;
}

interface Coffee {
    fun cost(): Int
    fun description(): String
}

class SimpleCoffee : Coffee {
    override fun cost() = 10
    override fun description() = "Simple coffee"
}

class MilkDecorator(private val coffee: Coffee) : Coffee {
    override fun cost() = coffee.cost() + 2
    override fun description() = coffee.description() + ", milk"
}

class SugarDecorator(private val coffee: Coffee) : Coffee {
    override fun cost() = coffee.cost() + 1
    override fun description() = coffee.description() + ", sugar"
}

// ----------------------------

fun main() {
    var coffee: Coffee = SimpleCoffee()
    println("${coffee.description()}: ${coffee.cost()}")

    coffee = MilkDecorator(coffee)
    println("${coffee.description()}: ${coffee.cost()}")

    coffee = SugarDecorator(coffee)
    println("${coffee.description()}: ${coffee.cost()}")
}

abstract class Coffee {
  int cost();
  String description();
}

class SimpleCoffee implements Coffee {
  @override
  int cost() => 10;

  @override
  String description() => "Simple coffee";
}

class MilkDecorator implements Coffee {
  final Coffee _coffee;

  MilkDecorator(this._coffee);

  @override
  int cost() => _coffee.cost() + 2;

  @override
  String description() => _coffee.description() + ", milk";
}

class SugarDecorator implements Coffee {
  final Coffee _coffee;

  SugarDecorator(this._coffee);

  @override
  int cost() => _coffee.cost() + 1;

  @override
  String description() => _coffee.description() + ", sugar";
}

// ----------------------------

void main() {
  Coffee coffee = SimpleCoffee();
  print("${coffee.description()}: ${coffee.cost()}");

  coffee = MilkDecorator(coffee);
  print("${coffee.description()}: ${coffee.cost()}");

  coffee = SugarDecorator(coffee);
  print("${coffee.description()}: ${coffee.cost()}");
}

class Computer:
    def getElectricShock(self):
        print("Ouch!")

    def makeSound(self):
        print("Beep beep!")

    def showLoadingScreen(self):
        print("Loading..")

    def bam(self):
        print("Ready to be used!")

    def closeEverything(self):
        print("Bup bup..")

    def pullCurrent(self):
        print("Haaah!")

    def sooth(self):
        print("Zzzzz")


class ComputerFacade:
    def __init__(self, computer):
        self.computer = computer

    def turnOn(self):
        self.computer.getElectricShock()
        self.computer.makeSound()
        self.computer.showLoadingScreen()
        self.computer.bam()

    def turnOff(self):
        self.computer.closeEverything()
        self.computer.pullCurrent()
        self.computer.sooth()


# ----------------------------

computer = ComputerFacade(Computer())
computer.turnOn()
computer.turnOff()

'''
Output:
Ouch!
Beep beep!
Loading..
Ready to be used!
Bup bup..
Haaah!
Zzzzz
'''

class Computer {
    getElectricShock() {
        console.log("Ouch!");
    }

    makeSound() {
        console.log("Beep beep!");
    }

    showLoadingScreen() {
        console.log("Loading..");
    }

    bam() {
        console.log("Ready to be used!");
    }

    closeEverything() {
        console.log("Bup bup..");
    }

    pullCurrent() {
        console.log("Haaah!");
    }

    sooth() {
        console.log("Zzzzz");
    }
}

class ComputerFacade {
    private computer: Computer;

    constructor(computer: Computer) {
        this.computer = computer;
    }

    turnOn() {
        this.computer.getElectricShock();
        this.computer.makeSound();
        this.computer.showLoadingScreen();
        this.computer.bam();
    }

    turnOff() {
        this.computer.closeEverything();
        this.computer.pullCurrent();
        this.computer.sooth();
    }
}

// ----------------------------

const computer = new ComputerFacade(new Computer());
computer.turnOn();
computer.turnOff();

// Output:
// Ouch!
// Beep beep!
// Loading..
// Ready to be used!
// Bup bup..
// Haaah!
// Zzzzz

class Computer {
    getElectricShock() {
        console.log("Ouch!");
    }

    makeSound() {
        console.log("Beep beep!");
    }

    showLoadingScreen() {
        console.log("Loading..");
    }

    bam() {
        console.log("Ready to be used!");
    }

    closeEverything() {
        console.log("Bup bup..");
    }

    pullCurrent() {
        console.log("Haaah!");
    }

    sooth() {
        console.log("Zzzzz");
    }
}

class ComputerFacade {
    constructor(computer) {
        this.computer = computer;
    }

    turnOn() {
        this.computer.getElectricShock();
        this.computer.makeSound();
        this.computer.showLoadingScreen();
        this.computer.bam();
    }

    turnOff() {
        this.computer.closeEverything();
        this.computer.pullCurrent();
        this.computer.sooth();
    }
}

const computer = new ComputerFacade(new Computer());
computer.turnOn();
computer.turnOff();

// Output:
// Ouch!
// Beep beep!
// Loading..
// Ready to be used!
// Bup bup..
// Haaah!
// Zzzzz

using System;


class Computer
{
  public void GetElectricShock()
  {
    Console.WriteLine("Ouch!");
  }

  public void MakeSound()
  {
    Console.WriteLine("Beep beep!");
  }

  public void ShowLoadingScreen()
  {
    Console.WriteLine("Loading..");
  }

  public void Bam()
  {
    Console.WriteLine("Ready to be used!");
  }

  public void CloseEverything()
  {
    Console.WriteLine("Bup bup..");
  }

  public void PullCurrent()
  {
    Console.WriteLine("Haaah!");
  }

  public void Sooth()
  {
    Console.WriteLine("Zzzzz");
  }
}


class ComputerFacade
{
  private readonly Computer mComputer;

  public ComputerFacade(Computer computer)
  {
    this.mComputer = computer ?? throw new ArgumentNullException("computer", "computer cannot be null");
  }

  public void TurnOn()
  {
    mComputer.GetElectricShock();
    mComputer.MakeSound();
    mComputer.ShowLoadingScreen();
    mComputer.Bam();
  }

  public void TurnOff()
  {
    mComputer.CloseEverything();
    mComputer.PullCurrent();
    mComputer.Sooth();
  }
}

// ----------------------------

var computer = new ComputerFacade(new Computer());
computer.TurnOn();
computer.TurnOff();

// Output:
// Ouch!
// Beep beep!
// Loading..
// Ready to be used!
// Bup bup..
// Haaah!
// Zzzzz

class Computer
{
  public function getElectricShock()
  {
    echo "Ouch!" . PHP_EOL;
  }

  public function makeSound()
  {
    echo "Beep beep!" . PHP_EOL;
  }

  public function showLoadingScreen()
  {
    echo "Loading.." . PHP_EOL;
  }

  public function bam()
  {
    echo "Ready to be used!" . PHP_EOL;
  }

  public function closeEverything()
  {
    echo "Bup bup.." . PHP_EOL;
  }

  public function pullCurrent()
  {
    echo "Haaah!" . PHP_EOL;
  }

  public function sooth()
  {
    echo "Zzzzz" . PHP_EOL;
  }
}

class ComputerFacade
{
  public function __construct(private Computer $computer)
  {
  }

  public function turnOn()
  {
    $this->computer->getElectricShock();
    $this->computer->makeSound();
    $this->computer->showLoadingScreen();
    $this->computer->bam();
  }

  public function turnOff()
  {
    $this->computer->closeEverything();
    $this->computer->pullCurrent();
    $this->computer->sooth();
  }
}

$computerFacade = new ComputerFacade(new Computer());
$computerFacade->turnOn();
$computerFacade->turnOff();

// Output:
// Ouch!
// Beep beep!
// Loading..
// Ready to be used!
// Bup bup..
// Haaah!
// Zzzzz

package main

import (
    "fmt"
)

type computer struct{}

func (c *computer) getElectricShock() {
    fmt.Println("Ouch!")
}

func (c *computer) makeSound() {
    fmt.Println("Beep beep!")
}

func (c *computer) showLoadingScreen() {
    fmt.Println("Loading..")
}

func (c *computer) bam() {
    fmt.Println("Ready to be used!")
}

func (c *computer) closeEverything() {
    fmt.Println("Bup bup..")
}

func (c *computer) pullCurrent() {
    fmt.Println("Haaah!")
}

func (c *computer) sooth() {
    fmt.Println("Zzzzz")
}

type computerFacade struct {
    computer *computer
}

func newComputerFacade(c *computer) *computerFacade {
    if c == nil {
        panic("computer cannot be nil")
    }
    return &computerFacade{computer: c}
}

func (cf *computerFacade) turnOn() {
    cf.computer.getElectricShock()
    cf.computer.makeSound()
    cf.computer.showLoadingScreen()
    cf.computer.bam()
}

func (cf *computerFacade) turnOff() {
    cf.computer.closeEverything()
    cf.computer.pullCurrent()
    cf.computer.sooth()
}

func main() {
    c := newComputerFacade(&computer{})
    c.turnOn()
    c.turnOff()
}

// Output:
// Ouch!
// Beep beep!
// Loading..
// Ready to be used!
// Bup bup..
// Haaah!
// Zzzzz

class Computer {
    public void getElectricShock() {
        System.out.println("Ouch!");
    }

    public void makeSound() {
        System.out.println("Beep beep!");
    }

    public void showLoadingScreen() {
        System.out.println("Loading..");
    }

    public void bam() {
        System.out.println("Ready to be used!");
    }

    public void closeEverything() {
        System.out.println("Bup bup..");
    }

    public void pullCurrent() {
        System.out.println("Haaah!");
    }

    public void sooth() {
        System.out.println("Zzzzz");
    }
}

class ComputerFacade {
    private Computer computer;

    public ComputerFacade(Computer computer) {
        if (computer == null)
            throw new IllegalArgumentException("computer cannot be null");
        this.computer = computer;
    }

    public void turnOn() {
        computer.getElectricShock();
        computer.makeSound();
        computer.showLoadingScreen();
        computer.bam();
    }

    public void turnOff() {
        computer.closeEverything();
        computer.pullCurrent();
        computer.sooth();
    }
}

// ----------------------------

ComputerFacade computer = new ComputerFacade(new Computer());
computer.turnOn();
computer.turnOff();

// Output:
// Ouch!
// Beep beep!
// Loading..
// Ready to be used!
// Bup bup..
// Haaah!
// Zzzzz

#include <iostream>

class Computer {
public:
    void getElectricShock() {
        std::cout << "Ouch!" << std::endl;
    }

    void makeSound() {
        std::cout << "Beep beep!" << std::endl;
    }

    void showLoadingScreen() {
        std::cout << "Loading.." << std::endl;
    }

    void bam() {
        std::cout << "Ready to be used!" << std::endl;
    }

    void closeEverything() {
        std::cout << "Bup bup.." << std::endl;
    }

    void pullCurrent() {
        std::cout << "Haaah!" << std::endl;
    }

    void sooth() {
        std::cout << "Zzzzz" << std::endl;
    }
};

class ComputerFacade {
private:
    Computer& computer;

public:
    ComputerFacade(Computer& comp) : computer(comp) {}

    void turnOn() {
        computer.getElectricShock();
        computer.makeSound();
        computer.showLoadingScreen();
        computer.bam();
    }

    void turnOff() {
        computer.closeEverything();
        computer.pullCurrent();
        computer.sooth();
    }
};

// ----------------------------

int main() {
    Computer comp;
    ComputerFacade computer(comp);
    computer.turnOn();
    computer.turnOff();
    return 0;
}

// Output:
// Ouch!
// Beep beep!
// Loading..
// Ready to be used!
// Bup bup..
// Haaah!
// Zzzzz

class Computer {
    fun getElectricShock() = println("Ouch!")
    fun makeSound() = println("Beep beep!")
    fun showLoadingScreen() = println("Loading..")
    fun bam() = println("Ready to be used!")
    fun closeEverything() = println("Bup bup..")
    fun pullCurrent() = println("Haaah!")
    fun sooth() = println("Zzzzz")
}

class ComputerFacade(private val computer: Computer) {
    fun turnOn() {
        computer.getElectricShock()
        computer.makeSound()
        computer.showLoadingScreen()
        computer.bam()
    }

    fun turnOff() {
        computer.closeEverything()
        computer.pullCurrent()
        computer.sooth()
    }
}

// ----------------------------

fun main() {
    val computer = ComputerFacade(Computer())
    computer.turnOn()
    computer.turnOff()
}

class Computer {
  void getElectricShock() => print('Ouch!');
  void makeSound() => print('Beep beep!');
  void showLoadingScreen() => print('Loading..');
  void bam() => print('Ready to be used!');
  void closeEverything() => print('Bup bup..');
  void pullCurrent() => print('Haaah!');
  void sooth() => print('Zzzzz');
}

class ComputerFacade {
  final Computer _computer;

  ComputerFacade(this._computer);

  void turnOn() {
    _computer.getElectricShock();
    _computer.makeSound();
    _computer.showLoadingScreen();
    _computer.bam();
  }

  void turnOff() {
    _computer.closeEverything();
    _computer.pullCurrent();
    _computer.sooth();
  }
}

// ----------------------------

void main() {
  var computer = ComputerFacade(Computer());
  computer.turnOn();
  computer.turnOff();
}

# KarakTea is the flyweight: the shared, intrinsic part.
class KarakTea:
    pass


# TeaMaker acts as the factory and caches one tea object per type.
class TeaMaker:
    def __init__(self):
        self.available_tea = {}

    def make(self, tea_type):
        if tea_type not in self.available_tea:
            self.available_tea[tea_type] = KarakTea()

        return self.available_tea[tea_type]

    def total_teas_made(self):
        return len(self.available_tea)


class TeaShop:
    def __init__(self, tea_maker):
        self.orders = {}
        self.tea_maker = tea_maker

    def take_order(self, tea_type, table):
        # Table number is the extrinsic state, passed in from outside.
        self.orders[table] = self.tea_maker.make(tea_type)

    def serve(self):
        for table in self.orders:
            print("Serving Karak Tea to table #" + str(table))


# ----------------------------

tea_maker = TeaMaker()
shop = TeaShop(tea_maker)

shop.take_order("Karak", 1)
shop.take_order("Karak", 3)
shop.take_order("Karak", 5)
shop.take_order("Karak", 7)
shop.take_order("Karak", 9)

shop.serve()

print("Total tea objects made: " + str(tea_maker.total_teas_made()))
# Serving Karak Tea to table #1
# Serving Karak Tea to table #3
# Serving Karak Tea to table #5
# Serving Karak Tea to table #7
# Serving Karak Tea to table #9
# Total tea objects made: 1

// KarakTea is the flyweight: the shared, intrinsic part.
class KarakTea {
}

// TeaMaker acts as the factory and caches one tea object per type.
class TeaMaker {
    private availableTea: { [key: string]: KarakTea } = {};

    make(teaType: string): KarakTea {
        if (!(teaType in this.availableTea)) {
            this.availableTea[teaType] = new KarakTea();
        }

        return this.availableTea[teaType];
    }

    totalTeasMade(): number {
        return Object.keys(this.availableTea).length;
    }
}

class TeaShop {
    private orders: { [key: number]: KarakTea } = {};
    private teaMaker: TeaMaker;

    constructor(teaMaker: TeaMaker) {
        this.teaMaker = teaMaker;
    }

    takeOrder(teaType: string, table: number): void {
        // Table number is the extrinsic state, passed in from outside.
        this.orders[table] = this.teaMaker.make(teaType);
    }

    serve(): void {
        for (const table in this.orders) {
            console.log("Serving Karak Tea to table #" + table);
        }
    }
}

// ----------------------------

const teaMaker = new TeaMaker();
const shop = new TeaShop(teaMaker);

shop.takeOrder("Karak", 1);
shop.takeOrder("Karak", 3);
shop.takeOrder("Karak", 5);
shop.takeOrder("Karak", 7);
shop.takeOrder("Karak", 9);

shop.serve();

console.log("Total tea objects made: " + teaMaker.totalTeasMade());
// Serving Karak Tea to table #1
// Serving Karak Tea to table #3
// Serving Karak Tea to table #5
// Serving Karak Tea to table #7
// Serving Karak Tea to table #9
// Total tea objects made: 1

// KarakTea is the flyweight: the shared, intrinsic part.
class KarakTea {
}

// TeaMaker acts as the factory and caches one tea object per type.
class TeaMaker {
    constructor() {
        this.availableTea = {};
    }

    make(teaType) {
        if (!(teaType in this.availableTea)) {
            this.availableTea[teaType] = new KarakTea();
        }

        return this.availableTea[teaType];
    }

    totalTeasMade() {
        return Object.keys(this.availableTea).length;
    }
}

class TeaShop {
    constructor(teaMaker) {
        this.orders = {};
        this.teaMaker = teaMaker;
    }

    takeOrder(teaType, table) {
        // Table number is the extrinsic state, passed in from outside.
        this.orders[table] = this.teaMaker.make(teaType);
    }

    serve() {
        for (const table in this.orders) {
            console.log("Serving Karak Tea to table #" + table);
        }
    }
}


const teaMaker = new TeaMaker();
const shop = new TeaShop(teaMaker);

shop.takeOrder("Karak", 1);
shop.takeOrder("Karak", 3);
shop.takeOrder("Karak", 5);
shop.takeOrder("Karak", 7);
shop.takeOrder("Karak", 9);

shop.serve();

console.log("Total tea objects made: " + teaMaker.totalTeasMade());
// Serving Karak Tea to table #1
// Serving Karak Tea to table #3
// Serving Karak Tea to table #5
// Serving Karak Tea to table #7
// Serving Karak Tea to table #9
// Total tea objects made: 1

using System;
using System.Collections.Generic;


// KarakTea is the flyweight: the shared, intrinsic part.
class KarakTea
{
}

// Acts as a factory and caches one tea object per type.
class TeaMaker
{
  private Dictionary<string, KarakTea> mAvailableTea = new Dictionary<string, KarakTea>();

  public KarakTea Make(string teaType)
  {
    if (!mAvailableTea.ContainsKey(teaType))
    {
      mAvailableTea[teaType] = new KarakTea();
    }

    return mAvailableTea[teaType];
  }

  public int TotalTeasMade()
  {
    return mAvailableTea.Count;
  }
}

class TeaShop
{
  private Dictionary<int, KarakTea> mOrders = new Dictionary<int, KarakTea>();
  private readonly TeaMaker mTeaMaker;

  public TeaShop(TeaMaker teaMaker)
  {
    mTeaMaker = teaMaker ?? throw new ArgumentNullException("teaMaker", "teaMaker cannot be null");
  }

  public void TakeOrder(string teaType, int table)
  {
    // Table number is the extrinsic state, passed in from outside.
    mOrders[table] = mTeaMaker.Make(teaType);
  }

  public void Serve()
  {
    foreach (var table in mOrders.Keys)
    {
      Console.WriteLine("Serving Karak Tea to table #" + table);
    }
  }
}

// ----------------------------

var teaMaker = new TeaMaker();
var teaShop = new TeaShop(teaMaker);

teaShop.TakeOrder("Karak", 1);
teaShop.TakeOrder("Karak", 3);
teaShop.TakeOrder("Karak", 5);
teaShop.TakeOrder("Karak", 7);
teaShop.TakeOrder("Karak", 9);

teaShop.Serve();

Console.WriteLine("Total tea objects made: " + teaMaker.TotalTeasMade());
// Serving Karak Tea to table #1
// Serving Karak Tea to table #3
// Serving Karak Tea to table #5
// Serving Karak Tea to table #7
// Serving Karak Tea to table #9
// Total tea objects made: 1

// KarakTea is the flyweight: the shared, intrinsic part.
class KarakTea
{
}

// Acts as a factory and caches one tea object per type.
class TeaMaker
{
  private array $mAvailableTea = [];

  public function make(string $teaType): KarakTea
  {
    if (!array_key_exists($teaType, $this->mAvailableTea)) {
      $this->mAvailableTea[$teaType] = new KarakTea();
    }

    return $this->mAvailableTea[$teaType];
  }

  public function totalTeasMade(): int
  {
    return count($this->mAvailableTea);
  }
}

class TeaShop
{
  private array $mOrders = [];

  public function __construct(private TeaMaker $teaMaker)
  {
  }

  public function takeOrder(string $teaType, int $table): void
  {
    // Table number is the extrinsic state, passed in from outside.
    $this->mOrders[$table] = $this->teaMaker->make($teaType);
  }

  public function serve(): void
  {
    foreach ($this->mOrders as $table => $tea) {
      echo "Serving Karak Tea to table #$table\n";
    }
  }
}

$teaMaker = new TeaMaker();
$teaShop = new TeaShop($teaMaker);

$teaShop->takeOrder("Karak", 1);
$teaShop->takeOrder("Karak", 3);
$teaShop->takeOrder("Karak", 5);
$teaShop->takeOrder("Karak", 7);
$teaShop->takeOrder("Karak", 9);

$teaShop->serve();

echo "Total tea objects made: " . $teaMaker->totalTeasMade() . "\n";
// Serving Karak Tea to table #1
// Serving Karak Tea to table #3
// Serving Karak Tea to table #5
// Serving Karak Tea to table #7
// Serving Karak Tea to table #9
// Total tea objects made: 1

// KarakTea is the flyweight: the shared, intrinsic part.
type KarakTea struct{}

// TeaMaker acts as the factory and caches one tea object per type.
type TeaMaker struct {
    mAvailableTea map[string]*KarakTea
}

func NewTeaMaker() *TeaMaker {
    return &TeaMaker{mAvailableTea: make(map[string]*KarakTea)}
}

func (tm *TeaMaker) Make(teaType string) *KarakTea {
    if _, ok := tm.mAvailableTea[teaType]; !ok {
        tm.mAvailableTea[teaType] = &KarakTea{}
    }
    return tm.mAvailableTea[teaType]
}

func (tm *TeaMaker) TotalTeasMade() int {
    return len(tm.mAvailableTea)
}

type TeaShop struct {
    mTables   []int
    mOrders   map[int]*KarakTea
    mTeaMaker *TeaMaker
}

func NewTeaShop(teaMaker *TeaMaker) *TeaShop {
    return &TeaShop{
        mOrders:   make(map[int]*KarakTea),
        mTeaMaker: teaMaker,
    }
}

func (ts *TeaShop) TakeOrder(teaType string, table int) {
    // Table number is the extrinsic state, passed in from outside.
    if _, ok := ts.mOrders[table]; !ok {
        ts.mTables = append(ts.mTables, table)
    }
    ts.mOrders[table] = ts.mTeaMaker.Make(teaType)
}

func (ts *TeaShop) Serve() {
    for _, table := range ts.mTables {
        fmt.Printf("Serving Karak Tea to table #%d\n", table)
    }
}
// ---------------------------
teaMaker := NewTeaMaker()
teaShop := NewTeaShop(teaMaker)

teaShop.TakeOrder("Karak", 1)
teaShop.TakeOrder("Karak", 3)
teaShop.TakeOrder("Karak", 5)
teaShop.TakeOrder("Karak", 7)
teaShop.TakeOrder("Karak", 9)

teaShop.Serve()

fmt.Printf("Total tea objects made: %d\n", teaMaker.TotalTeasMade())
// Serving Karak Tea to table #1
// Serving Karak Tea to table #3
// Serving Karak Tea to table #5
// Serving Karak Tea to table #7
// Serving Karak Tea to table #9
// Total tea objects made: 1

import java.util.*;

// KarakTea is the flyweight: the shared, intrinsic part.
class KarakTea {
}

// Acts as a factory and caches one tea object per type.
class TeaMaker {
    private Map<String, KarakTea> availableTea = new HashMap<>();

    public KarakTea make(String teaType) {
        if (!availableTea.containsKey(teaType)) {
            availableTea.put(teaType, new KarakTea());
        }
        return availableTea.get(teaType);
    }

    public int totalTeasMade() {
        return availableTea.size();
    }
}

class TeaShop {
    private Map<Integer, KarakTea> orders = new LinkedHashMap<>();
    private TeaMaker teaMaker;

    public TeaShop(TeaMaker teaMaker) {
        if (teaMaker == null)
            throw new IllegalArgumentException("teaMaker cannot be null");
        this.teaMaker = teaMaker;
    }

    public void takeOrder(String teaType, int table) {
        // Table number is the extrinsic state, passed in from outside.
        orders.put(table, teaMaker.make(teaType));
    }

    public void serve() {
        for (Integer table : orders.keySet()) {
            System.out.println("Serving Karak Tea to table #" + table);
        }
    }
}

// ----------------------------

TeaMaker teaMaker = new TeaMaker();
TeaShop teaShop = new TeaShop(teaMaker);

teaShop.takeOrder("Karak", 1);
teaShop.takeOrder("Karak", 3);
teaShop.takeOrder("Karak", 5);
teaShop.takeOrder("Karak", 7);
teaShop.takeOrder("Karak", 9);

teaShop.serve();

System.out.println("Total tea objects made: " + teaMaker.totalTeasMade());
// Serving Karak Tea to table #1
// Serving Karak Tea to table #3
// Serving Karak Tea to table #5
// Serving Karak Tea to table #7
// Serving Karak Tea to table #9
// Total tea objects made: 1

#include <iostream>
#include <unordered_map>
#include <string>
#include <vector>

// KarakTea is the flyweight: the shared, intrinsic part.
class KarakTea {
    // Tea implementation
};

// TeaMaker acts as the factory and caches one tea object per type.
class TeaMaker {
private:
    std::unordered_map<std::string, KarakTea*> availableTea;

public:
    KarakTea* make(const std::string& teaType) {
        if (availableTea.find(teaType) == availableTea.end()) {
            availableTea[teaType] = new KarakTea();
        }
        return availableTea[teaType];
    }

    int totalTeasMade() const {
        return availableTea.size();
    }
};

class TeaShop {
private:
    std::vector<int> tables;
    std::unordered_map<int, KarakTea*> orders;
    TeaMaker& teaMaker;

public:
    TeaShop(TeaMaker& maker) : teaMaker(maker) {}

    void takeOrder(const std::string& teaType, int table) {
        // Table number is the extrinsic state, passed in from outside.
        if (orders.find(table) == orders.end()) {
            tables.push_back(table);
        }
        orders[table] = teaMaker.make(teaType);
    }

    void serve() {
        for (int table : tables) {
            std::cout << "Serving Karak Tea to table #" << table << std::endl;
        }
    }
};

// ----------------------------

int main() {
    TeaMaker teaMaker;
    TeaShop teaShop(teaMaker);

    teaShop.takeOrder("Karak", 1);
    teaShop.takeOrder("Karak", 3);
    teaShop.takeOrder("Karak", 5);
    teaShop.takeOrder("Karak", 7);
    teaShop.takeOrder("Karak", 9);

    teaShop.serve();

    std::cout << "Total tea objects made: " << teaMaker.totalTeasMade() << std::endl;
    // Serving Karak Tea to table #1
    // Serving Karak Tea to table #3
    // Serving Karak Tea to table #5
    // Serving Karak Tea to table #7
    // Serving Karak Tea to table #9
    // Total tea objects made: 1
    return 0;
}

// KarakTea is the flyweight: the shared, intrinsic part.
class KarakTea

// TeaMaker acts as the factory and caches one tea object per type.
class TeaMaker {
    private val availableTea = mutableMapOf<String, KarakTea>()

    fun make(teaType: String): KarakTea =
        availableTea.getOrPut(teaType) { KarakTea() }

    fun totalTeasMade(): Int = availableTea.size
}

class TeaShop(private val teaMaker: TeaMaker) {
    private val orders = mutableMapOf<Int, KarakTea>()

    fun takeOrder(teaType: String, table: Int) {
        // Table number is the extrinsic state, passed in from outside.
        orders[table] = teaMaker.make(teaType)
    }

    fun serve() {
        for (table in orders.keys) {
            println("Serving Karak Tea to table #" + table)
        }
    }
}

// ----------------------------

fun main() {
    val teaMaker = TeaMaker()
    val shop = TeaShop(teaMaker)

    shop.takeOrder("Karak", 1)
    shop.takeOrder("Karak", 3)
    shop.takeOrder("Karak", 5)
    shop.takeOrder("Karak", 7)
    shop.takeOrder("Karak", 9)

    shop.serve()

    println("Total tea objects made: " + teaMaker.totalTeasMade())
}

// KarakTea is the flyweight: the shared, intrinsic part.
class KarakTea {}

// TeaMaker acts as the factory and caches one tea object per type.
class TeaMaker {
  final Map<String, KarakTea> _availableTea = {};

  KarakTea make(String teaType) {
    return _availableTea.putIfAbsent(teaType, () => KarakTea());
  }

  int totalTeasMade() => _availableTea.length;
}

class TeaShop {
  final Map<int, KarakTea> _orders = {};
  final TeaMaker _teaMaker;

  TeaShop(this._teaMaker);

  void takeOrder(String teaType, int table) {
    // Table number is the extrinsic state, passed in from outside.
    _orders[table] = _teaMaker.make(teaType);
  }

  void serve() {
    for (var table in _orders.keys) {
      print('Serving Karak Tea to table #$table');
    }
  }
}

// ----------------------------

void main() {
  var teaMaker = TeaMaker();
  var shop = TeaShop(teaMaker);

  shop.takeOrder('Karak', 1);
  shop.takeOrder('Karak', 3);
  shop.takeOrder('Karak', 5);
  shop.takeOrder('Karak', 7);
  shop.takeOrder('Karak', 9);

  shop.serve();

  print('Total tea objects made: ${teaMaker.totalTeasMade()}');
}

class Door:
    def open(self, password):
        raise NotImplementedError

    def close(self):
        raise NotImplementedError


class LabDoor(Door):
    def open(self, password):
        print("Opening lab door")

    def close(self):
        print("Closing lab door")


class SecurityProxy(Door):
    def __init__(self, door):
        self.door = door

    def open(self, password):
        if self.authenticate(password):
            self.door.open(password)
        else:
            print("Big no! It is not possible.")

    def authenticate(self, password):
        return password == "$ecr@t"

    def close(self):
        self.door.close()


# ----------------------------

door = SecurityProxy(LabDoor())
door.open("invalid")   # Big no! It is not possible.
door.open("$ecr@t")    # Opening lab door
door.close()           # Closing lab door

interface Door {
    open(password: string): void;
    close(): void;
}

class LabDoor implements Door {
    open(password: string): void {
        console.log("Opening lab door");
    }

    close(): void {
        console.log("Closing lab door");
    }
}

class SecurityProxy implements Door {
    private door: Door;

    constructor(door: Door) {
        this.door = door;
    }

    open(password: string): void {
        if (this.authenticate(password)) {
            this.door.open(password);
        } else {
            console.log("Big no! It is not possible.");
        }
    }

    private authenticate(password: string): boolean {
        return password === "$ecr@t";
    }

    close(): void {
        this.door.close();
    }
}

// ----------------------------

const door = new SecurityProxy(new LabDoor());
door.open("invalid");   // Big no! It is not possible.
door.open("$ecr@t");    // Opening lab door
door.close();           // Closing lab door

class LabDoor {
    open(password) {
        console.log("Opening lab door");
    }

    close() {
        console.log("Closing lab door");
    }
}

class SecurityProxy {
    constructor(door) {
        this.door = door;
    }

    open(password) {
        if (this.authenticate(password)) {
            this.door.open(password);
        } else {
            console.log("Big no! It is not possible.");
        }
    }

    authenticate(password) {
        return password === "$ecr@t";
    }

    close() {
        this.door.close();
    }
}


const door = new SecurityProxy(new LabDoor());
door.open("invalid");   // Big no! It is not possible.
door.open("$ecr@t");    // Opening lab door
door.close();           // Closing lab door

using System;


interface IDoor
{
  void Open(string password);
  void Close();
}

class LabDoor : IDoor
{
  public void Open(string password)
  {
    Console.WriteLine("Opening lab door");
  }

  public void Close()
  {
    Console.WriteLine("Closing lab door");
  }
}

class SecurityProxy : IDoor
{
  private IDoor mDoor;

  public SecurityProxy(IDoor door)
  {
    mDoor = door ?? throw new ArgumentNullException("door", "door can not be null");
  }

  public void Open(string password)
  {
    if (Authenticate(password))
    {
      mDoor.Open(password);
    }
    else
    {
      Console.WriteLine("Big no! It is not possible.");
    }
  }

  private bool Authenticate(string password)
  {
    return password == "$ecr@t";
  }

  public void Close()
  {
    mDoor.Close();
  }
}

// ----------------------------

IDoor door = new SecurityProxy(new LabDoor());
door.Open("invalid"); // Big no! It is not possible.
door.Open("$ecr@t");  // Opening lab door
door.Close();         // Closing lab door

interface DoorInterface {
  public function open(string $password);
  public function close();
}

class LabDoor implements DoorInterface {
  public function open(string $password) {
    echo "Opening lab door\n";
  }

  public function close() {
    echo "Closing lab door\n";
  }
}

class SecurityProxy implements DoorInterface {
  public function __construct(private DoorInterface $door) {
  }

  public function open(string $password) {
    if ($this->authenticate($password)) {
      $this->door->open($password);
    } else {
      echo "Big no! It is not possible.\n";
    }
  }

  private function authenticate(string $password): bool {
    return $password === '$ecr@t';
  }

  public function close() {
    $this->door->close();
  }
}

$door = new SecurityProxy(new LabDoor());
$door->open('invalid');  // Big no! It is not possible.
$door->open('$ecr@t');   // Opening lab door
$door->close();          // Closing lab door

package main

import "fmt"

type Door interface {
    Open(password string)
    Close()
}

type LabDoor struct{}

func (d LabDoor) Open(password string) {
    fmt.Println("Opening lab door")
}

func (d LabDoor) Close() {
    fmt.Println("Closing lab door")
}

type SecurityProxy struct {
    door Door
}

func NewSecurityProxy(door Door) *SecurityProxy {
    return &SecurityProxy{door: door}
}

func (d *SecurityProxy) Open(password string) {
    if d.authenticate(password) {
        d.door.Open(password)
    } else {
        fmt.Println("Big no! It is not possible.")
    }
}

func (d *SecurityProxy) authenticate(password string) bool {
    return password == "$ecr@t"
}

func (d *SecurityProxy) Close() {
    d.door.Close()
}

func main() {
    door := NewSecurityProxy(LabDoor{})
    door.Open("invalid") // Big no! It is not possible.
    door.Open("$ecr@t")  // Opening lab door
    door.Close()         // Closing lab door
}

interface Door {
    void open(String password);
    void close();
}

class LabDoor implements Door {
    public void open(String password) {
        System.out.println("Opening lab door");
    }

    public void close() {
        System.out.println("Closing lab door");
    }
}

class SecurityProxy implements Door {
    private Door door;

    public SecurityProxy(Door door) {
        if (door == null)
            throw new IllegalArgumentException("door can not be null");
        this.door = door;
    }

    @Override
    public void open(String password) {
        if (authenticate(password)) {
            door.open(password);
        } else {
            System.out.println("Big no! It is not possible.");
        }
    }

    private boolean authenticate(String password) {
        return "$ecr@t".equals(password);
    }

    @Override
    public void close() {
        door.close();
    }
}

// ----------------------------

Door door = new SecurityProxy(new LabDoor());

door.open("invalid");       // Big no! It is not possible.
door.open("$ecr@t");        // Opening lab door
door.close();               // Closing lab door

#include <iostream>
#include <string>

class Door {
public:
    virtual ~Door() = default;
    virtual void open(const std::string& password) = 0;
    virtual void close() = 0;
};

class LabDoor : public Door {
public:
    void open(const std::string& password) override {
        std::cout << "Opening lab door" << std::endl;
    }

    void close() override {
        std::cout << "Closing lab door" << std::endl;
    }
};

class SecurityProxy : public Door {
private:
    Door& door;

    bool authenticate(const std::string& password) {
        return password == "$ecr@t";
    }

public:
    SecurityProxy(Door& d) : door(d) {}

    void open(const std::string& password) override {
        if (authenticate(password)) {
            door.open(password);
        } else {
            std::cout << "Big no! It is not possible." << std::endl;
        }
    }

    void close() override {
        door.close();
    }
};

// ----------------------------

int main() {
    LabDoor labDoor;
    SecurityProxy door(labDoor);

    door.open("invalid");       // Big no! It is not possible.
    door.open("$ecr@t");        // Opening lab door
    door.close();               // Closing lab door
    return 0;
}

interface Door {
    fun open(password: String)
    fun close()
}

class LabDoor : Door {
    override fun open(password: String) = println("Opening lab door")
    override fun close() = println("Closing lab door")
}

class SecurityProxy(private val door: Door) : Door {
    override fun open(password: String) {
        if (authenticate(password)) {
            door.open(password)
        } else {
            println("Big no! It is not possible.")
        }
    }

    private fun authenticate(password: String): Boolean = password == "\$ecr@t"

    override fun close() {
        door.close()
    }
}

// ----------------------------

fun main() {
    val door = SecurityProxy(LabDoor())
    door.open("invalid")
    door.open("\$ecr@t")
    door.close()
}

abstract class Door {
  void open(String password);
  void close();
}

class LabDoor implements Door {
  @override
  void open(String password) => print('Opening lab door');

  @override
  void close() => print('Closing lab door');
}

class SecurityProxy implements Door {
  final Door _door;

  SecurityProxy(this._door);

  @override
  void open(String password) {
    if (authenticate(password)) {
      _door.open(password);
    } else {
      print('Big no! It is not possible.');
    }
  }

  bool authenticate(String password) => password == r'$ecr@t';

  @override
  void close() => _door.close();
}

// ----------------------------

void main() {
  var door = SecurityProxy(LabDoor());
  door.open('invalid');
  door.open(r'$ecr@t');
  door.close();
}

class Account:
    _successor = None

    def setNext(self, account):
        self._successor = account

    def pay(self, amountToPay):
        if self.canPay(amountToPay):
            print("Paid " + str(amountToPay) + " using " + self.getName())
        elif self._successor:
            print("Cannot pay using " + self.getName() + ". Proceeding ..")
            self._successor.pay(amountToPay)
        else:
            print("None of the accounts have enough balance")

    def canPay(self, amount):
        return self.balance >= amount

    def getName(self):
        return type(self).__name__


class Bank(Account):
    def __init__(self, balance):
        self.balance = balance


class Paypal(Account):
    def __init__(self, balance):
        self.balance = balance


class Bitcoin(Account):
    def __init__(self, balance):
        self.balance = balance


# ----------------------------

bank = Bank(100)        # Bank with balance 100
paypal = Paypal(300)    # Paypal with balance 300
bitcoin = Bitcoin(1000) # Bitcoin with balance 1000

bank.setNext(paypal)
paypal.setNext(bitcoin)

bank.pay(259)


'''
Output will be
==============
Cannot pay using Bank. Proceeding ..
Paid 259 using Paypal
'''

class Account {
    protected _successor: Account | null = null;
    protected _balance: number = 0;

    setNext(account: Account): void {
        this._successor = account;
    }

    pay(amountToPay: number): void {
        if (this.canPay(amountToPay)) {
            console.log(`Paid ${amountToPay} using ${this.getName()}`);
        } else if (this._successor) {
            console.log(`Cannot pay using ${this.getName()}. Proceeding ..`);
            this._successor.pay(amountToPay);
        } else {
            console.log("None of the accounts have enough balance");
        }
    }

    canPay(amount: number): boolean {
        return this._balance >= amount;
    }

    getName(): string {
        return this.constructor.name;
    }
}

class Bank extends Account {
    constructor(balance: number) {
        super();
        this._balance = balance;
    }
}

class Paypal extends Account {
    constructor(balance: number) {
        super();
        this._balance = balance;
    }
}

class Bitcoin extends Account {
    constructor(balance: number) {
        super();
        this._balance = balance;
    }
}

// ----------------------------

const bank = new Bank(100);        // Bank with balance 100
const paypal = new Paypal(300);    // Paypal with balance 300
const bitcoin = new Bitcoin(1000); // Bitcoin with balance 1000

bank.setNext(paypal);
paypal.setNext(bitcoin);

bank.pay(259);

class Account {
    constructor() {
        this._successor = null;
        this._balance = null;
    }

    setNext(account) {
        this._successor = account;
    }

    pay(amountToPay) {
        if (this.canPay(amountToPay)) {
            console.log(`Paid ${amountToPay} using ${this.getName()}`);
        } else if (this._successor) {
            console.log(`Cannot pay using ${this.getName()}. Proceeding ..`);
            this._successor.pay(amountToPay);
        } else {
            console.log("None of the accounts have enough balance");
        }
    }

    canPay(amount) {
        return this._balance >= amount;
    }

    getName() {
        return this.constructor.name;
    }
}

class Bank extends Account {
    constructor(balance) {
        super();
        this._balance = balance;
    }
}

class Paypal extends Account {
    constructor(balance) {
        super();
        this._balance = balance;
    }
}

class Bitcoin extends Account {
    constructor(balance) {
        super();
        this._balance = balance;
    }
}

// ----------------------------

const bank = new Bank(100);        // Bank with balance 100
const paypal = new Paypal(300);    // Paypal with balance 300
const bitcoin = new Bitcoin(1000); // Bitcoin with balance 1000

bank.setNext(paypal);
paypal.setNext(bitcoin);

bank.pay(259);

using System;

abstract class Account
{
  private Account mSuccessor;
  protected int mBalance;

  public void SetNext(Account account)
  {
    mSuccessor = account;
  }

  public void Pay(int amountToPay)
  {
    if (CanPay(amountToPay))
    {
      Console.WriteLine($"Paid {amountToPay} using {this.GetType().Name}");
    }
    else if (this.mSuccessor != null)
    {
      Console.WriteLine($"Cannot pay using {this.GetType().Name}. Proceeding ..");
      mSuccessor.Pay(amountToPay);
    }
    else
    {
      Console.WriteLine("None of the accounts have enough balance");
    }
  }

  private bool CanPay(int amount)
  {
    return mBalance >= amount;
  }
}

class Bank : Account
{
  public Bank(int balance)
  {
    this.mBalance = balance;
  }
}

class Paypal : Account
{
  public Paypal(int balance)
  {
    this.mBalance = balance;
  }
}

class Bitcoin : Account
{
  public Bitcoin(int balance)
  {
    this.mBalance = balance;
  }
}

// ----------------------------

var bank = new Bank(100);        // Bank with balance 100
var paypal = new Paypal(300);    // Paypal with balance 300
var bitcoin = new Bitcoin(1000); // Bitcoin with balance 1000

bank.SetNext(paypal);
paypal.SetNext(bitcoin);

bank.Pay(259);
// Output will be
// ==============
// Cannot pay using Bank. Proceeding ..
// Paid 259 using Paypal

abstract class Account
{
    private $successor;
    protected $balance;

    public function setNext(Account $account)
    {
        $this->successor = $account;
    }

    public function pay($amountToPay)
    {
        if ($this->canPay($amountToPay)) {
            echo "Paid " . $amountToPay . " using " . get_class($this) . PHP_EOL;
        } elseif ($this->successor != null) {
            echo "Cannot pay using " . get_class($this) . ". Proceeding .." . PHP_EOL;
            $this->successor->pay($amountToPay);
        } else {
            echo "None of the accounts have enough balance" . PHP_EOL;
        }
    }

    private function canPay($amount)
    {
        return $this->balance >= $amount;
    }
}

class Bank extends Account
{
    public function __construct($balance)
    {
        $this->balance = $balance;
    }
}

class Paypal extends Account
{
    public function __construct($balance)
    {
        $this->balance = $balance;
    }
}

class Bitcoin extends Account
{
    public function __construct($balance)
    {
        $this->balance = $balance;
    }
}

// ----------------------------

$bank = new Bank(100);        // Bank with balance 100
$paypal = new Paypal(300);    // Paypal with balance 300
$bitcoin = new Bitcoin(1000); // Bitcoin with balance 1000

$bank->setNext($paypal);
$paypal->setNext($bitcoin);

$bank->pay(259);
// Output will be
// ==============
// Cannot pay using Bank. Proceeding ..
// Paid 259 using Paypal

package main

import "fmt"

type payer interface {
	Pay(amountToPay int)
}

type Account struct {
	successor payer
	balance   int
	name      string
}

func (a *Account) SetNext(account payer) {
	a.successor = account
}

func (a *Account) Pay(amountToPay int) {
	if a.canPay(amountToPay) {
		fmt.Printf("Paid %d using %s\n", amountToPay, a.name)
	} else if a.successor != nil {
		fmt.Printf("Cannot pay using %s. Proceeding ..\n", a.name)
		a.successor.Pay(amountToPay)
	} else {
		fmt.Println("None of the accounts have enough balance")
	}
}

func (a *Account) canPay(amount int) bool {
	return a.balance >= amount
}

func NewBank(balance int) *Account {
	return &Account{balance: balance, name: "Bank"}
}

func NewPaypal(balance int) *Account {
	return &Account{balance: balance, name: "Paypal"}
}

func NewBitcoin(balance int) *Account {
	return &Account{balance: balance, name: "Bitcoin"}
}

func main() {
	bank := NewBank(100)        // Bank with balance 100
	paypal := NewPaypal(300)    // Paypal with balance 300
	bitcoin := NewBitcoin(1000) // Bitcoin with balance 1000

	bank.SetNext(paypal)
	paypal.SetNext(bitcoin)

	bank.Pay(259)
}

abstract class Account {
  private Account successor;
  protected Integer balance;

  public void setNext(Account account) {
    successor = account;
  }

  public void pay(Integer amountToPay) {
    String accountType = this.getClass().getSimpleName();
    if (canPay(amountToPay)) {
      System.out.println("Paid " + amountToPay + " using " + accountType);
    } else if (this.successor != null) {
      System.out.println("Cannot pay using " + accountType + ". Proceeding ..");
      successor.pay(amountToPay);
    } else {
      System.out.println("None of the accounts have enough balance");
    }
  }

  private boolean canPay(Integer amount) {
    return balance >= amount;
  }
}

class Bank extends Account {
  public Bank(Integer balance) {
    this.balance = balance;
  }
}

class Paypal extends Account {
  public Paypal(Integer balance) {
    this.balance = balance;
  }
}

class Bitcoin extends Account {
  public Bitcoin(Integer balance) {
    this.balance = balance;
  }
}

// ----------------------------

Bank bank = new Bank(100);           // Bank with balance 100
Paypal paypal = new Paypal(300);     // Paypal with balance 300
Bitcoin bitcoin = new Bitcoin(1000); // Bitcoin with balance 1000

bank.setNext(paypal);
paypal.setNext(bitcoin);

bank.pay(259);
// Output will be
// ==============
// Cannot pay using Bank. Proceeding ..
// Paid 259 using Paypal

#include <iostream>
#include <string>

class Account {
protected:
    Account* successor = nullptr;
    int balance = 0;

public:
    virtual ~Account() = default;

    void setNext(Account* account) {
        successor = account;
    }

    void pay(int amountToPay) {
        if (canPay(amountToPay)) {
            std::cout << "Paid " << amountToPay << " using " << getName() << std::endl;
        } else if (successor != nullptr) {
            std::cout << "Cannot pay using " << getName() << ". Proceeding .." << std::endl;
            successor->pay(amountToPay);
        } else {
            std::cout << "None of the accounts have enough balance" << std::endl;
        }
    }

    virtual std::string getName() = 0;

private:
    bool canPay(int amount) {
        return balance >= amount;
    }
};

class Bank : public Account {
public:
    Bank(int bal) { balance = bal; }
    std::string getName() override { return "Bank"; }
};

class Paypal : public Account {
public:
    Paypal(int bal) { balance = bal; }
    std::string getName() override { return "Paypal"; }
};

class Bitcoin : public Account {
public:
    Bitcoin(int bal) { balance = bal; }
    std::string getName() override { return "Bitcoin"; }
};

// ----------------------------

int main() {
    Bank bank(100);        // Bank with balance 100
    Paypal paypal(300);    // Paypal with balance 300
    Bitcoin bitcoin(1000); // Bitcoin with balance 1000

    bank.setNext(&paypal);
    paypal.setNext(&bitcoin);

    bank.pay(259);
    // Cannot pay using Bank. Proceeding ..
    // Paid 259 using Paypal
    return 0;
}

abstract class Account(protected var balance: Int) {
    private var successor: Account? = null

    fun setNext(account: Account) {
        successor = account
    }

    fun pay(amountToPay: Int) {
        if (canPay(amountToPay)) {
            println("Paid " + amountToPay + " using " + getName())
        } else if (successor != null) {
            println("Cannot pay using " + getName() + ". Proceeding ..")
            successor!!.pay(amountToPay)
        } else {
            println("None of the accounts have enough balance")
        }
    }

    private fun canPay(amount: Int): Boolean = balance >= amount

    protected fun getName(): String = this::class.simpleName!!
}

class Bank(balance: Int) : Account(balance)

class Paypal(balance: Int) : Account(balance)

class Bitcoin(balance: Int) : Account(balance)

// ----------------------------

fun main() {
    val bank = Bank(100)        // Bank with balance 100
    val paypal = Paypal(300)    // Paypal with balance 300
    val bitcoin = Bitcoin(1000) // Bitcoin with balance 1000

    bank.setNext(paypal)
    paypal.setNext(bitcoin)

    bank.pay(259)
}

abstract class Account {
  Account? _successor;
  late int balance;

  void setNext(Account account) {
    _successor = account;
  }

  void pay(int amountToPay) {
    if (canPay(amountToPay)) {
      print('Paid $amountToPay using ${getName()}');
    } else if (_successor != null) {
      print('Cannot pay using ${getName()}. Proceeding ..');
      _successor!.pay(amountToPay);
    } else {
      print('None of the accounts have enough balance');
    }
  }

  bool canPay(int amount) => balance >= amount;

  String getName() => runtimeType.toString();
}

class Bank extends Account {
  Bank(int balance) {
    this.balance = balance;
  }
}

class Paypal extends Account {
  Paypal(int balance) {
    this.balance = balance;
  }
}

class Bitcoin extends Account {
  Bitcoin(int balance) {
    this.balance = balance;
  }
}

// ----------------------------

void main() {
  var bank = Bank(100); // Bank with balance 100
  var paypal = Paypal(300); // Paypal with balance 300
  var bitcoin = Bitcoin(1000); // Bitcoin with balance 1000

  bank.setNext(paypal);
  paypal.setNext(bitcoin);

  bank.pay(259);
}

class Bulb:
    def turnOn(self):
        print("Bulb has been lit")

    def turnOff(self):
        print("Darkness!")


class Command:
    def __init__(self, bulb):
        self._bulb = bulb

    def execute(self):
        pass

    def undo(self):
        pass


class TurnOn(Command):
    def execute(self):
        self._bulb.turnOn()

    def undo(self):
        self._bulb.turnOff()


class TurnOff(Command):
    def execute(self):
        self._bulb.turnOff()

    def undo(self):
        self._bulb.turnOn()


class RemoteControl:
    def submit(self, command):
        command.execute()


# ----------------------------

bulb = Bulb()

turnOn = TurnOn(bulb)
turnOff = TurnOff(bulb)

remote = RemoteControl()
remote.submit(turnOn)   # Bulb has been lit
remote.submit(turnOff)  # Darkness!

class Bulb {
    turnOn(): void {
        console.log("Bulb has been lit");
    }

    turnOff(): void {
        console.log("Darkness!");
    }
}

interface Command {
    execute(): void;
    undo(): void;
}

class TurnOn implements Command {
    constructor(private bulb: Bulb) {}

    execute(): void {
        this.bulb.turnOn();
    }

    undo(): void {
        this.bulb.turnOff();
    }
}

class TurnOff implements Command {
    constructor(private bulb: Bulb) {}

    execute(): void {
        this.bulb.turnOff();
    }

    undo(): void {
        this.bulb.turnOn();
    }
}

class RemoteControl {
    submit(command: Command): void {
        command.execute();
    }
}

// ----------------------------

const bulb = new Bulb();

const turnOn = new TurnOn(bulb);
const turnOff = new TurnOff(bulb);

const remote = new RemoteControl();
remote.submit(turnOn);  // Bulb has been lit
remote.submit(turnOff); // Darkness!

class Bulb {
    turnOn() {
        console.log("Bulb has been lit");
    }

    turnOff() {
        console.log("Darkness!");
    }
}

class Command {
    constructor(bulb) {
        this._bulb = bulb;
    }

    execute() {
    }

    undo() {
    }
}

class TurnOn extends Command {
    execute() {
        this._bulb.turnOn();
    }

    undo() {
        this._bulb.turnOff();
    }
}

class TurnOff extends Command {
    execute() {
        this._bulb.turnOff();
    }

    undo() {
        this._bulb.turnOn();
    }
}

class RemoteControl {
    submit(command) {
        command.execute();
    }
}

// ----------------------------

const bulb = new Bulb();

const turnOn = new TurnOn(bulb);
const turnOff = new TurnOff(bulb);

const remote = new RemoteControl();
remote.submit(turnOn);  // Bulb has been lit
remote.submit(turnOff); // Darkness!

using System;


// Receiver
class Bulb
{
  public void TurnOn()
  {
    Console.WriteLine("Bulb has been lit");
  }

  public void TurnOff()
  {
    Console.WriteLine("Darkness!");
  }
}

interface ICommand
{
  void Execute();
  void Undo();
}

// Command
class TurnOn : ICommand
{
  private Bulb mBulb;

  public TurnOn(Bulb bulb)
  {
    mBulb = bulb;
  }

  public void Execute()
  {
    mBulb.TurnOn();
  }

  public void Undo()
  {
    mBulb.TurnOff();
  }
}

class TurnOff : ICommand
{
  private Bulb mBulb;

  public TurnOff(Bulb bulb)
  {
    mBulb = bulb;
  }

  public void Execute()
  {
    mBulb.TurnOff();
  }

  public void Undo()
  {
    mBulb.TurnOn();
  }
}

// Invoker
class RemoteControl
{
  public void Submit(ICommand command)
  {
    command.Execute();
  }
}

// ----------------------------

var bulb = new Bulb();

var turnOn = new TurnOn(bulb);
var turnOff = new TurnOff(bulb);

var remote = new RemoteControl();
remote.Submit(turnOn);  // Bulb has been lit
remote.Submit(turnOff); // Darkness!

// Receiver
class Bulb
{
    public function turnOn()
    {
        echo "Bulb has been lit\n";
    }

    public function turnOff()
    {
        echo "Darkness!\n";
    }
}

interface CommandInterface
{
    public function execute();
    public function undo();
}

// Command
class TurnOn implements CommandInterface
{
    public function __construct(private Bulb $bulb)
    {
    }

    public function execute()
    {
        $this->bulb->turnOn();
    }

    public function undo()
    {
        $this->bulb->turnOff();
    }
}

class TurnOff implements CommandInterface
{
    public function __construct(private Bulb $bulb)
    {
    }

    public function execute()
    {
        $this->bulb->turnOff();
    }

    public function undo()
    {
        $this->bulb->turnOn();
    }
}

// Invoker
class RemoteControl
{
    public function submit(CommandInterface $command)
    {
        $command->execute();
    }
}

// Usage
$bulb = new Bulb();

$turnOn = new TurnOn($bulb);
$turnOff = new TurnOff($bulb);

$remote = new RemoteControl();
$remote->submit($turnOn);  // Bulb has been lit
$remote->submit($turnOff); // Darkness!

package main

import "fmt"

// Receiver
type Bulb struct{}

func (b *Bulb) TurnOn() {
    fmt.Println("Bulb has been lit")
}

func (b *Bulb) TurnOff() {
    fmt.Println("Darkness!")
}

// Command interface
type Command interface {
    Execute()
    Undo()
}

// Command
type TurnOnCommand struct {
    bulb *Bulb
}

func (c *TurnOnCommand) Execute() {
    c.bulb.TurnOn()
}

func (c *TurnOnCommand) Undo() {
    c.bulb.TurnOff()
}

type TurnOffCommand struct {
    bulb *Bulb
}

func (c *TurnOffCommand) Execute() {
    c.bulb.TurnOff()
}

func (c *TurnOffCommand) Undo() {
    c.bulb.TurnOn()
}

// Invoker
type RemoteControl struct{}

func (r *RemoteControl) Submit(command Command) {
    command.Execute()
}

func main() {
    bulb := &Bulb{}

    turnOn := &TurnOnCommand{bulb: bulb}
    turnOff := &TurnOffCommand{bulb: bulb}

    remote := &RemoteControl{}
    remote.Submit(turnOn)  // Bulb has been lit
    remote.Submit(turnOff) // Darkness!
}

// Receiver
class Bulb {
    public void turnOn() {
        System.out.println("Bulb has been lit");
    }

    public void turnOff() {
        System.out.println("Darkness!");
    }
}

interface Command {
    void execute();
    void undo();
}

// Command
class TurnOn implements Command {
    private Bulb bulb;

    public TurnOn(Bulb bulb) {
        this.bulb = bulb;
    }

    @Override
    public void execute() {
        bulb.turnOn();
    }

    @Override
    public void undo() {
        bulb.turnOff();
    }
}

class TurnOff implements Command {
    private Bulb bulb;

    public TurnOff(Bulb bulb) {
        this.bulb = bulb;
    }

    @Override
    public void execute() {
        bulb.turnOff();
    }

    @Override
    public void undo() {
        bulb.turnOn();
    }
}

// Invoker
class RemoteControl {
    public void submit(Command command) {
        command.execute();
    }
}

// ----------------------------

Bulb bulb = new Bulb();
TurnOn turnOnCmd = new TurnOn(bulb);
TurnOff turnOffCmd = new TurnOff(bulb);

RemoteControl remote = new RemoteControl();
remote.submit(turnOnCmd);  // Bulb has been lit
remote.submit(turnOffCmd); // Darkness!

#include <iostream>

// Receiver
class Bulb {
public:
    void turnOn() {
        std::cout << "Bulb has been lit" << std::endl;
    }

    void turnOff() {
        std::cout << "Darkness!" << std::endl;
    }
};

// Command interface
class Command {
public:
    virtual ~Command() = default;
    virtual void execute() = 0;
    virtual void undo() = 0;
};

class TurnOn : public Command {
private:
    Bulb& bulb;

public:
    TurnOn(Bulb& b) : bulb(b) {}

    void execute() override {
        bulb.turnOn();
    }

    void undo() override {
        bulb.turnOff();
    }
};

class TurnOff : public Command {
private:
    Bulb& bulb;

public:
    TurnOff(Bulb& b) : bulb(b) {}

    void execute() override {
        bulb.turnOff();
    }

    void undo() override {
        bulb.turnOn();
    }
};

// Invoker
class RemoteControl {
public:
    void submit(Command& command) {
        command.execute();
    }
};

// ----------------------------

int main() {
    Bulb bulb;

    TurnOn turnOn(bulb);
    TurnOff turnOff(bulb);

    RemoteControl remote;
    remote.submit(turnOn);  // Bulb has been lit
    remote.submit(turnOff); // Darkness!
    return 0;
}

// Receiver
class Bulb {
    fun turnOn() = println("Bulb has been lit")
    fun turnOff() = println("Darkness!")
}

interface Command {
    fun execute()
    fun undo()
}

// Command
class TurnOn(private val bulb: Bulb) : Command {
    override fun execute() = bulb.turnOn()
    override fun undo() = bulb.turnOff()
}

class TurnOff(private val bulb: Bulb) : Command {
    override fun execute() = bulb.turnOff()
    override fun undo() = bulb.turnOn()
}

// Invoker
class RemoteControl {
    fun submit(command: Command) {
        command.execute()
    }
}

// ----------------------------

fun main() {
    val bulb = Bulb()

    val turnOn = TurnOn(bulb)
    val turnOff = TurnOff(bulb)

    val remote = RemoteControl()
    remote.submit(turnOn)   // Bulb has been lit
    remote.submit(turnOff)  // Darkness!
}

// Receiver
class Bulb {
  void turnOn() => print('Bulb has been lit');
  void turnOff() => print('Darkness!');
}

abstract class Command {
  void execute();
  void undo();
}

// Command
class TurnOn implements Command {
  final Bulb _bulb;
  TurnOn(this._bulb);

  @override
  void execute() => _bulb.turnOn();

  @override
  void undo() => _bulb.turnOff();
}

class TurnOff implements Command {
  final Bulb _bulb;
  TurnOff(this._bulb);

  @override
  void execute() => _bulb.turnOff();

  @override
  void undo() => _bulb.turnOn();
}

// Invoker
class RemoteControl {
  void submit(Command command) {
    command.execute();
  }
}

// ----------------------------

void main() {
  var bulb = Bulb();

  var turnOn = TurnOn(bulb);
  var turnOff = TurnOff(bulb);

  var remote = RemoteControl();
  remote.submit(turnOn); // Bulb has been lit
  remote.submit(turnOff); // Darkness!
}

from __future__ import annotations
from collections.abc import Iterable, Iterator
from typing import List


class RadioStation:
    def __init__(self, frequency: float) -> None:
        self._frequency = frequency

    def get_frequency(self) -> float:
        return self._frequency


class StationIterator(Iterator):
    def __init__(self, stations: List[RadioStation]) -> None:
        self._stations = stations
        self._position = 0

    def __next__(self) -> RadioStation:
        if self._position >= len(self._stations):
            raise StopIteration()
        station = self._stations[self._position]
        self._position += 1
        return station


class RadioStationList(Iterable):
    def __init__(self) -> None:
        self._stations: List[RadioStation] = []

    def add(self, station: RadioStation) -> None:
        self._stations.append(station)

    def __iter__(self) -> StationIterator:
        return StationIterator(self._stations)

# ----------------------------

if __name__ == "__main__":
    stations = RadioStationList()
    stations.add(RadioStation(89.0))
    stations.add(RadioStation(101.0))
    stations.add(RadioStation(102.5))

    for station in stations:
        print(f"{station.get_frequency():.1f}")

'''
Output:
89.0
101.0
102.5
'''

class RadioStation {
    constructor(private frequency: number) {}

    getFrequency(): number {
        return this.frequency;
    }
}

class StationIterator implements Iterator<RadioStation> {
    private position = 0;

    constructor(private stations: RadioStation[]) {}

    next(): IteratorResult<RadioStation> {
        if (this.position < this.stations.length) {
            const value = this.stations[this.position];
            this.position += 1;
            return { value, done: false };
        }
        return { value: undefined as any, done: true };
    }
}

class RadioStationList {
    private stations: RadioStation[] = [];

    add(station: RadioStation): void {
        this.stations.push(station);
    }

    [Symbol.iterator](): Iterator<RadioStation> {
        return new StationIterator(this.stations);
    }
}

// ----------------------------

const stations = new RadioStationList();
stations.add(new RadioStation(89.0));
stations.add(new RadioStation(101.0));
stations.add(new RadioStation(102.5));

for (const station of stations) {
    console.log(station.getFrequency().toFixed(1));
}

// Output:
// 89.0
// 101.0
// 102.5

class RadioStation {
    constructor(frequency) {
        this.frequency = frequency;
    }

    getFrequency() {
        return this.frequency;
    }
}

class StationIterator {
    constructor(stations) {
        this.stations = stations;
        this.position = 0;
    }

    next() {
        if (this.position < this.stations.length) {
            const value = this.stations[this.position];
            this.position += 1;
            return { value, done: false };
        }
        return { value: undefined, done: true };
    }
}

class RadioStationList {
    constructor() {
        this.stations = [];
    }

    add(station) {
        this.stations.push(station);
    }

    [Symbol.iterator]() {
        return new StationIterator(this.stations);
    }
}

// ----------------------------

const stations = new RadioStationList();
stations.add(new RadioStation(89.0));
stations.add(new RadioStation(101.0));
stations.add(new RadioStation(102.5));

for (const station of stations) {
    console.log(station.getFrequency().toFixed(1));
}

// Output:
// 89.0
// 101.0
// 102.5

using System;
using System.Collections.Generic;
using System.Collections;
using System.Globalization;

class RadioStation
{
    private float mFrequency;

    public RadioStation(float frequency)
    {
        mFrequency = frequency;
    }

    public float GetFrequency()
    {
        return mFrequency;
    }
}

class StationList : IEnumerable<RadioStation>
{
    private List<RadioStation> mStations = new List<RadioStation>();

    public void Add(RadioStation station)
    {
        mStations.Add(station);
    }

    public IEnumerator<RadioStation> GetEnumerator()
    {
        foreach (var station in mStations)
        {
            yield return station;
        }
    }

    IEnumerator IEnumerable.GetEnumerator()
    {
        return GetEnumerator();
    }
}

// ----------------------------

var stations = new StationList();
stations.Add(new RadioStation(89.0f));
stations.Add(new RadioStation(101.0f));
stations.Add(new RadioStation(102.5f));

foreach (var station in stations)
{
    Console.WriteLine(station.GetFrequency().ToString("F1", CultureInfo.InvariantCulture));
}

// Output:
// 89.0
// 101.0
// 102.5

class RadioStation
{
    private $mFrequency;

    public function __construct($frequency)
    {
        $this->mFrequency = $frequency;
    }

    public function getFrequency()
    {
        return $this->mFrequency;
    }
}

class StationList implements IteratorAggregate
{
    private $mStations = [];

    public function add(RadioStation $station)
    {
        array_push($this->mStations, $station);
    }

    public function getIterator(): Iterator
    {
        foreach ($this->mStations as $station) {
            yield $station;
        }
    }
}

$stations = new StationList();
$stations->add(new RadioStation(89.0));
$stations->add(new RadioStation(101.0));
$stations->add(new RadioStation(102.5));

foreach ($stations as $station) {
    echo number_format($station->getFrequency(), 1) . "\n";
}

// Output:
// 89.0
// 101.0
// 102.5

package main

import (
    "fmt"
)

type RadioStation struct {
    frequency float32
}

func NewRadioStation(frequency float32) *RadioStation {
    return &RadioStation{frequency}
}

func (r *RadioStation) GetFrequency() float32 {
    return r.frequency
}

type StationList struct {
    stations []*RadioStation
}

func NewStationList() *StationList {
    return &StationList{}
}

func (s *StationList) Add(station *RadioStation) {
    s.stations = append(s.stations, station)
}

func (s *StationList) Iterator() <-chan *RadioStation {
    ch := make(chan *RadioStation)
    go func() {
        for _, station := range s.stations {
            ch <- station
        }
        close(ch)
    }()
    return ch
}

func main() {
    stations := NewStationList()
    stations.Add(NewRadioStation(89.0))
    stations.Add(NewRadioStation(101.0))
    stations.Add(NewRadioStation(102.5))

    for station := range stations.Iterator() {
        fmt.Printf("%.1f\n", station.GetFrequency())
    }
}

// Output:
// 89.0
// 101.0
// 102.5

import java.util.*;

class RadioStation {
    private float frequency;

    public RadioStation(float frequency) {
        this.frequency = frequency;
    }

    public float getFrequency() {
        return frequency;
    }
}

class StationList implements Iterable<RadioStation> {
    private List<RadioStation> stations;

    public StationList() {
        stations = new ArrayList<>();
    }

    public void add(RadioStation station) {
        stations.add(station);
    }

    @Override
    public Iterator<RadioStation> iterator() {
        return stations.iterator();
    }
}

// ----------------------------

StationList stations = new StationList();
stations.add(new RadioStation(89.0f));
stations.add(new RadioStation(101.0f));
stations.add(new RadioStation(102.5f));

Iterator<RadioStation> stationIterator = stations.iterator();
while (stationIterator.hasNext()) {
    RadioStation radioStation = stationIterator.next();
    System.out.println(radioStation.getFrequency());
}
// Output:
// 89.0
// 101.0
// 102.5

#include <iostream>
#include <vector>
#include <iomanip>

class RadioStation {
private:
    float frequency;

public:
    RadioStation(float freq) : frequency(freq) {}

    float getFrequency() const {
        return frequency;
    }
};

class StationList {
private:
    std::vector<RadioStation> stations;

public:
    void add(const RadioStation& station) {
        stations.push_back(station);
    }

    std::vector<RadioStation>::iterator begin() {
        return stations.begin();
    }

    std::vector<RadioStation>::iterator end() {
        return stations.end();
    }
};

// ----------------------------

int main() {
    StationList stations;
    stations.add(RadioStation(89.0f));
    stations.add(RadioStation(101.0f));
    stations.add(RadioStation(102.5f));

    for (auto& station : stations) {
        std::cout << std::fixed << std::setprecision(1)
                  << station.getFrequency() << std::endl;
    }
    // Output:
    // 89.0
    // 101.0
    // 102.5
    return 0;
}

class RadioStation(private val frequency: Float) {
    fun getFrequency(): Float = frequency
}

class StationList : Iterable<RadioStation> {
    private val stations = mutableListOf<RadioStation>()

    fun add(station: RadioStation) {
        stations.add(station)
    }

    override fun iterator(): Iterator<RadioStation> = stations.iterator()
}

// ----------------------------

fun main() {
    val stations = StationList()
    stations.add(RadioStation(89.0f))
    stations.add(RadioStation(101.0f))
    stations.add(RadioStation(102.5f))

    for (station in stations) {
        println(station.getFrequency())
    }
}

import 'dart:collection';

class RadioStation {
  final double _frequency;

  RadioStation(this._frequency);

  double getFrequency() => _frequency;
}

class StationIterator implements Iterator<RadioStation> {
  final List<RadioStation> _stations;
  int _position = -1;

  StationIterator(this._stations);

  @override
  RadioStation get current => _stations[_position];

  @override
  bool moveNext() {
    _position++;
    return _position < _stations.length;
  }
}

class StationList extends IterableBase<RadioStation> {
  final List<RadioStation> _stations = [];

  void add(RadioStation station) {
    _stations.add(station);
  }

  @override
  Iterator<RadioStation> get iterator => StationIterator(_stations);
}

// ----------------------------

void main() {
  var stations = StationList();
  stations.add(RadioStation(89.0));
  stations.add(RadioStation(101.0));
  stations.add(RadioStation(102.5));

  for (var station in stations) {
    print(station.getFrequency().toStringAsFixed(1));
  }
}

class ChatRoomMediator:
    def show_message(self, user, message):
        raise NotImplementedError


class ChatRoom(ChatRoomMediator):
    def show_message(self, user, message):
        print(user.get_name() + ': ' + message)


class User:
    def __init__(self, name, chat_room):
        self._name = name
        self._chat_room = chat_room

    def get_name(self):
        return self._name

    def send(self, message):
        self._chat_room.show_message(self, message)


# ----------------------------

mediator = ChatRoom()

john = User('John', mediator)
jane = User('Jane', mediator)

john.send('Hi there!')
jane.send('Hey!')

# Output:
# John: Hi there!
# Jane: Hey!

interface ChatRoomMediator {
    showMessage(user: User, message: string): void;
}

class ChatRoom implements ChatRoomMediator {
    showMessage(user: User, message: string): void {
        console.log(`${user.getName()}: ${message}`);
    }
}

class User {
    private name: string;
    private chatRoom: ChatRoomMediator;

    constructor(name: string, chatRoom: ChatRoomMediator) {
        this.name = name;
        this.chatRoom = chatRoom;
    }

    getName(): string {
        return this.name;
    }

    send(message: string): void {
        this.chatRoom.showMessage(this, message);
    }
}

// ----------------------------

const mediator = new ChatRoom();

const john = new User("John", mediator);
const jane = new User("Jane", mediator);

john.send("Hi there!");
jane.send("Hey!");

// Output:
// John: Hi there!
// Jane: Hey!

class ChatRoomMediator {
    showMessage(user, message) {
    }
}

class ChatRoom extends ChatRoomMediator {
    showMessage(user, message) {
        console.log(`${user.getName()}: ${message}`);
    }
}

class User {
    constructor(name, chatRoom) {
        this.name = name;
        this.chatRoom = chatRoom;
    }

    getName() {
        return this.name;
    }

    send(message) {
        this.chatRoom.showMessage(this, message);
    }
}

const mediator = new ChatRoom();

const john = new User("John", mediator);
const jane = new User("Jane", mediator);

john.send("Hi there!");
jane.send("Hey!");

// Output:
// John: Hi there!
// Jane: Hey!

using System;


interface IChatRoomMediator
{
  void ShowMessage(User user, string message);
}

// Mediator
class ChatRoom : IChatRoomMediator
{
  public void ShowMessage(User user, string message)
  {
    Console.WriteLine($"{user.GetName()}: {message}");
  }
}


class User
{
  private string mName;
  private IChatRoomMediator mChatRoom;

  public User(string name, IChatRoomMediator chatRoom)
  {
    mChatRoom = chatRoom;
    mName = name;
  }

  public string GetName()
  {
    return mName;
  }

  public void Send(string message)
  {
    mChatRoom.ShowMessage(this, message);
  }
}

// ----------------------------

var mediator = new ChatRoom();

var john = new User("John", mediator);
var jane = new User("Jane", mediator);

john.Send("Hi there!");
jane.Send("Hey!");

// Output:
// John: Hi there!
// Jane: Hey!

interface ChatRoomMediator
{
    public function showMessage(User $user, string $message): void;
}

class ChatRoom implements ChatRoomMediator
{
    public function showMessage(User $user, string $message): void
    {
        echo $user->getName() . ": " . $message . "\n";
    }
}

class User
{
    private $name;
    private $chatRoom;

    public function __construct(string $name, ChatRoomMediator $chatRoom)
    {
        $this->name = $name;
        $this->chatRoom = $chatRoom;
    }

    public function getName(): string
    {
        return $this->name;
    }

    public function send(string $message): void
    {
        $this->chatRoom->showMessage($this, $message);
    }
}

$mediator = new ChatRoom();

$john = new User("John", $mediator);
$jane = new User("Jane", $mediator);

$john->send("Hi there!");
$jane->send("Hey!");

// Output:
// John: Hi there!
// Jane: Hey!

package main

import "fmt"

type ChatRoomMediator interface {
	ShowMessage(user *User, message string)
}

type ChatRoom struct{}

func (cr *ChatRoom) ShowMessage(user *User, message string) {
	fmt.Printf("%s: %s\n", user.GetName(), message)
}

type User struct {
	Name     string
	ChatRoom ChatRoomMediator
}

func (u *User) GetName() string {
	return u.Name
}

func (u *User) Send(message string) {
	u.ChatRoom.ShowMessage(u, message)
}

func main() {
	mediator := &ChatRoom{}

	john := &User{Name: "John", ChatRoom: mediator}
	jane := &User{Name: "Jane", ChatRoom: mediator}

	john.Send("Hi there!")
	jane.Send("Hey!")

	// Output:
	// John: Hi there!
	// Jane: Hey!
}

interface ChatRoomMediator {
    void showMessage(User user, String message);
}

// Mediator
class ChatRoom implements ChatRoomMediator {

    @Override
    public void showMessage(User user, String message) {
        System.out.println(user.getName() + ": " + message);
    }
}

class User {
    private String name;
    private ChatRoomMediator chatRoom;

    public User(String name, ChatRoomMediator chatRoom) {
        this.chatRoom = chatRoom;
        this.name = name;
    }

    public String getName() {
        return name;
    }

    public void send(String message) {
        chatRoom.showMessage(this, message);
    }
}

// ----------------------------

ChatRoom mediator = new ChatRoom();

User john = new User("John", mediator);
User jane = new User("Jane", mediator);

john.send("Hi there!"); // John: Hi there!
jane.send("Hey!");      // Jane: Hey!

#include <iostream>
#include <string>

class User;

class ChatRoomMediator {
public:
    virtual ~ChatRoomMediator() = default;
    virtual void showMessage(User* user, const std::string& message) = 0;
};

class User {
private:
    std::string name;
    ChatRoomMediator* chatRoom;

public:
    User(const std::string& name, ChatRoomMediator* chatRoom)
        : name(name), chatRoom(chatRoom) {}

    std::string getName() const {
        return name;
    }

    void send(const std::string& message) {
        chatRoom->showMessage(this, message);
    }
};

class ChatRoom : public ChatRoomMediator {
public:
    void showMessage(User* user, const std::string& message) override {
        std::cout << user->getName() << ": " << message << std::endl;
    }
};

// ----------------------------

int main() {
    ChatRoom mediator;

    User john("John", &mediator);
    User jane("Jane", &mediator);

    john.send("Hi there!");
    jane.send("Hey!");
    return 0;
}

interface ChatRoomMediator {
    fun showMessage(user: User, message: String)
}

class ChatRoom : ChatRoomMediator {
    override fun showMessage(user: User, message: String) {
        println("${user.getName()}: $message")
    }
}

class User(private val name: String, private val chatRoom: ChatRoomMediator) {
    fun getName(): String = name

    fun send(message: String) {
        chatRoom.showMessage(this, message)
    }
}

// ----------------------------

fun main() {
    val mediator = ChatRoom()

    val john = User("John", mediator)
    val jane = User("Jane", mediator)

    john.send("Hi there!")
    jane.send("Hey!")
}

abstract class ChatRoomMediator {
  void showMessage(User user, String message);
}

class ChatRoom implements ChatRoomMediator {
  @override
  void showMessage(User user, String message) {
    print('${user.getName()}: $message');
  }
}

class User {
  final String _name;
  final ChatRoomMediator _chatRoom;

  User(this._name, this._chatRoom);

  String getName() => _name;

  void send(String message) {
    _chatRoom.showMessage(this, message);
  }
}

// ----------------------------

void main() {
  var mediator = ChatRoom();

  var john = User('John', mediator);
  var jane = User('Jane', mediator);

  john.send('Hi there!');
  jane.send('Hey!');
}

# Originator: حالت رو نگه می‌داره و memento می‌سازه/برمی‌گردونه.
class Editor:
    def __init__(self):
        self._content = ""

    def type(self, content):
        self._content = content

    def get_content(self):
        return self._content

    def save(self):
        return EditorMemento(self._content)

    def restore(self, memento):
        self._content = memento.get_content()


# Memento: یک snapshot غیرقابل‌تغییر از حالت ادیتور.
class EditorMemento:
    def __init__(self, content):
        self._content = content

    def get_content(self):
        return self._content


# Caretaker: memento ها رو توی یک stack نگه می‌داره، بدون اینکه داخلشون رو ببینه.
class History:
    def __init__(self):
        self._mementos = []

    def push(self, memento):
        self._mementos.append(memento)

    def pop(self):
        return self._mementos.pop()


# ----------------------------

editor = Editor()
history = History()

editor.type("a")
history.push(editor.save())

editor.type("ab")
history.push(editor.save())

editor.type("abc")

editor.restore(history.pop())
print(editor.get_content())  # ab

editor.restore(history.pop())
print(editor.get_content())  # a

// Memento: یک snapshot غیرقابل‌تغییر از حالت ادیتور.
class EditorMemento {
    private content: string;

    constructor(content: string) {
        this.content = content;
    }

    getContent(): string {
        return this.content;
    }
}

// Originator: حالت رو نگه می‌داره و memento می‌سازه/برمی‌گردونه.
class Editor {
    private content = "";

    type(content: string): void {
        this.content = content;
    }

    getContent(): string {
        return this.content;
    }

    save(): EditorMemento {
        return new EditorMemento(this.content);
    }

    restore(memento: EditorMemento): void {
        this.content = memento.getContent();
    }
}

// Caretaker: memento ها رو توی یک stack نگه می‌داره، بدون اینکه داخلشون رو ببینه.
class History {
    private mementos: EditorMemento[] = [];

    push(memento: EditorMemento): void {
        this.mementos.push(memento);
    }

    pop(): EditorMemento {
        return this.mementos.pop()!;
    }
}

// ----------------------------

const editor = new Editor();
const history = new History();

editor.type("a");
history.push(editor.save());

editor.type("ab");
history.push(editor.save());

editor.type("abc");

editor.restore(history.pop());
console.log(editor.getContent()); // ab

editor.restore(history.pop());
console.log(editor.getContent()); // a

// Memento: یک snapshot غیرقابل‌تغییر از حالت ادیتور.
class EditorMemento {
    constructor(content) {
        this.content = content;
    }

    getContent() {
        return this.content;
    }
}

// Originator: حالت رو نگه می‌داره و memento می‌سازه/برمی‌گردونه.
class Editor {
    constructor() {
        this.content = "";
    }

    type(content) {
        this.content = content;
    }

    getContent() {
        return this.content;
    }

    save() {
        return new EditorMemento(this.content);
    }

    restore(memento) {
        this.content = memento.getContent();
    }
}

// Caretaker: memento ها رو توی یک stack نگه می‌داره، بدون اینکه داخلشون رو ببینه.
class History {
    constructor() {
        this.mementos = [];
    }

    push(memento) {
        this.mementos.push(memento);
    }

    pop() {
        return this.mementos.pop();
    }
}

// ----------------------------

const editor = new Editor();
const history = new History();

editor.type("a");
history.push(editor.save());

editor.type("ab");
history.push(editor.save());

editor.type("abc");

editor.restore(history.pop());
console.log(editor.getContent()); // ab

editor.restore(history.pop());
console.log(editor.getContent()); // a

using System;
using System.Collections.Generic;

// Memento: یک snapshot غیرقابل‌تغییر از حالت ادیتور.
class EditorMemento
{
    private readonly string mContent;

    public EditorMemento(string content)
    {
        mContent = content;
    }

    public string Content
    {
        get { return mContent; }
    }
}

// Originator: حالت رو نگه می‌داره و memento می‌سازه/برمی‌گردونه.
class Editor
{
    private string mContent = string.Empty;

    public void Type(string words)
    {
        mContent = words;
    }

    public string Content
    {
        get { return mContent; }
    }

    public EditorMemento Save()
    {
        return new EditorMemento(mContent);
    }

    public void Restore(EditorMemento memento)
    {
        mContent = memento.Content;
    }
}

// Caretaker: memento ها رو توی یک stack نگه می‌داره، بدون اینکه داخلشون رو ببینه.
class History
{
    private readonly Stack<EditorMemento> mementos = new Stack<EditorMemento>();

    public void Push(EditorMemento memento)
    {
        mementos.Push(memento);
    }

    public EditorMemento Pop()
    {
        return mementos.Pop();
    }
}

// ----------------------------

var editor = new Editor();
var history = new History();

editor.Type("a");
history.Push(editor.Save());

editor.Type("ab");
history.Push(editor.Save());

editor.Type("abc");

editor.Restore(history.Pop());
Console.WriteLine(editor.Content); // ab

editor.Restore(history.Pop());
Console.WriteLine(editor.Content); // a

// Memento: یک snapshot غیرقابل‌تغییر از حالت ادیتور.
class EditorMemento
{
    private $content;

    public function __construct($content)
    {
        $this->content = $content;
    }

    public function getContent()
    {
        return $this->content;
    }
}

// Originator: حالت رو نگه می‌داره و memento می‌سازه/برمی‌گردونه.
class Editor
{
    private $content = '';

    public function type($words)
    {
        $this->content = $words;
    }

    public function getContent()
    {
        return $this->content;
    }

    public function save()
    {
        return new EditorMemento($this->content);
    }

    public function restore($memento)
    {
        $this->content = $memento->getContent();
    }
}

// Caretaker: memento ها رو توی یک stack نگه می‌داره، بدون اینکه داخلشون رو ببینه.
class History
{
    private $mementos = [];

    public function push($memento)
    {
        $this->mementos[] = $memento;
    }

    public function pop()
    {
        return array_pop($this->mementos);
    }
}

// ----------------------------

$editor = new Editor();
$history = new History();

$editor->type("a");
$history->push($editor->save());

$editor->type("ab");
$history->push($editor->save());

$editor->type("abc");

$editor->restore($history->pop());
echo $editor->getContent() . "\n"; // ab

$editor->restore($history->pop());
echo $editor->getContent() . "\n"; // a

import java.util.Deque;
import java.util.ArrayDeque;

// Memento: یک snapshot غیرقابل‌تغییر از حالت ادیتور.
class EditorMemento {
    private final String content;

    public EditorMemento(String content) {
        this.content = content;
    }

    public String getContent() {
        return this.content;
    }
}

// Originator: حالت رو نگه می‌داره و memento می‌سازه/برمی‌گردونه.
class Editor {
    private String content = "";

    public void type(String words) {
        this.content = words;
    }

    public String getContent() {
        return this.content;
    }

    public EditorMemento save() {
        return new EditorMemento(this.content);
    }

    public void restore(EditorMemento memento) {
        this.content = memento.getContent();
    }
}

// Caretaker: memento ها رو توی یک stack نگه می‌داره، بدون اینکه داخلشون رو ببینه.
class History {
    private final Deque<EditorMemento> mementos = new ArrayDeque<>();

    public void push(EditorMemento memento) {
        mementos.push(memento);
    }

    public EditorMemento pop() {
        return mementos.pop();
    }
}

public class Main {
    public static void main(String[] args) {
        Editor editor = new Editor();
        History history = new History();

        editor.type("a");
        history.push(editor.save());

        editor.type("ab");
        history.push(editor.save());

        editor.type("abc");

        editor.restore(history.pop());
        System.out.println(editor.getContent()); // ab

        editor.restore(history.pop());
        System.out.println(editor.getContent()); // a
    }
}

package main

import "fmt"

// Memento: یک snapshot غیرقابل‌تغییر از حالت ادیتور.
type EditorMemento struct {
	content string
}

func NewEditorMemento(content string) *EditorMemento {
	return &EditorMemento{content: content}
}

func (m *EditorMemento) GetContent() string {
	return m.content
}

// Originator: حالت رو نگه می‌داره و memento می‌سازه/برمی‌گردونه.
type Editor struct {
	content string
}

func (e *Editor) Type(content string) {
	e.content = content
}

func (e *Editor) GetContent() string {
	return e.content
}

func (e *Editor) Save() *EditorMemento {
	return NewEditorMemento(e.content)
}

func (e *Editor) Restore(memento *EditorMemento) {
	e.content = memento.GetContent()
}

// Caretaker: memento ها رو توی یک stack نگه می‌داره، بدون اینکه داخلشون رو ببینه.
type History struct {
	mementos []*EditorMemento
}

func (h *History) Push(memento *EditorMemento) {
	h.mementos = append(h.mementos, memento)
}

func (h *History) Pop() *EditorMemento {
	last := len(h.mementos) - 1
	memento := h.mementos[last]
	h.mementos = h.mementos[:last]
	return memento
}

// ----------------------------

func main() {
	editor := &Editor{}
	history := &History{}

	editor.Type("a")
	history.Push(editor.Save())

	editor.Type("ab")
	history.Push(editor.Save())

	editor.Type("abc")

	editor.Restore(history.Pop())
	fmt.Println(editor.GetContent()) // ab

	editor.Restore(history.Pop())
	fmt.Println(editor.GetContent()) // a
}

#include <iostream>
#include <string>
#include <vector>

// Memento: یک snapshot غیرقابل‌تغییر از حالت ادیتور.
class EditorMemento {
private:
    std::string content;

public:
    EditorMemento(const std::string& c) : content(c) {}

    std::string getContent() const {
        return content;
    }
};

// Originator: حالت رو نگه می‌داره و memento می‌سازه/برمی‌گردونه.
class Editor {
private:
    std::string content;

public:
    void type(const std::string& words) {
        content = words;
    }

    std::string getContent() const {
        return content;
    }

    EditorMemento save() const {
        return EditorMemento(content);
    }

    void restore(const EditorMemento& memento) {
        content = memento.getContent();
    }
};

// Caretaker: memento ها رو توی یک stack نگه می‌داره، بدون اینکه داخلشون رو ببینه.
class History {
private:
    std::vector<EditorMemento> mementos;

public:
    void push(const EditorMemento& memento) {
        mementos.push_back(memento);
    }

    EditorMemento pop() {
        EditorMemento memento = mementos.back();
        mementos.pop_back();
        return memento;
    }
};

// ----------------------------

int main() {
    Editor editor;
    History history;

    editor.type("a");
    history.push(editor.save());

    editor.type("ab");
    history.push(editor.save());

    editor.type("abc");

    editor.restore(history.pop());
    std::cout << editor.getContent() << std::endl; // ab

    editor.restore(history.pop());
    std::cout << editor.getContent() << std::endl; // a
    return 0;
}

// Originator: حالت رو نگه می‌داره و memento می‌سازه/برمی‌گردونه.
class Editor {
    private var content: String = ""

    fun type(content: String) {
        this.content = content
    }

    fun getContent(): String = content

    fun save(): EditorMemento = EditorMemento(content)

    fun restore(memento: EditorMemento) {
        content = memento.getContent()
    }
}

// Memento: یک snapshot غیرقابل‌تغییر از حالت ادیتور.
class EditorMemento(private val content: String) {
    fun getContent(): String = content
}

// Caretaker: memento ها رو توی یک stack نگه می‌داره، بدون اینکه داخلشون رو ببینه.
class History {
    private val mementos = ArrayDeque<EditorMemento>()

    fun push(memento: EditorMemento) {
        mementos.addLast(memento)
    }

    fun pop(): EditorMemento = mementos.removeLast()
}

// ----------------------------

fun main() {
    val editor = Editor()
    val history = History()

    editor.type("a")
    history.push(editor.save())

    editor.type("ab")
    history.push(editor.save())

    editor.type("abc")

    editor.restore(history.pop())
    println(editor.getContent())

    editor.restore(history.pop())
    println(editor.getContent())
}

// Originator: حالت رو نگه می‌داره و memento می‌سازه/برمی‌گردونه.
class Editor {
  String _content = '';

  void type(String content) {
    _content = content;
  }

  String getContent() => _content;

  EditorMemento save() => EditorMemento(_content);

  void restore(EditorMemento memento) {
    _content = memento.getContent();
  }
}

// Memento: یک snapshot غیرقابل‌تغییر از حالت ادیتور.
class EditorMemento {
  final String _content;

  EditorMemento(this._content);

  String getContent() => _content;
}

// Caretaker: memento ها رو توی یک stack نگه می‌داره، بدون اینکه داخلشون رو ببینه.
class History {
  final List<EditorMemento> _mementos = [];

  void push(EditorMemento memento) {
    _mementos.add(memento);
  }

  EditorMemento pop() => _mementos.removeLast();
}

// ----------------------------

void main() {
  var editor = Editor();
  var history = History();

  editor.type('a');
  history.push(editor.save());

  editor.type('ab');
  history.push(editor.save());

  editor.type('abc');

  editor.restore(history.pop());
  print(editor.getContent());

  editor.restore(history.pop());
  print(editor.getContent());
}

class JobPost:
    def __init__(self, title):
        self.title = title

    def getTitle(self):
        return self.title


class JobSeeker:
    def __init__(self, name):
        self.name = name

    def onJobPosted(self, job):
        print('Hi ' + self.name + '! New job posted: ' + job.getTitle())


class EmploymentAgency:
    def __init__(self):
        self.observers = []

    def notify(self, jobPosting):
        for observer in self.observers:
            observer.onJobPosted(jobPosting)

    def attach(self, observer):
        self.observers.append(observer)

    def addJob(self, jobPosting):
        self.notify(jobPosting)


# ----------------------------

johnDoe = JobSeeker('John Doe')
janeDoe = JobSeeker('Jane Doe')

jobPostings = EmploymentAgency()
jobPostings.attach(johnDoe)
jobPostings.attach(janeDoe)

jobPostings.addJob(JobPost('Software Engineer'))

# Output
# Hi John Doe! New job posted: Software Engineer
# Hi Jane Doe! New job posted: Software Engineer

class JobPost {
    private title: string;

    constructor(title: string) {
        this.title = title;
    }

    getTitle(): string {
        return this.title;
    }
}

class JobSeeker {
    private name: string;

    constructor(name: string) {
        this.name = name;
    }

    onJobPosted(job: JobPost): void {
        console.log(`Hi ${this.name}! New job posted: ${job.getTitle()}`);
    }
}

class EmploymentAgency {
    private observers: JobSeeker[] = [];

    notify(jobPosting: JobPost): void {
        for (const observer of this.observers) {
            observer.onJobPosted(jobPosting);
        }
    }

    attach(observer: JobSeeker): void {
        this.observers.push(observer);
    }

    addJob(jobPosting: JobPost): void {
        this.notify(jobPosting);
    }
}

// ----------------------------

const johnDoe = new JobSeeker("John Doe");
const janeDoe = new JobSeeker("Jane Doe");

const jobPostings = new EmploymentAgency();
jobPostings.attach(johnDoe);
jobPostings.attach(janeDoe);

jobPostings.addJob(new JobPost("Software Engineer"));

// Output
// Hi John Doe! New job posted: Software Engineer
// Hi Jane Doe! New job posted: Software Engineer

class JobPost {
    constructor(title) {
        this.title = title;
    }

    getTitle() {
        return this.title;
    }
}

class JobSeeker {
    constructor(name) {
        this.name = name;
    }

    onJobPosted(job) {
        console.log(`Hi ${this.name}! New job posted: ${job.getTitle()}`);
    }
}

class EmploymentAgency {
    constructor() {
        this.observers = [];
    }

    notify(jobPosting) {
        for (const observer of this.observers) {
            observer.onJobPosted(jobPosting);
        }
    }

    attach(observer) {
        this.observers.push(observer);
    }

    addJob(jobPosting) {
        this.notify(jobPosting);
    }
}


const johnDoe = new JobSeeker("John Doe");
const janeDoe = new JobSeeker("Jane Doe");

const jobPostings = new EmploymentAgency();
jobPostings.attach(johnDoe);
jobPostings.attach(janeDoe);

jobPostings.addJob(new JobPost("Software Engineer"));

// Output
// Hi John Doe! New job posted: Software Engineer
// Hi Jane Doe! New job posted: Software Engineer

using System;
using System.Collections.Generic;


class JobPost
{
  public string Title { get; private set; }

  public JobPost(string title)
  {
    Title = title;
  }
}
class JobSeeker : IObserver<JobPost>
{
  public string Name { get; private set; }

  public JobSeeker(string name)
  {
    Name = name;
  }

  //Method is not being called by EmploymentAgency class currently
  public void OnCompleted()
  {
    //No Implementation
  }

  //Method is not being called by EmploymentAgency class currently
  public void OnError(Exception error)
  {
    //No Implementation
  }

  public void OnNext(JobPost value)
  {
    Console.WriteLine($"Hi {Name}! New job posted: {value.Title}");
  }
}


class EmploymentAgency : IObservable<JobPost>
{
  private List<IObserver<JobPost>> mObservers;
  private List<JobPost> mJobPostings;

  public EmploymentAgency()
  {
    mObservers = new List<IObserver<JobPost>>();
    mJobPostings = new List<JobPost>();
  }

  public IDisposable Subscribe(IObserver<JobPost> observer)
  {
    // Check whether observer is already registered. If not, add it
    if (!mObservers.Contains(observer))
    {
      mObservers.Add(observer);
    }
    return new Unsubscriber<JobPost>(mObservers, observer);
  }

  private void Notify(JobPost jobPost)
  {
    foreach(var observer in mObservers)
    {
      observer.OnNext(jobPost);
    }
  }

  public void AddJob(JobPost jobPost)
  {
    mJobPostings.Add(jobPost);
    Notify(jobPost);
  }

}

internal class Unsubscriber<JobPost> : IDisposable
{
  private List<IObserver<JobPost>> mObservers;
  private IObserver<JobPost> mObserver;

  internal Unsubscriber(List<IObserver<JobPost>> observers, IObserver<JobPost> observer)
  {
    this.mObservers = observers;
    this.mObserver = observer;
  }

  public void Dispose()
  {
    if (mObservers.Contains(mObserver))
      mObservers.Remove(mObserver);
  }
}

// ----------------------------

//Create Subscribers
var johnDoe = new JobSeeker("John Doe");
var janeDoe = new JobSeeker("Jane Doe");

//Create publisher and attach subscribers
var jobPostings = new EmploymentAgency();
jobPostings.Subscribe(johnDoe);
jobPostings.Subscribe(janeDoe);

//Add a new job and see if subscribers get notified
jobPostings.AddJob(new JobPost("Software Engineer"));

//Output
// Hi John Doe! New job posted: Software Engineer
// Hi Jane Doe! New job posted: Software Engineer

Console.ReadLine();

interface ObserverInterface
{
    public function onJobPosted(JobPost $job): void;
}

class JobPost
{
    public function __construct(private string $title)
    {
    }

    public function getTitle(): string
    {
        return $this->title;
    }
}

class JobSeeker implements ObserverInterface
{
    public function __construct(private string $name)
    {
    }

    public function onJobPosted(JobPost $job): void
    {
        echo "Hi {$this->name}! New job posted: {$job->getTitle()}
";
    }
}

class EmploymentAgency
{
    private array $observers = [];

    public function attach(ObserverInterface $observer): void
    {
        $this->observers[] = $observer;
    }

    public function notify(JobPost $jobPosting): void
    {
        foreach ($this->observers as $observer) {
            $observer->onJobPosted($jobPosting);
        }
    }

    public function addJob(JobPost $jobPosting): void
    {
        $this->notify($jobPosting);
    }
}

// ----------------------------

$johnDoe = new JobSeeker("John Doe");
$janeDoe = new JobSeeker("Jane Doe");

$jobPostings = new EmploymentAgency();
$jobPostings->attach($johnDoe);
$jobPostings->attach($janeDoe);

$jobPostings->addJob(new JobPost("Software Engineer"));

// Output:
// Hi John Doe! New job posted: Software Engineer
// Hi Jane Doe! New job posted: Software Engineer

package main

import "fmt"

type JobPost struct {
	title string
}

func NewJobPost(title string) *JobPost {
	return &JobPost{title: title}
}

func (jp *JobPost) GetTitle() string {
	return jp.title
}

type JobSeeker struct {
	name string
}

func NewJobSeeker(name string) *JobSeeker {
	return &JobSeeker{name: name}
}

func (js *JobSeeker) OnJobPosted(job *JobPost) {
	fmt.Printf("Hi %s! New job posted: %s\n", js.name, job.GetTitle())
}

type EmploymentAgency struct {
	observers []*JobSeeker
}

func NewEmploymentAgency() *EmploymentAgency {
	return &EmploymentAgency{}
}

func (ea *EmploymentAgency) Notify(jobPosting *JobPost) {
	for _, observer := range ea.observers {
		observer.OnJobPosted(jobPosting)
	}
}

func (ea *EmploymentAgency) Attach(observer *JobSeeker) {
	ea.observers = append(ea.observers, observer)
}

func (ea *EmploymentAgency) AddJob(jobPosting *JobPost) {
	ea.Notify(jobPosting)
}

func main() {
	johnDoe := NewJobSeeker("John Doe")
	janeDoe := NewJobSeeker("Jane Doe")

	jobPostings := NewEmploymentAgency()
	jobPostings.Attach(johnDoe)
	jobPostings.Attach(janeDoe)

	jobPostings.AddJob(NewJobPost("Software Engineer"))

	// Output
	// Hi John Doe! New job posted: Software Engineer
	// Hi Jane Doe! New job posted: Software Engineer
}

import java.util.*;

class JobPost {
    private String title;

    public JobPost(String title) {
        this.title = title;
    }

    public String getTitle() {
        return this.title;
    }
}

class JobSeeker {
    private String name;

    public JobSeeker(String name) {
        this.name = name;
    }

    public void onJobPosted(JobPost job) {
        System.out.println("Hi " + this.name + "! New job posted: " + job.getTitle());
    }
}

class EmploymentAgency {
    private List<JobSeeker> observers = new ArrayList<>();

    public void notify(JobPost jobPosting) {
        for (JobSeeker observer : this.observers) {
            observer.onJobPosted(jobPosting);
        }
    }

    public void attach(JobSeeker observer) {
        this.observers.add(observer);
    }

    public void addJob(JobPost jobPosting) {
        this.notify(jobPosting);
    }
}

// ----------------------------

JobSeeker johnDoe = new JobSeeker("John Doe");
JobSeeker janeDoe = new JobSeeker("Jane Doe");

EmploymentAgency jobPostings = new EmploymentAgency();
jobPostings.attach(johnDoe);
jobPostings.attach(janeDoe);

jobPostings.addJob(new JobPost("Software Engineer"));
// Hi John Doe! New job posted: Software Engineer
// Hi Jane Doe! New job posted: Software Engineer

#include <iostream>
#include <string>
#include <vector>
#include <memory>
#include <algorithm>

// Job post class
class JobPost {
private:
    std::string title;

public:
    JobPost(const std::string& title) : title(title) {}
    
    std::string getTitle() const {
        return title;
    }
};

// Observer interface
class JobSeeker {
private:
    std::string name;

public:
    JobSeeker(const std::string& name) : name(name) {}
    
    void onJobPosted(const JobPost& job) {
        std::cout << "Hi " << name << "! New job posted: " << job.getTitle() << std::endl;
    }
    
    std::string getName() const {
        return name;
    }
};

// Subject class
class EmploymentAgency {
private:
    std::vector<std::shared_ptr<JobSeeker>> observers;

public:
    void attach(std::shared_ptr<JobSeeker> observer) {
        observers.push_back(observer);
    }
    
    void detach(std::shared_ptr<JobSeeker> observer) {
        observers.erase(
            std::remove(observers.begin(), observers.end(), observer),
            observers.end()
        );
    }
    
    void notify(const JobPost& jobPosting) {
        for (auto& observer : observers) {
            observer->onJobPosted(jobPosting);
        }
    }
    
    void addJob(const JobPost& jobPosting) {
        notify(jobPosting);
    }
};

// Usage
int main() {
    auto johnDoe = std::make_shared<JobSeeker>("John Doe");
    auto janeDoe = std::make_shared<JobSeeker>("Jane Doe");
    
    EmploymentAgency jobPostings;
    jobPostings.attach(johnDoe);
    jobPostings.attach(janeDoe);
    
    jobPostings.addJob(JobPost("Software Engineer"));
    // Hi John Doe! New job posted: Software Engineer
    // Hi Jane Doe! New job posted: Software Engineer
    
    return 0;
}

class JobPost(private val title: String) {
    fun getTitle(): String = title
}

class JobSeeker(private val name: String) {
    fun onJobPosted(job: JobPost) {
        println("Hi $name! New job posted: ${job.getTitle()}")
    }
}

class EmploymentAgency {
    private val observers = mutableListOf<JobSeeker>()

    fun notify(jobPosting: JobPost) {
        for (observer in observers) {
            observer.onJobPosted(jobPosting)
        }
    }

    fun attach(observer: JobSeeker) {
        observers.add(observer)
    }

    fun addJob(jobPosting: JobPost) {
        notify(jobPosting)
    }
}

// ----------------------------

fun main() {
    val johnDoe = JobSeeker("John Doe")
    val janeDoe = JobSeeker("Jane Doe")

    val jobPostings = EmploymentAgency()
    jobPostings.attach(johnDoe)
    jobPostings.attach(janeDoe)

    jobPostings.addJob(JobPost("Software Engineer"))
}

class JobPost {
  final String _title;

  JobPost(this._title);

  String getTitle() => _title;
}

class JobSeeker {
  final String _name;

  JobSeeker(this._name);

  void onJobPosted(JobPost job) {
    print('Hi $_name! New job posted: ${job.getTitle()}');
  }
}

class EmploymentAgency {
  final List<JobSeeker> _observers = [];

  void notify(JobPost jobPosting) {
    for (var observer in _observers) {
      observer.onJobPosted(jobPosting);
    }
  }

  void attach(JobSeeker observer) {
    _observers.add(observer);
  }

  void addJob(JobPost jobPosting) {
    notify(jobPosting);
  }
}

// ----------------------------

void main() {
  var johnDoe = JobSeeker('John Doe');
  var janeDoe = JobSeeker('Jane Doe');

  var jobPostings = EmploymentAgency();
  jobPostings.attach(johnDoe);
  jobPostings.attach(janeDoe);

  jobPostings.addJob(JobPost('Software Engineer'));
}

# Visitee
class Animal:
    def accept(self, operation):
        pass


# Visitor
class AnimalOperation:
    def visitMonkey(self, monkey):
        pass

    def visitLion(self, lion):
        pass

    def visitDolphin(self, dolphin):
        pass


class Monkey(Animal):
    def shout(self):
        print('Ooh oo aa aa!')

    def accept(self, operation):
        operation.visitMonkey(self)


class Lion(Animal):
    def roar(self):
        print('Roaaar!')

    def accept(self, operation):
        operation.visitLion(self)


class Dolphin(Animal):
    def speak(self):
        print('Tuut tuttu tuutt!')

    def accept(self, operation):
        operation.visitDolphin(self)


class Speak(AnimalOperation):
    def visitMonkey(self, monkey):
        monkey.shout()

    def visitLion(self, lion):
        lion.roar()

    def visitDolphin(self, dolphin):
        dolphin.speak()


class Jump(AnimalOperation):
    def visitMonkey(self, monkey):
        print('Jumped 20 feet high! on to the tree!')

    def visitLion(self, lion):
        print('Jumped 7 feet! back on the ground!')

    def visitDolphin(self, dolphin):
        print('Walked on water a little and disappeared')


monkey = Monkey()
lion = Lion()
dolphin = Dolphin()

speak = Speak()
jump = Jump()

monkey.accept(speak)   # Ooh oo aa aa!
lion.accept(speak)     # Roaaar!
dolphin.accept(speak)  # Tuut tuttu tuutt!

monkey.accept(jump)    # Jumped 20 feet high! on to the tree!
lion.accept(jump)      # Jumped 7 feet! back on the ground!
dolphin.accept(jump)   # Walked on water a little and disappeared

interface AnimalOperation {
  visitMonkey(monkey: Monkey): void;
  visitLion(lion: Lion): void;
  visitDolphin(dolphin: Dolphin): void;
}

interface Animal {
  accept(operation: AnimalOperation): void;
}

class Monkey implements Animal {
  shout() {
    console.log("Ooh oo aa aa!");
  }

  accept(operation: AnimalOperation): void {
    operation.visitMonkey(this);
  }
}

class Lion implements Animal {
  roar() {
    console.log("Roaaar!");
  }

  accept(operation: AnimalOperation): void {
    operation.visitLion(this);
  }
}

class Dolphin implements Animal {
  speak() {
    console.log("Tuut tuttu tuutt!");
  }

  accept(operation: AnimalOperation): void {
    operation.visitDolphin(this);
  }
}

class Speak implements AnimalOperation {
  visitMonkey(monkey: Monkey): void {
    monkey.shout();
  }

  visitLion(lion: Lion): void {
    lion.roar();
  }

  visitDolphin(dolphin: Dolphin): void {
    dolphin.speak();
  }
}

class Jump implements AnimalOperation {
  visitMonkey(monkey: Monkey): void {
    console.log("Jumped 20 feet high! on to the tree!");
  }

  visitLion(lion: Lion): void {
    console.log("Jumped 7 feet! back on the ground!");
  }

  visitDolphin(dolphin: Dolphin): void {
    console.log("Walked on water a little and disappeared");
  }
}

const monkey = new Monkey();
const lion = new Lion();
const dolphin = new Dolphin();

const speak = new Speak();
const jump = new Jump();

monkey.accept(speak);   // Ooh oo aa aa!
lion.accept(speak);     // Roaaar!
dolphin.accept(speak);  // Tuut tuttu tuutt!

monkey.accept(jump);    // Jumped 20 feet high! on to the tree!
lion.accept(jump);      // Jumped 7 feet! back on the ground!
dolphin.accept(jump);   // Walked on water a little and disappeared

class Monkey {
    shout() {
        console.log("Ooh oo aa aa!");
    }

    accept(operation) {
        operation.visitMonkey(this);
    }
}

class Lion {
    roar() {
        console.log("Roaaar!");
    }

    accept(operation) {
        operation.visitLion(this);
    }
}

class Dolphin {
    speak() {
        console.log("Tuut tuttu tuutt!");
    }

    accept(operation) {
        operation.visitDolphin(this);
    }
}

class Speak {
    visitMonkey(monkey) {
        monkey.shout();
    }

    visitLion(lion) {
        lion.roar();
    }

    visitDolphin(dolphin) {
        dolphin.speak();
    }
}

class Jump {
    visitMonkey(monkey) {
        console.log("Jumped 20 feet high! on to the tree!");
    }

    visitLion(lion) {
        console.log("Jumped 7 feet! back on the ground!");
    }

    visitDolphin(dolphin) {
        console.log("Walked on water a little and disappeared");
    }
}

const monkey = new Monkey();
const lion = new Lion();
const dolphin = new Dolphin();

const speak = new Speak();
const jump = new Jump();

monkey.accept(speak);   // Ooh oo aa aa!
lion.accept(speak);     // Roaaar!
dolphin.accept(speak);  // Tuut tuttu tuutt!

monkey.accept(jump);    // Jumped 20 feet high! on to the tree!
lion.accept(jump);      // Jumped 7 feet! back on the ground!
dolphin.accept(jump);   // Walked on water a little and disappeared

using System;

// Visitee
interface IAnimal
{
  void Accept(IAnimalOperation operation);
}

// Visitor
interface IAnimalOperation
{
  void VisitMonkey(Monkey monkey);
  void VisitLion(Lion lion);
  void VisitDolphin(Dolphin dolphin);
}

class Monkey : IAnimal
{
  public void Shout()
  {
    Console.WriteLine("Ooh oo aa aa!");
  }

  public void Accept(IAnimalOperation operation)
  {
    operation.VisitMonkey(this);
  }
}

class Lion : IAnimal
{
  public void Roar()
  {
    Console.WriteLine("Roaaar!");
  }

  public void Accept(IAnimalOperation operation)
  {
    operation.VisitLion(this);
  }
}

class Dolphin : IAnimal
{
  public void Speak()
  {
    Console.WriteLine("Tuut tuttu tuutt!");
  }

  public void Accept(IAnimalOperation operation)
  {
    operation.VisitDolphin(this);
  }
}

class Speak : IAnimalOperation
{
  public void VisitMonkey(Monkey monkey)
  {
    monkey.Shout();
  }

  public void VisitLion(Lion lion)
  {
    lion.Roar();
  }

  public void VisitDolphin(Dolphin dolphin)
  {
    dolphin.Speak();
  }
}

class Jump : IAnimalOperation
{
  public void VisitMonkey(Monkey monkey)
  {
    Console.WriteLine("Jumped 20 feet high! on to the tree!");
  }

  public void VisitLion(Lion lion)
  {
    Console.WriteLine("Jumped 7 feet! back on the ground!");
  }

  public void VisitDolphin(Dolphin dolphin)
  {
    Console.WriteLine("Walked on water a little and disappeared");
  }
}

// ----------------------------

var monkey = new Monkey();
var lion = new Lion();
var dolphin = new Dolphin();

var speak = new Speak();
var jump = new Jump();

monkey.Accept(speak);    // Ooh oo aa aa!
lion.Accept(speak);      // Roaaar!
dolphin.Accept(speak);   // Tuut tuttu tuutt!

monkey.Accept(jump);     // Jumped 20 feet high! on to the tree!
lion.Accept(jump);       // Jumped 7 feet! back on the ground!
dolphin.Accept(jump);    // Walked on water a little and disappeared

// Visitee
interface AnimalInterface
{
  public function accept(AnimalOperationInterface $operation);
}

// Visitor
interface AnimalOperationInterface
{
  public function visitMonkey(Monkey $monkey);
  public function visitLion(Lion $lion);
  public function visitDolphin(Dolphin $dolphin);
}

class Monkey implements AnimalInterface
{
  public function shout()
  {
    echo "Ooh oo aa aa!\n";
  }

  public function accept(AnimalOperationInterface $operation)
  {
    $operation->visitMonkey($this);
  }
}

class Lion implements AnimalInterface
{
  public function roar()
  {
    echo "Roaaar!\n";
  }

  public function accept(AnimalOperationInterface $operation)
  {
    $operation->visitLion($this);
  }
}

class Dolphin implements AnimalInterface
{
  public function speak()
  {
    echo "Tuut tuttu tuutt!\n";
  }

  public function accept(AnimalOperationInterface $operation)
  {
    $operation->visitDolphin($this);
  }
}

class Speak implements AnimalOperationInterface
{
  public function visitMonkey(Monkey $monkey)
  {
    $monkey->shout();
  }

  public function visitLion(Lion $lion)
  {
    $lion->roar();
  }

  public function visitDolphin(Dolphin $dolphin)
  {
    $dolphin->speak();
  }
}

class Jump implements AnimalOperationInterface
{
  public function visitMonkey(Monkey $monkey)
  {
    echo "Jumped 20 feet high! on to the tree!\n";
  }

  public function visitLion(Lion $lion)
  {
    echo "Jumped 7 feet! back on the ground!\n";
  }

  public function visitDolphin(Dolphin $dolphin)
  {
    echo "Walked on water a little and disappeared\n";
  }
}

$monkey = new Monkey();
$lion = new Lion();
$dolphin = new Dolphin();

$speak = new Speak();
$jump = new Jump();

$monkey->accept($speak);    // Ooh oo aa aa!
$lion->accept($speak);      // Roaaar!
$dolphin->accept($speak);   // Tuut tuttu tuutt!

$monkey->accept($jump);     // Jumped 20 feet high! on to the tree!
$lion->accept($jump);       // Jumped 7 feet! back on the ground!
$dolphin->accept($jump);    // Walked on water a little and disappeared

package main

import "fmt"

// Visitee
type Animal interface {
	Accept(operation AnimalOperation)
}

// Visitor
type AnimalOperation interface {
	VisitMonkey(monkey *Monkey)
	VisitLion(lion *Lion)
	VisitDolphin(dolphin *Dolphin)
}

type Monkey struct{}

func (m *Monkey) Shout() {
	fmt.Println("Ooh oo aa aa!")
}

func (m *Monkey) Accept(operation AnimalOperation) {
	operation.VisitMonkey(m)
}

type Lion struct{}

func (l *Lion) Roar() {
	fmt.Println("Roaaar!")
}

func (l *Lion) Accept(operation AnimalOperation) {
	operation.VisitLion(l)
}

type Dolphin struct{}

func (d *Dolphin) Speak() {
	fmt.Println("Tuut tuttu tuutt!")
}

func (d *Dolphin) Accept(operation AnimalOperation) {
	operation.VisitDolphin(d)
}

type Speak struct{}

func (s *Speak) VisitMonkey(monkey *Monkey) {
	monkey.Shout()
}

func (s *Speak) VisitLion(lion *Lion) {
	lion.Roar()
}

func (s *Speak) VisitDolphin(dolphin *Dolphin) {
	dolphin.Speak()
}

type Jump struct{}

func (j *Jump) VisitMonkey(monkey *Monkey) {
	fmt.Println("Jumped 20 feet high! on to the tree!")
}

func (j *Jump) VisitLion(lion *Lion) {
	fmt.Println("Jumped 7 feet! back on the ground!")
}

func (j *Jump) VisitDolphin(dolphin *Dolphin) {
	fmt.Println("Walked on water a little and disappeared")
}

func main() {
	monkey := &Monkey{}
	lion := &Lion{}
	dolphin := &Dolphin{}

	speak := &Speak{}
	jump := &Jump{}

	monkey.Accept(speak)  // Ooh oo aa aa!
	lion.Accept(speak)    // Roaaar!
	dolphin.Accept(speak) // Tuut tuttu tuutt!

	monkey.Accept(jump)  // Jumped 20 feet high! on to the tree!
	lion.Accept(jump)    // Jumped 7 feet! back on the ground!
	dolphin.Accept(jump) // Walked on water a little and disappeared
}

interface AnimalOperation {
    void visitMonkey(Monkey monkey);
    void visitLion(Lion lion);
    void visitDolphin(Dolphin dolphin);
}

interface Animal {
    void accept(AnimalOperation operation);
}

class Monkey implements Animal {
    public void shout() {
        System.out.println("Ooh oo aa aa!");
    }

    @Override
    public void accept(AnimalOperation operation) {
        operation.visitMonkey(this);
    }
}

class Lion implements Animal {
    public void roar() {
        System.out.println("Roaaar!");
    }

    @Override
    public void accept(AnimalOperation operation) {
        operation.visitLion(this);
    }
}

class Dolphin implements Animal {
    public void speak() {
        System.out.println("Tuut tuttu tuutt!");
    }

    @Override
    public void accept(AnimalOperation operation) {
        operation.visitDolphin(this);
    }
}

class Speak implements AnimalOperation {
    @Override
    public void visitMonkey(Monkey monkey) {
        monkey.shout();
    }

    @Override
    public void visitLion(Lion lion) {
        lion.roar();
    }

    @Override
    public void visitDolphin(Dolphin dolphin) {
        dolphin.speak();
    }
}

class Jump implements AnimalOperation {
    @Override
    public void visitMonkey(Monkey monkey) {
        System.out.println("Jumped 20 feet high! on to the tree!");
    }

    @Override
    public void visitLion(Lion lion) {
        System.out.println("Jumped 7 feet! back on the ground!");
    }

    @Override
    public void visitDolphin(Dolphin dolphin) {
        System.out.println("Walked on water a little and disappeared");
    }
}

// -----------------------

Monkey monkey = new Monkey();
Lion lion = new Lion();
Dolphin dolphin = new Dolphin();

Speak speak = new Speak();
Jump jump = new Jump();

monkey.accept(speak);   // Ooh oo aa aa!
lion.accept(speak);     // Roaaar!
dolphin.accept(speak);  // Tuut tuttu tuutt!

monkey.accept(jump);    // Jumped 20 feet high! on to the tree!
lion.accept(jump);      // Jumped 7 feet! back on the ground!
dolphin.accept(jump);   // Walked on water a little and disappeared

#include <iostream>

// Forward declarations
class Monkey;
class Lion;
class Dolphin;

// Visitor interface
class AnimalOperation {
public:
    virtual ~AnimalOperation() = default;
    virtual void visitMonkey(Monkey& monkey) = 0;
    virtual void visitLion(Lion& lion) = 0;
    virtual void visitDolphin(Dolphin& dolphin) = 0;
};

// Animal interface
class Animal {
public:
    virtual ~Animal() = default;
    virtual void accept(AnimalOperation& operation) = 0;
};

// Concrete animals
class Monkey : public Animal {
public:
    void shout() {
        std::cout << "Ooh oo aa aa!" << std::endl;
    }

    void accept(AnimalOperation& operation) override {
        operation.visitMonkey(*this);
    }
};

class Lion : public Animal {
public:
    void roar() {
        std::cout << "Roaaar!" << std::endl;
    }

    void accept(AnimalOperation& operation) override {
        operation.visitLion(*this);
    }
};

class Dolphin : public Animal {
public:
    void speak() {
        std::cout << "Tuut tuttu tuutt!" << std::endl;
    }

    void accept(AnimalOperation& operation) override {
        operation.visitDolphin(*this);
    }
};

// Concrete visitor: Speak
class Speak : public AnimalOperation {
public:
    void visitMonkey(Monkey& monkey) override {
        monkey.shout();
    }

    void visitLion(Lion& lion) override {
        lion.roar();
    }

    void visitDolphin(Dolphin& dolphin) override {
        dolphin.speak();
    }
};

// Concrete visitor: Jump
class Jump : public AnimalOperation {
public:
    void visitMonkey(Monkey& monkey) override {
        std::cout << "Jumped 20 feet high! on to the tree!" << std::endl;
    }

    void visitLion(Lion& lion) override {
        std::cout << "Jumped 7 feet! back on the ground!" << std::endl;
    }

    void visitDolphin(Dolphin& dolphin) override {
        std::cout << "Walked on water a little and disappeared" << std::endl;
    }
};

// ----------------------------

int main() {
    Monkey monkey;
    Lion lion;
    Dolphin dolphin;

    Speak speak;
    Jump jump;

    monkey.accept(speak);   // Ooh oo aa aa!
    lion.accept(speak);     // Roaaar!
    dolphin.accept(speak);  // Tuut tuttu tuutt!

    monkey.accept(jump);    // Jumped 20 feet high! on to the tree!
    lion.accept(jump);      // Jumped 7 feet! back on the ground!
    dolphin.accept(jump);   // Walked on water a little and disappeared
    return 0;
}

// Visitee
interface Animal {
    fun accept(operation: AnimalOperation)
}

// Visitor
interface AnimalOperation {
    fun visitMonkey(monkey: Monkey)
    fun visitLion(lion: Lion)
    fun visitDolphin(dolphin: Dolphin)
}

class Monkey : Animal {
    fun shout() = println("Ooh oo aa aa!")

    override fun accept(operation: AnimalOperation) {
        operation.visitMonkey(this)
    }
}

class Lion : Animal {
    fun roar() = println("Roaaar!")

    override fun accept(operation: AnimalOperation) {
        operation.visitLion(this)
    }
}

class Dolphin : Animal {
    fun speak() = println("Tuut tuttu tuutt!")

    override fun accept(operation: AnimalOperation) {
        operation.visitDolphin(this)
    }
}

class Speak : AnimalOperation {
    override fun visitMonkey(monkey: Monkey) = monkey.shout()
    override fun visitLion(lion: Lion) = lion.roar()
    override fun visitDolphin(dolphin: Dolphin) = dolphin.speak()
}

class Jump : AnimalOperation {
    override fun visitMonkey(monkey: Monkey) = println("Jumped 20 feet high! on to the tree!")
    override fun visitLion(lion: Lion) = println("Jumped 7 feet! back on the ground!")
    override fun visitDolphin(dolphin: Dolphin) = println("Walked on water a little and disappeared")
}

// ----------------------------

fun main() {
    val monkey = Monkey()
    val lion = Lion()
    val dolphin = Dolphin()

    val speak = Speak()
    val jump = Jump()

    monkey.accept(speak)
    lion.accept(speak)
    dolphin.accept(speak)

    monkey.accept(jump)
    lion.accept(jump)
    dolphin.accept(jump)
}

// Visitor
abstract class AnimalOperation {
  void visitMonkey(Monkey monkey);
  void visitLion(Lion lion);
  void visitDolphin(Dolphin dolphin);
}

// Visitee
abstract class Animal {
  void accept(AnimalOperation operation);
}

class Monkey implements Animal {
  void shout() => print('Ooh oo aa aa!');

  @override
  void accept(AnimalOperation operation) => operation.visitMonkey(this);
}

class Lion implements Animal {
  void roar() => print('Roaaar!');

  @override
  void accept(AnimalOperation operation) => operation.visitLion(this);
}

class Dolphin implements Animal {
  void speak() => print('Tuut tuttu tuutt!');

  @override
  void accept(AnimalOperation operation) => operation.visitDolphin(this);
}

class Speak implements AnimalOperation {
  @override
  void visitMonkey(Monkey monkey) => monkey.shout();

  @override
  void visitLion(Lion lion) => lion.roar();

  @override
  void visitDolphin(Dolphin dolphin) => dolphin.speak();
}

class Jump implements AnimalOperation {
  @override
  void visitMonkey(Monkey monkey) => print('Jumped 20 feet high! on to the tree!');

  @override
  void visitLion(Lion lion) => print('Jumped 7 feet! back on the ground!');

  @override
  void visitDolphin(Dolphin dolphin) => print('Walked on water a little and disappeared');
}

// ----------------------------

void main() {
  var monkey = Monkey();
  var lion = Lion();
  var dolphin = Dolphin();

  var speak = Speak();
  var jump = Jump();

  monkey.accept(speak);
  lion.accept(speak);
  dolphin.accept(speak);

  monkey.accept(jump);
  lion.accept(jump);
  dolphin.accept(jump);
}

class PaymentStrategy:
    def pay(self, amount):
        pass


class CashPayment(PaymentStrategy):
    def pay(self, amount):
        print(f'Paid {amount} in cash')


class CardPayment(PaymentStrategy):
    def pay(self, amount):
        print(f'Paid {amount} by card')


class WalletPayment(PaymentStrategy):
    def pay(self, amount):
        print(f'Paid {amount} from wallet')


class Checkout:
    def __init__(self, strategy):
        self._strategy = strategy

    def checkout(self, amount):
        self._strategy.pay(amount)


# ----------------------------

checkout = Checkout(CashPayment())
checkout.checkout(100)  # Output: Paid 100 in cash

checkout = Checkout(CardPayment())
checkout.checkout(250)  # Output: Paid 250 by card

interface PaymentStrategy {
    pay(amount: number): void;
}

class CashPayment implements PaymentStrategy {
    pay(amount: number): void {
        console.log(`Paid ${amount} in cash`);
    }
}

class CardPayment implements PaymentStrategy {
    pay(amount: number): void {
        console.log(`Paid ${amount} by card`);
    }
}

class WalletPayment implements PaymentStrategy {
    pay(amount: number): void {
        console.log(`Paid ${amount} from wallet`);
    }
}

class Checkout {
    private strategy: PaymentStrategy;

    constructor(strategy: PaymentStrategy) {
        this.strategy = strategy;
    }

    checkout(amount: number): void {
        this.strategy.pay(amount);
    }
}

// ----------------------------

let checkout = new Checkout(new CashPayment());
checkout.checkout(100); // Output: Paid 100 in cash

checkout = new Checkout(new CardPayment());
checkout.checkout(250); // Output: Paid 250 by card

class CashPayment {
    pay(amount) {
        console.log(`Paid ${amount} in cash`);
    }
}

class CardPayment {
    pay(amount) {
        console.log(`Paid ${amount} by card`);
    }
}

class WalletPayment {
    pay(amount) {
        console.log(`Paid ${amount} from wallet`);
    }
}

class Checkout {
    constructor(strategy) {
        this.strategy = strategy;
    }

    checkout(amount) {
        this.strategy.pay(amount);
    }
}

let checkout = new Checkout(new CashPayment());
checkout.checkout(100); // Output: Paid 100 in cash

checkout = new Checkout(new CardPayment());
checkout.checkout(250); // Output: Paid 250 by card

using System;


interface IPaymentStrategy
{
  void Pay(int amount);
}

class CashPayment : IPaymentStrategy
{
  public void Pay(int amount)
  {
    Console.WriteLine($"Paid {amount} in cash");
  }
}

class CardPayment : IPaymentStrategy
{
  public void Pay(int amount)
  {
    Console.WriteLine($"Paid {amount} by card");
  }
}

class WalletPayment : IPaymentStrategy
{
  public void Pay(int amount)
  {
    Console.WriteLine($"Paid {amount} from wallet");
  }
}

class ShoppingCart
{
  private readonly IPaymentStrategy mStrategy;

  public ShoppingCart(IPaymentStrategy strategy)
  {
    mStrategy = strategy;
  }

  public void Checkout(int amount)
  {
    mStrategy.Pay(amount);
  }
}

// ----------------------------

var checkout = new ShoppingCart(new CashPayment());
checkout.Checkout(100); // Output: Paid 100 in cash

checkout = new ShoppingCart(new CardPayment());
checkout.Checkout(250); // Output: Paid 250 by card

interface PaymentStrategyInterface {
  public function pay($amount);
}

class CashPayment implements PaymentStrategyInterface {
  public function pay($amount) {
    echo "Paid $amount in cash\n";
  }
}

class CardPayment implements PaymentStrategyInterface {
  public function pay($amount) {
    echo "Paid $amount by card\n";
  }
}

class WalletPayment implements PaymentStrategyInterface {
  public function pay($amount) {
    echo "Paid $amount from wallet\n";
  }
}

class Checkout {
  private $mStrategy;

  public function __construct(PaymentStrategyInterface $strategy) {
    $this->mStrategy = $strategy;
  }

  public function checkout($amount) {
    $this->mStrategy->pay($amount);
  }
}

$checkout = new Checkout(new CashPayment());
$checkout->checkout(100); // Output: Paid 100 in cash

$checkout = new Checkout(new CardPayment());
$checkout->checkout(250); // Output: Paid 250 by card

package main

import (
	"fmt"
)

// PaymentStrategy is the interface that defines a payment method
type PaymentStrategy interface {
	Pay(amount int)
}

// CashPayment implements the PaymentStrategy interface
type CashPayment struct{}

func (c *CashPayment) Pay(amount int) {
	fmt.Printf("Paid %d in cash\n", amount)
}

// CardPayment implements the PaymentStrategy interface
type CardPayment struct{}

func (c *CardPayment) Pay(amount int) {
	fmt.Printf("Paid %d by card\n", amount)
}

// WalletPayment implements the PaymentStrategy interface
type WalletPayment struct{}

func (w *WalletPayment) Pay(amount int) {
	fmt.Printf("Paid %d from wallet\n", amount)
}

// Checkout is the context that uses a payment strategy
type Checkout struct {
	strategy PaymentStrategy
}

func NewCheckout(strategy PaymentStrategy) *Checkout {
	return &Checkout{strategy: strategy}
}

func (c *Checkout) Checkout(amount int) {
	c.strategy.Pay(amount)
}

func main() {
	checkout := NewCheckout(&CashPayment{})
	checkout.Checkout(100) // Output: Paid 100 in cash

	checkout = NewCheckout(&CardPayment{})
	checkout.Checkout(250) // Output: Paid 250 by card
}

interface PaymentStrategy {
    void pay(int amount);
}

class CashPayment implements PaymentStrategy {

    @Override
    public void pay(int amount) {
        System.out.println("Paid " + amount + " in cash");
    }
}

class CardPayment implements PaymentStrategy {

    @Override
    public void pay(int amount) {
        System.out.println("Paid " + amount + " by card");
    }
}

class WalletPayment implements PaymentStrategy {

    @Override
    public void pay(int amount) {
        System.out.println("Paid " + amount + " from wallet");
    }
}

class Checkout {
    private PaymentStrategy strategy;

    public Checkout(PaymentStrategy strategy) {
        this.strategy = strategy;
    }

    public void checkout(int amount) {
        strategy.pay(amount);
    }
}

// ----------------------------

Checkout checkout = new Checkout(new CashPayment());
checkout.checkout(100); // Paid 100 in cash

checkout = new Checkout(new CardPayment());
checkout.checkout(250); // Paid 250 by card

#include <iostream>

class PaymentStrategy {
public:
    virtual ~PaymentStrategy() = default;
    virtual void pay(int amount) = 0;
};

class CashPayment : public PaymentStrategy {
public:
    void pay(int amount) override {
        std::cout << "Paid " << amount << " in cash" << std::endl;
    }
};

class CardPayment : public PaymentStrategy {
public:
    void pay(int amount) override {
        std::cout << "Paid " << amount << " by card" << std::endl;
    }
};

class WalletPayment : public PaymentStrategy {
public:
    void pay(int amount) override {
        std::cout << "Paid " << amount << " from wallet" << std::endl;
    }
};

class Checkout {
private:
    PaymentStrategy* strategy;

public:
    Checkout(PaymentStrategy* s) : strategy(s) {}

    void checkout(int amount) {
        strategy->pay(amount);
    }
};

// ----------------------------

int main() {
    CashPayment cash;
    Checkout checkout(&cash);
    checkout.checkout(100); // Output: Paid 100 in cash

    CardPayment card;
    Checkout checkout2(&card);
    checkout2.checkout(250); // Output: Paid 250 by card
    return 0;
}

interface PaymentStrategy {
    fun pay(amount: Int)
}

class CashPayment : PaymentStrategy {
    override fun pay(amount: Int) {
        println("Paid $amount in cash")
    }
}

class CardPayment : PaymentStrategy {
    override fun pay(amount: Int) {
        println("Paid $amount by card")
    }
}

class WalletPayment : PaymentStrategy {
    override fun pay(amount: Int) {
        println("Paid $amount from wallet")
    }
}

class Checkout(private val strategy: PaymentStrategy) {
    fun checkout(amount: Int) {
        strategy.pay(amount)
    }
}

// ----------------------------

fun main() {
    var checkout = Checkout(CashPayment())
    checkout.checkout(100)

    checkout = Checkout(CardPayment())
    checkout.checkout(250)
}

abstract class PaymentStrategy {
  void pay(int amount);
}

class CashPayment implements PaymentStrategy {
  @override
  void pay(int amount) => print('Paid $amount in cash');
}

class CardPayment implements PaymentStrategy {
  @override
  void pay(int amount) => print('Paid $amount by card');
}

class WalletPayment implements PaymentStrategy {
  @override
  void pay(int amount) => print('Paid $amount from wallet');
}

class Checkout {
  final PaymentStrategy _strategy;

  Checkout(this._strategy);

  void checkout(int amount) => _strategy.pay(amount);
}

// ----------------------------

void main() {
  var checkout = Checkout(CashPayment());
  checkout.checkout(100);

  checkout = Checkout(CardPayment());
  checkout.checkout(250);
}

from abc import ABC, abstractmethod


class TrafficLightState(ABC):
    @abstractmethod
    def name(self):
        ...

    @abstractmethod
    def next(self):
        ...


class RedLight(TrafficLightState):
    def name(self):
        return "Red"

    def next(self):
        return GreenLight()


class GreenLight(TrafficLightState):
    def name(self):
        return "Green"

    def next(self):
        return YellowLight()


class YellowLight(TrafficLightState):
    def name(self):
        return "Yellow"

    def next(self):
        return RedLight()


class TrafficLight:
    def __init__(self, state):
        self._state = state

    def name(self):
        return self._state.name()

    def next(self):
        self._state = self._state.next()


# ----------------------------

light = TrafficLight(RedLight())
for _ in range(4):
    print(light.name())
    light.next()

'''
Output:
Red
Green
Yellow
Red
'''

interface TrafficLightState {
    name(): string;
    next(): TrafficLightState;
}

class RedLight implements TrafficLightState {
    name(): string {
        return "Red";
    }

    next(): TrafficLightState {
        return new GreenLight();
    }
}

class GreenLight implements TrafficLightState {
    name(): string {
        return "Green";
    }

    next(): TrafficLightState {
        return new YellowLight();
    }
}

class YellowLight implements TrafficLightState {
    name(): string {
        return "Yellow";
    }

    next(): TrafficLightState {
        return new RedLight();
    }
}

class TrafficLight {
    private state: TrafficLightState;

    constructor(state: TrafficLightState) {
        this.state = state;
    }

    name(): string {
        return this.state.name();
    }

    next(): void {
        this.state = this.state.next();
    }
}

// ----------------------------

const light = new TrafficLight(new RedLight());
for (let i = 0; i < 4; i++) {
    console.log(light.name());
    light.next();
}

// Output:
// Red
// Green
// Yellow
// Red

class RedLight {
    name() {
        return "Red";
    }

    next() {
        return new GreenLight();
    }
}

class GreenLight {
    name() {
        return "Green";
    }

    next() {
        return new YellowLight();
    }
}

class YellowLight {
    name() {
        return "Yellow";
    }

    next() {
        return new RedLight();
    }
}

class TrafficLight {
    constructor(state) {
        this.state = state;
    }

    name() {
        return this.state.name();
    }

    next() {
        this.state = this.state.next();
    }
}

// ----------------------------

const light = new TrafficLight(new RedLight());
for (let i = 0; i < 4; i++) {
    console.log(light.name());
    light.next();
}

// Output:
// Red
// Green
// Yellow
// Red

using System;


interface ITrafficLightState {
  string Name();
  ITrafficLightState Next();
}

class RedLight : ITrafficLightState
{
  public string Name() => "Red";
  public ITrafficLightState Next() => new GreenLight();
}

class GreenLight : ITrafficLightState
{
  public string Name() => "Green";
  public ITrafficLightState Next() => new YellowLight();
}

class YellowLight : ITrafficLightState
{
  public string Name() => "Yellow";
  public ITrafficLightState Next() => new RedLight();
}

class TrafficLight {

  private ITrafficLightState mState;

  public TrafficLight(ITrafficLightState state)
  {
    mState = state;
  }

  public string Name() => mState.Name();

  public void Next()
  {
    mState = mState.Next();
  }

}


// ----------------------------

var light = new TrafficLight(new RedLight());

for (int i = 0; i < 4; i++)
{
  Console.WriteLine(light.Name());
  light.Next();
}

// Output:
// Red
// Green
// Yellow
// Red

interface TrafficLightStateInterface {
  public function name(): string;
  public function next(): TrafficLightStateInterface;
}

class RedLight implements TrafficLightStateInterface
{
  public function name(): string
  {
    return "Red";
  }

  public function next(): TrafficLightStateInterface
  {
    return new GreenLight();
  }
}

class GreenLight implements TrafficLightStateInterface
{
  public function name(): string
  {
    return "Green";
  }

  public function next(): TrafficLightStateInterface
  {
    return new YellowLight();
  }
}

class YellowLight implements TrafficLightStateInterface
{
  public function name(): string
  {
    return "Yellow";
  }

  public function next(): TrafficLightStateInterface
  {
    return new RedLight();
  }
}

class TrafficLight {
  private TrafficLightStateInterface $state;

  public function __construct(TrafficLightStateInterface $state)
  {
    $this->state = $state;
  }

  public function name(): string
  {
    return $this->state->name();
  }

  public function next(): void
  {
    $this->state = $this->state->next();
  }
}

$light = new TrafficLight(new RedLight());

for ($i = 0; $i < 4; $i++) {
  echo $light->name() . "\n";
  $light->next();
}

// Output:
// Red
// Green
// Yellow
// Red

package main

import "fmt"

// TrafficLightState interface
type TrafficLightState interface {
	Name() string
	Next() TrafficLightState
}

// RedLight struct
type RedLight struct{}

func (r *RedLight) Name() string {
	return "Red"
}

func (r *RedLight) Next() TrafficLightState {
	return &GreenLight{}
}

// GreenLight struct
type GreenLight struct{}

func (g *GreenLight) Name() string {
	return "Green"
}

func (g *GreenLight) Next() TrafficLightState {
	return &YellowLight{}
}

// YellowLight struct
type YellowLight struct{}

func (y *YellowLight) Name() string {
	return "Yellow"
}

func (y *YellowLight) Next() TrafficLightState {
	return &RedLight{}
}

// TrafficLight holds the current state
type TrafficLight struct {
	state TrafficLightState
}

// NewTrafficLight constructor
func NewTrafficLight(state TrafficLightState) *TrafficLight {
	return &TrafficLight{state: state}
}

// Name delegates to the current state
func (t *TrafficLight) Name() string {
	return t.state.Name()
}

// Next asks the current state for the next one
func (t *TrafficLight) Next() {
	t.state = t.state.Next()
}

func main() {
	light := NewTrafficLight(&RedLight{})
	for i := 0; i < 4; i++ {
		fmt.Println(light.Name())
		light.Next()
	}
}

interface TrafficLightState {
    String name();
    TrafficLightState next();
}

class RedLight implements TrafficLightState {
    public String name() {
        return "Red";
    }

    public TrafficLightState next() {
        return new GreenLight();
    }
}

class GreenLight implements TrafficLightState {
    public String name() {
        return "Green";
    }

    public TrafficLightState next() {
        return new YellowLight();
    }
}

class YellowLight implements TrafficLightState {
    public String name() {
        return "Yellow";
    }

    public TrafficLightState next() {
        return new RedLight();
    }
}

class TrafficLight {
    private TrafficLightState state;

    public TrafficLight(TrafficLightState state) {
        this.state = state;
    }

    public String name() {
        return state.name();
    }

    public void next() {
        state = state.next();
    }
}

// ----------------------------

TrafficLight light = new TrafficLight(new RedLight());

for (int i = 0; i < 4; i++) {
    System.out.println(light.name());
    light.next();
}

// Output:
// Red
// Green
// Yellow
// Red

#include <iostream>
#include <memory>
#include <string>

class TrafficLightState {
public:
    virtual ~TrafficLightState() = default;
    virtual std::string name() const = 0;
    virtual std::unique_ptr<TrafficLightState> next() const = 0;
};

class GreenLight;
class YellowLight;

class RedLight : public TrafficLightState {
public:
    std::string name() const override { return "Red"; }
    std::unique_ptr<TrafficLightState> next() const override;
};

class GreenLight : public TrafficLightState {
public:
    std::string name() const override { return "Green"; }
    std::unique_ptr<TrafficLightState> next() const override;
};

class YellowLight : public TrafficLightState {
public:
    std::string name() const override { return "Yellow"; }
    std::unique_ptr<TrafficLightState> next() const override;
};

std::unique_ptr<TrafficLightState> RedLight::next() const {
    return std::make_unique<GreenLight>();
}

std::unique_ptr<TrafficLightState> GreenLight::next() const {
    return std::make_unique<YellowLight>();
}

std::unique_ptr<TrafficLightState> YellowLight::next() const {
    return std::make_unique<RedLight>();
}

class TrafficLight {
private:
    std::unique_ptr<TrafficLightState> state;

public:
    explicit TrafficLight(std::unique_ptr<TrafficLightState> initial)
        : state(std::move(initial)) {}

    std::string name() const { return state->name(); }

    void next() { state = state->next(); }
};

// ----------------------------

int main() {
    TrafficLight light(std::make_unique<RedLight>());
    for (int i = 0; i < 4; ++i) {
        std::cout << light.name() << std::endl;
        light.next();
    }
    return 0;
}

interface TrafficLightState {
    fun name(): String
    fun next(): TrafficLightState
}

class RedLight : TrafficLightState {
    override fun name() = "Red"
    override fun next(): TrafficLightState = GreenLight()
}

class GreenLight : TrafficLightState {
    override fun name() = "Green"
    override fun next(): TrafficLightState = YellowLight()
}

class YellowLight : TrafficLightState {
    override fun name() = "Yellow"
    override fun next(): TrafficLightState = RedLight()
}

class TrafficLight(private var state: TrafficLightState) {
    fun name() = state.name()

    fun next() {
        state = state.next()
    }
}

// ----------------------------

fun main() {
    val light = TrafficLight(RedLight())
    for (i in 0 until 4) {
        println(light.name())
        light.next()
    }
}

abstract class TrafficLightState {
  String name();
  TrafficLightState next();
}

class RedLight implements TrafficLightState {
  @override
  String name() => 'Red';

  @override
  TrafficLightState next() => GreenLight();
}

class GreenLight implements TrafficLightState {
  @override
  String name() => 'Green';

  @override
  TrafficLightState next() => YellowLight();
}

class YellowLight implements TrafficLightState {
  @override
  String name() => 'Yellow';

  @override
  TrafficLightState next() => RedLight();
}

class TrafficLight {
  TrafficLightState _state;

  TrafficLight(this._state);

  String name() => _state.name();

  void next() {
    _state = _state.next();
  }
}

// ----------------------------

void main() {
  var light = TrafficLight(RedLight());
  for (var i = 0; i < 4; i++) {
    print(light.name());
    light.next();
  }
}

class Builder:
    def build(self):
        self.test()
        self.lint()
        self.assemble()
        self.deploy()

    def test(self):
        pass

    def lint(self):
        pass

    def assemble(self):
        pass

    def deploy(self):
        pass


class AndroidBuilder(Builder):
    def test(self):
        print('Running android tests')

    def lint(self):
        print('Linting the android code')

    def assemble(self):
        print('Assembling the android build')

    def deploy(self):
        print('Deploying android build to server')


class IosBuilder(Builder):
    def test(self):
        print('Running ios tests')

    def lint(self):
        print('Linting the ios code')

    def assemble(self):
        print('Assembling the ios build')

    def deploy(self):
        print('Deploying ios build to server')


# ----------------------------

androidBuilder = AndroidBuilder()
androidBuilder.build()

# Output:
# Running android tests
# Linting the android code
# Assembling the android build
# Deploying android build to server


iosBuilder = IosBuilder()
iosBuilder.build()

# Output:
# Running ios tests
# Linting the ios code
# Assembling the ios build
# Deploying ios build to server

class Builder {
    build(): void {
        this.test();
        this.lint();
        this.assemble();
        this.deploy();
    }

    test(): void {
    }

    lint(): void {
    }

    assemble(): void {
    }

    deploy(): void {
    }
}

class AndroidBuilder extends Builder {
    test(): void {
        console.log("Running android tests");
    }

    lint(): void {
        console.log("Linting the android code");
    }

    assemble(): void {
        console.log("Assembling the android build");
    }

    deploy(): void {
        console.log("Deploying android build to server");
    }
}

class IosBuilder extends Builder {
    test(): void {
        console.log("Running ios tests");
    }

    lint(): void {
        console.log("Linting the ios code");
    }

    assemble(): void {
        console.log("Assembling the ios build");
    }

    deploy(): void {
        console.log("Deploying ios build to server");
    }
}

// ----------------------------

const androidBuilder = new AndroidBuilder();
androidBuilder.build();

// Output:
// Running android tests
// Linting the android code
// Assembling the android build
// Deploying android build to server

const iosBuilder = new IosBuilder();
iosBuilder.build();

// Output:
// Running ios tests
// Linting the ios code
// Assembling the ios build
// Deploying ios build to server

class Builder {
    build() {
        this.test();
        this.lint();
        this.assemble();
        this.deploy();
    }

    test() {

    }

    lint() {

    }

    assemble() {

    }

    deploy() {

    }
}

class AndroidBuilder extends Builder {
    test() {
        console.log("Running android tests");
    }

    lint() {
        console.log("Linting the android code");
    }

    assemble() {
        console.log("Assembling the android build");
    }

    deploy() {
        console.log("Deploying android build to server");
    }
}

class IosBuilder extends Builder {
    test() {
        console.log("Running ios tests");
    }

    lint() {
        console.log("Linting the ios code");
    }

    assemble() {
        console.log("Assembling the ios build");
    }

    deploy() {
        console.log("Deploying ios build to server");
    }
}


const androidBuilder = new AndroidBuilder();
androidBuilder.build();

// Output:
// Running android tests
// Linting the android code
// Assembling the android build
// Deploying android build to server

const iosBuilder = new IosBuilder();
iosBuilder.build();

// Output:
// Running ios tests
// Linting the ios code
// Assembling the ios build
// Deploying ios build to server

using System;


abstract class Builder
{
    // Template method
    public void Build()
    {
      Test();
      Lint();
      Assemble();
      Deploy();
    }

    abstract public void Test();
    abstract public void Lint();
    abstract public void Assemble();
    abstract public void Deploy();
}



class AndroidBuilder : Builder
{
  public override void Assemble()
  {
    Console.WriteLine("Assembling the android build");
  }

  public override void Deploy()
  {
    Console.WriteLine("Deploying android build to server");
  }

  public override void Lint()
  {
    Console.WriteLine("Linting the android code");
  }

  public override void Test()
  {
    Console.WriteLine("Running android tests");
  }
}


class IosBuilder : Builder
{
  public override void Assemble()
  {
    Console.WriteLine("Assembling the ios build");
  }

  public override void Deploy()
  {
    Console.WriteLine("Deploying ios build to server");
  }

  public override void Lint()
  {
    Console.WriteLine("Linting the ios code");
  }

  public override void Test()
  {
    Console.WriteLine("Running ios tests");
  }
}


// ----------------------------

var androidBuilder = new AndroidBuilder();
androidBuilder.Build();

// Output:
// Running android tests
// Linting the android code
// Assembling the android build
// Deploying android build to server

var iosBuilder = new IosBuilder();
iosBuilder.Build();

// Output:
// Running ios tests
// Linting the ios code
// Assembling the ios build
// Deploying ios build to server

abstract class Builder {
  // Template method
  public function Build() {
    $this->test();
    $this->lint();
    $this->assemble();
    $this->deploy();
  }

  abstract public function test();
  abstract public function lint();
  abstract public function assemble();
  abstract public function deploy();
}

class AndroidBuilder extends Builder {
  public function assemble() {
    echo "Assembling the android build\n";
  }

  public function deploy() {
    echo "Deploying android build to server\n";
  }

  public function lint() {
    echo "Linting the android code\n";
  }

  public function test() {
    echo "Running android tests\n";
  }
}

class IosBuilder extends Builder {
  public function assemble() {
    echo "Assembling the ios build\n";
  }

  public function deploy() {
    echo "Deploying ios build to server\n";
  }

  public function lint() {
    echo "Linting the ios code\n";
  }

  public function test() {
    echo "Running ios tests\n";
  }
}

$androidBuilder = new AndroidBuilder();
$androidBuilder->build();

// Output:
// Running android tests
// Linting the android code
// Assembling the android build
// Deploying android build to server

$iosBuilder = new IosBuilder();
$iosBuilder->build();

// Output:
// Running ios tests
// Linting the ios code
// Assembling the ios build
// Deploying ios build to server

package main

import (
	"fmt"
)

// Builder interface
type Builder interface {
	Test()
	Lint()
	Assemble()
	Deploy()
}

// BaseBuilder provides default implementations
type BaseBuilder struct{
    self Builder
}
func (b *BaseBuilder) init(self Builder) {
	b.self = self
}

// Build for BaseBuilder
func (b *BaseBuilder) Build() {
	b.self.Test()
	b.self.Lint()
	b.self.Assemble()
	b.self.Deploy()
}


// AndroidBuilder struct
type AndroidBuilder struct {
	BaseBuilder
}

func NewAndroidBuilder() *AndroidBuilder {
	a := &AndroidBuilder{}
	a.init(a)
	return a
}

// Test for AndroidBuilder
func (a *AndroidBuilder) Test() {
	fmt.Println("Running android tests")
}

// Lint for AndroidBuilder
func (a *AndroidBuilder) Lint() {
	fmt.Println("Linting the android code")
}

// Assemble for AndroidBuilder
func (a *AndroidBuilder) Assemble() {
	fmt.Println("Assembling the android build")
}

// Deploy for AndroidBuilder
func (a *AndroidBuilder) Deploy() {
	fmt.Println("Deploying android build to server")
}

// IosBuilder struct
type IosBuilder struct {
	BaseBuilder
}
func NewIosBuilder() *IosBuilder {
	i := &IosBuilder{}
	i.init(i)
	return i
}
// Test for IosBuilder
func (i *IosBuilder) Test() {
	fmt.Println("Running ios tests")
}

// Lint for IosBuilder
func (i *IosBuilder) Lint() {
	fmt.Println("Linting the ios code")
}

// Assemble for IosBuilder
func (i *IosBuilder) Assemble() {
	fmt.Println("Assembling the ios build")
}

// Deploy for IosBuilder
func (i *IosBuilder) Deploy() {
	fmt.Println("Deploying ios build to server")
}

func main() {
	NewAndroidBuilder().Build()
	NewIosBuilder().Build()
}

abstract class Builder {
    // Template method
    public void build() {
        test();
        lint();
        assemble();
        deploy();
    }

    abstract public void test();
    abstract public void lint();
    abstract public void assemble();
    abstract public void deploy();
}

class AndroidBuilder extends Builder {

    @Override
    public void test() {
        System.out.println("Running android tests");
    }

    @Override
    public void lint() {
        System.out.println("Linting the android code");
    }

    @Override
    public void assemble() {
        System.out.println("Assembling the android build");
    }

    @Override
    public void deploy() {
        System.out.println("Deploying android build to server");
    }
}

class IosBuilder extends Builder {

    @Override
    public void test() {
        System.out.println("Running ios tests");
    }

    @Override
    public void lint() {
        System.out.println("Linting the ios code");
    }

    @Override
    public void assemble() {
        System.out.println("Assembling the ios build");
    }

    @Override
    public void deploy() {
        System.out.println("Deploying ios build to server");
    }
}

// ----------------------------

AndroidBuilder androidBuilder = new AndroidBuilder();
androidBuilder.build();
// Running android tests
// Linting the android code
// Assembling the android build
// Deploying android build to server

IosBuilder iosBuilder = new IosBuilder();
iosBuilder.build();
// Running ios tests
// Linting the ios code
// Assembling the ios build
// Deploying ios build to server

#include <iostream>

class Builder {
public:
    virtual ~Builder() = default;
    
    // Template method
    void build() {
        test();
        lint();
        assemble();
        deploy();
    }

    virtual void test() = 0;
    virtual void lint() = 0;
    virtual void assemble() = 0;
    virtual void deploy() = 0;
};

class AndroidBuilder : public Builder {
public:
    void test() override {
        std::cout << "Running android tests" << std::endl;
    }

    void lint() override {
        std::cout << "Linting the android code" << std::endl;
    }

    void assemble() override {
        std::cout << "Assembling the android build" << std::endl;
    }

    void deploy() override {
        std::cout << "Deploying android build to server" << std::endl;
    }
};

class IosBuilder : public Builder {
public:
    void test() override {
        std::cout << "Running ios tests" << std::endl;
    }

    void lint() override {
        std::cout << "Linting the ios code" << std::endl;
    }

    void assemble() override {
        std::cout << "Assembling the ios build" << std::endl;
    }

    void deploy() override {
        std::cout << "Deploying ios build to server" << std::endl;
    }
};

// ----------------------------

int main() {
    AndroidBuilder androidBuilder;
    androidBuilder.build();
    // Running android tests
    // Linting the android code
    // Assembling the android build
    // Deploying android build to server

    IosBuilder iosBuilder;
    iosBuilder.build();
    // Running ios tests
    // Linting the ios code
    // Assembling the ios build
    // Deploying ios build to server
    return 0;
}

abstract class Builder {
    // Template method
    fun build() {
        test()
        lint()
        assemble()
        deploy()
    }

    abstract fun test()
    abstract fun lint()
    abstract fun assemble()
    abstract fun deploy()
}

class AndroidBuilder : Builder() {
    override fun test() {
        println("Running android tests")
    }

    override fun lint() {
        println("Linting the android code")
    }

    override fun assemble() {
        println("Assembling the android build")
    }

    override fun deploy() {
        println("Deploying android build to server")
    }
}

class IosBuilder : Builder() {
    override fun test() {
        println("Running ios tests")
    }

    override fun lint() {
        println("Linting the ios code")
    }

    override fun assemble() {
        println("Assembling the ios build")
    }

    override fun deploy() {
        println("Deploying ios build to server")
    }
}

// ----------------------------

fun main() {
    val androidBuilder = AndroidBuilder()
    androidBuilder.build()

    val iosBuilder = IosBuilder()
    iosBuilder.build()
}

abstract class Builder {
  // Template method
  void build() {
    test();
    lint();
    assemble();
    deploy();
  }

  void test();
  void lint();
  void assemble();
  void deploy();
}

class AndroidBuilder extends Builder {
  @override
  void test() => print('Running android tests');

  @override
  void lint() => print('Linting the android code');

  @override
  void assemble() => print('Assembling the android build');

  @override
  void deploy() => print('Deploying android build to server');
}

class IosBuilder extends Builder {
  @override
  void test() => print('Running ios tests');

  @override
  void lint() => print('Linting the ios code');

  @override
  void assemble() => print('Assembling the ios build');

  @override
  void deploy() => print('Deploying ios build to server');
}

// ----------------------------

void main() {
  var androidBuilder = AndroidBuilder();
  androidBuilder.build();

  var iosBuilder = IosBuilder();
  iosBuilder.build();
}