Decorator

// Component interface
abstract class Component {
  String operation();
}

// Concrete Component
class ConcreteComponent implements Component {
  @override
  String operation() => 'Base operation';
}

// Decorator abstract class
abstract class Decorator implements Component {
  final Component _component;

  Decorator(this._component);

  @override
  String operation() => _component.operation();
}

// Concrete Decorator 1
class ConcreteDecoratorA extends Decorator {
  ConcreteDecoratorA(Component component) : super(component);

  @override
  String operation() {
    return 'Decorator A: ' + super.operation();
  }
}

// Concrete Decorator 2
class ConcreteDecoratorB extends Decorator {
  ConcreteDecoratorB(Component component) : super(component);

  @override
  String operation() {
    return 'Decorator B: ' + super.operation();
  }
}

void main() {
  Component component = ConcreteComponent();
  print(component.operation());

  Component decoratorA = ConcreteDecoratorA(component);
  print(decoratorA.operation());

  Component decoratorB = ConcreteDecoratorB(decoratorA);
  print(decoratorB.operation());
}

trait Beverage {
  val cost: Double
  val description: String
}

class Espresso extends Beverage {
  val cost = 2.0
  val description = "Espresso"
}

trait BeverageDecorator extends Beverage {
  protected var decoratedBeverage: Beverage
  def this(beverage: Beverage) = {
    this.decoratedBeverage = beverage
    this
  }
}

class MilkDecorator(beverage: Beverage) extends BeverageDecorator {
  val cost = beverage.cost + 0.5
  val description = beverage.description + ", Milk"
}

class SoyDecorator(beverage: Beverage) extends BeverageDecorator {
  val cost = beverage.cost + 0.7
  val description = beverage.description + ", Soy"
}

object Main {
  def main(args: Array[String]): Unit = {
    val espresso = new Espresso()
    val milkEspresso = new MilkDecorator(espresso)
    val soyMilkEspresso = new SoyDecorator(milkEspresso)

    println(s"Description: ${soyMilkEspresso.description}")
    println(s"Cost: $${soyMilkEspresso.cost}")
  }
}

<?php

/**
 * Component Interface: Defines the interface for objects that can have
 * responsibilities added dynamically.
 */
interface Coffee {
    public function getCost(): float;
    public function getDescription(): string;
}

/**
 * Concrete Component: The base coffee object.
 */
class SimpleCoffee implements Coffee {
    public function getCost(): float {
        return 2.0;
    }

    public function getDescription(): string {
        return "Simple coffee";
    }
}

/**
 * Decorator Abstract Class: Holds a reference to the object it decorates.
 */
abstract class CoffeeDecorator implements Coffee {
    protected Coffee $coffee;

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

/**
 * Concrete Decorator: Adds milk to the coffee.
 */
class MilkDecorator extends CoffeeDecorator {
    public function getCost(): float {
        return $this->coffee->getCost() + 0.5;
    }

    public function getDescription(): string {
        return $this->coffee->getDescription() . ", with milk";
    }
}

/**
 * Concrete Decorator: Adds sugar to the coffee.
 */
class SugarDecorator extends CoffeeDecorator {
    public function getCost(): float {
        return $this->coffee->getCost() + 0.2;
    }

    public function getDescription(): string {
        return $this->coffee->getDescription() . ", with sugar";
    }
}

// Usage
$coffee = new SimpleCoffee();
$coffee = new MilkDecorator($coffee);
$coffee = new SugarDecorator($coffee);

echo "Description: " . $coffee->getDescription() . "\n";
echo "Cost: $" . $coffee->getCost() . "\n";

?>

# Component interface
class Coffee
  def cost
    raise NotImplementedError
  end

  def description
    "Simple Coffee"
  end
end

# Concrete Component
class SimpleCoffee < Coffee
  def cost
    1.0
  end
end

# Decorator abstract class
class CoffeeDecorator < Coffee
  def initialize(coffee)
    @coffee = coffee
  end

  def cost
    @coffee.cost
  end

  def description
    @coffee.description
  end
end

# Concrete Decorators
class MilkDecorator < CoffeeDecorator
  def cost
    @coffee.cost + 0.5
  end

  def description
    @coffee.description + ", with Milk"
  end
end

class SugarDecorator < CoffeeDecorator
  def cost
    @coffee.cost + 0.2
  end

  def description
    @coffee.description + ", with Sugar"
  end
end

# Usage
coffee = SimpleCoffee.new
puts "Cost: #{coffee.cost}, Description: #{coffee.description}"

decorated_coffee = MilkDecorator.new(coffee)
puts "Cost: #{decorated_coffee.cost}, Description: #{decorated_coffee.description}"

more_decorated_coffee = SugarDecorator.new(decorated_coffee)
puts "Cost: #{more_decorated_coffee.cost}, Description: #{more_decorated_coffee.description}"

protocol Coffee {
    var cost: Double { get }
    var description: String { get }
}

class BaseCoffee: Coffee {
    let description: String
    let cost: Double

    init(description: String, cost: Double) {
        self.description = description
        self.cost = cost
    }
}

class CoffeeDecorator: Coffee {
    let coffee: Coffee

    init(coffee: Coffee) {
        self.coffee = coffee
    }

    var cost: Double {
        return coffee.cost
    }

    var description: String {
        return coffee.description
    }
}

class MilkDecorator: CoffeeDecorator {
    override var cost: Double {
        return super.cost + 0.5
    }

    override var description: String {
        return super.description + ", with milk"
    }
}

class SugarDecorator: CoffeeDecorator {
    override var cost: Double {
        return super.cost + 0.2
    }

    override var description: String {
        return super.description + ", with sugar"
    }
}

// Example Usage
let simpleCoffee = BaseCoffee(description: "Simple coffee", cost: 2.0)
let milkCoffee = MilkDecorator(coffee: simpleCoffee)
let sugaryMilkCoffee = SugarDecorator(coffee: milkCoffee)

print(sugaryMilkCoffee.description) // Output: Simple coffee, with milk, with sugar
print(sugaryMilkCoffee.cost) // Output: 2.7

// Component Interface
interface Coffee {
    fun brew(): String
    fun getCost(): Double
}

// Concrete Component
class SimpleCoffee : Coffee {
    override fun brew(): String = "Simple coffee"
    override fun getCost(): Double = 1.0
}

// Decorator
abstract class CoffeeDecorator(protected var coffee: Coffee) : Coffee {
    override fun brew(): String {
        return coffee.brew()
    }

    override fun getCost(): Double {
        return coffee.getCost()
    }
}

// Concrete Decorators
class MilkDecorator(coffee: Coffee) : CoffeeDecorator(coffee) {
    override fun brew(): String = "${coffee.brew()} with milk"
    override fun getCost(): Double = coffee.getCost() + 0.5
}

class SugarDecorator(coffee: Coffee) : CoffeeDecorator(coffee) {
    override fun brew(): String = "${coffee.brew()} with sugar"
    override fun getCost(): Double = coffee.getCost() + 0.2
}

fun main() {
    val coffee = SimpleCoffee()
    println(coffee.brew()) // Output: Simple coffee
    println("Cost: $${coffee.getCost()}") // Output: Cost: $1.0

    val milkCoffee = MilkDecorator(coffee)
    println(milkCoffee.brew()) // Output: Simple coffee with milk
    println("Cost: $${milkCoffee.getCost()}") // Output: Cost: $1.5

    val sugarMilkCoffee = SugarDecorator(milkCoffee)
    println(sugarMilkCoffee.brew()) // Output: Simple coffee with milk with sugar
    println("Cost: $${sugarMilkCoffee.getCost()}") // Output: Cost: $1.7
}

// Define the component interface
trait Report {
    fn display(&self) -> String;
}

// Concrete component
struct SimpleReport {
    content: String,
}

impl SimpleReport {
    fn new(content: String) -> Self {
        SimpleReport { content }
    }
}

impl Report for SimpleReport {
    fn display(&self) -> String {
        self.content.clone()
    }
}

// The Decorator abstract class
trait Decorator: Report {
    fn get_component(&self) -> &dyn Report;
}

struct ConcreteDecorator<'a> {
    component: Box<dyn Report>,
    additional_info: String,
}

impl<'a> ConcreteDecorator<'a> {
    fn new(component: Box<dyn Report>, additional_info: String) -> Self {
        ConcreteDecorator { component, additional_info }
    }
}

impl<'a> Report for ConcreteDecorator<'a> {
    fn display(&self) -> String {
        self.component.display() + &self.additional_info
    }
}

// Concrete Decorator
struct DetailedReport<'a> {
    report: Box<dyn Report>,
}

impl<'a> DetailedReport<'a> {
    fn new(report: Box<dyn Report>) -> Self {
        DetailedReport { report }
    }
}

impl<'a> Report for DetailedReport<'a> {
    fn display(&self) -> String {
        format!("Detailed Report:\n{}", self.report.display())
    }
}

fn main() {
    let simple_report = Box::new(SimpleReport::new("This is the base report.".to_string()));

    let detailed_report = DetailedReport::new(simple_report);
    println!("{}", detailed_report.display());

    let decorated_report = ConcreteDecorator::new(Box::new(SimpleReport::new("Another report.".to_string())), " - with extra details!".to_string());
    println!("{}", decorated_report.display());
}

// service.go

package main

import "fmt"

// Service interface defines the core functionality.
type Service interface {
	Do()
}

// ConcreteService is a concrete implementation of the Service interface.
type ConcreteService struct{}

func (s *ConcreteService) Do() {
	fmt.Println("ConcreteService: Doing something.")
}

// Decorator interface defines the decorator's structure.
type Decorator interface {
	Service
}

// ConcreteDecorator adds functionality to the Service.
type ConcreteDecorator struct {
	decoratedService Service
}

func NewConcreteDecorator(s Service) *ConcreteDecorator {
	return &ConcreteDecorator{decoratedService: s}
}

func (d *ConcreteDecorator) Do() {
	fmt.Println("ConcreteDecorator: Before service.")
	d.decoratedService.Do()
	fmt.Println("ConcreteDecorator: After service.")
}

// AnotherDecorator adds different functionality.
type AnotherDecorator struct {
	decoratedService Service
}

func NewAnotherDecorator(s Service) *AnotherDecorator {
	return &AnotherDecorator{decoratedService: s}
}

func (a *AnotherDecorator) Do() {
	fmt.Println("AnotherDecorator: Adding extra behavior.")
	a.decoratedService.Do()
}

func main() {
	service := &ConcreteService{}

	// Decorate the service with ConcreteDecorator
	decoratedService := NewConcreteDecorator(service)
	decoratedService.Do()

	// Further decorate with AnotherDecorator
	anotherDecoratedService := NewAnotherDecorator(decoratedService)
	anotherDecoratedService.Do()
}

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

// Component Interface
typedef struct Coffee Coffee;
typedef void (*CoffeeFunc)(Coffee*);

struct Coffee {
  CoffeeFunc drink;
  char* description;
};

void simpleCoffeeDrink(Coffee* coffee) {
  printf("Drinking a simple coffee: %s\n", coffee->description);
}

// Concrete Component
Coffee* createSimpleCoffee() {
  Coffee* coffee = (Coffee*)malloc(sizeof(Coffee));
  if (coffee == NULL) {
    perror("Failed to allocate memory for coffee");
    exit(EXIT_FAILURE);
  }
  coffee->drink = simpleCoffeeDrink;
  coffee->description = strdup("Simple Coffee");
  return coffee;
}

// Decorator
typedef struct CoffeeDecorator CoffeeDecorator;

struct CoffeeDecorator {
  Coffee* coffee;
  char* description;
};

CoffeeDecorator* createCoffeeDecorator(Coffee* coffee) {
  CoffeeDecorator* decorator = (CoffeeDecorator*)malloc(sizeof(CoffeeDecorator));
  if (decorator == NULL) {
    perror("Failed to allocate memory for decorator");
    exit(EXIT_FAILURE);
  }
  decorator->coffee = coffee;
  decorator->description = strdup("Decorated Coffee");
  return decorator;
}

// Concrete Decorators
typedef struct MilkDecorator MilkDecorator;
typedef struct SugarDecorator SugarDecorator;

struct MilkDecorator {
  CoffeeDecorator base;
  char* milk_description;
};

struct SugarDecorator {
  CoffeeDecorator base;
  char* sugar_description;
};

void milkDecoratorDrink(CoffeeDecorator* decorator) {
  printf("Adding milk: %s\n", decorator->base.coffee->description);
  printf("Drinking a coffee with milk: %s\n", decorator->milk_description);
}

void sugarDecoratorDrink(CoffeeDecorator* decorator) {
  printf("Adding sugar: %s\n", decorator->base.coffee->description);
  printf("Drinking a coffee with sugar: %s\n", decorator->sugar_description);
}

CoffeeDecorator* createMilkDecorator(Coffee* coffee) {
  CoffeeDecorator* decorator = createCoffeeDecorator(coffee);
  MilkDecorator* milkDecorator = (MilkDecorator*)decorator;
  milkDecorator->milk_description = strdup("Milk Coffee");
  milkDecorator->base.coffee->drink(milkDecorator); // Call the underlying coffee's drink method
  return decorator;
}

CoffeeDecorator* createSugarDecorator(Coffee* coffee) {
  CoffeeDecorator* decorator = createCoffeeDecorator(coffee);
  SugarDecorator* sugarDecorator = (SugarDecorator*)decorator;
  sugarDecorator->sugar_description = strdup("Sugar Coffee");
  sugarDecorator->base.coffee->drink(sugarDecorator); // Call the underlying coffee's drink method
  return decorator;
}

int main() {
  Coffee* simple = createSimpleCoffee();

  CoffeeDecorator* milk = createMilkDecorator(simple);

  CoffeeDecorator* sugar = createSugarDecorator(milk);

  // Cleanup (important in C)
  free(simple->description);
  free(simple);
  free(milk->milk_description);
  free(milk);
  free(sugar->sugar_description);
  free(sugar);

  return 0;
}

#include <iostream>
#include <string>

// Component interface
class Component {
public:
  virtual std::string operation() = 0;
};

// Concrete Component
class ConcreteComponent : public Component {
public:
  std::string operation() override {
    return "Core functionality";
  }
};

// Decorator base class
class Decorator : public Component {
public:
  Decorator(Component* component) : component_(component) {}

  std::string operation() override {
    return component_->operation();
  }

protected:
  Component* component_;
};

// Concrete Decorator A
class ConcreteDecoratorA : public Decorator {
public:
  ConcreteDecoratorA(Component* component) : Decorator(component) {}

  std::string operation() override {
    return Decorator::operation() + " with added feature A";
  }
};

// Concrete Decorator B
class ConcreteDecoratorB : public Decorator {
public:
  ConcreteDecoratorB(Component* component) : Decorator(component) {}

  std::string operation() override {
    return Decorator::operation() + " and feature B";
  }
};

int main() {
  Component* simple = new ConcreteComponent();
  std::cout << "Simple component: " << simple->operation() << std::endl;

  Component* decorated = new ConcreteDecoratorA(simple);
  std::cout << "Decorated with A: " << decorated->operation() << std::endl;

  Component* doubly_decorated = new ConcreteDecoratorB(decorated);
  std::cout << "Decorated with A and B: " << doubly_decorated->operation() << std::endl;

  delete simple;
  delete decorated;
  delete doubly_decorated;

  return 0;
}

// Component Interface
public interface IMessage
{
    string GetMessage();
}

// Concrete Component
public class SimpleMessage : IMessage
{
    private readonly string _message;

    public SimpleMessage(string message)
    {
        _message = message;
    }

    public string GetMessage()
    {
        return _message;
    }
}

// Decorator Abstract Class
public abstract class MessageDecorator : IMessage
{
    protected readonly IMessage _message;

    protected MessageDecorator(IMessage message)
    {
        _message = message;
    }

    public virtual string GetMessage()
    {
        return _message.GetMessage();
    }
}

// Concrete Decorators
public class EncryptionDecorator : MessageDecorator
{
    public EncryptionDecorator(IMessage message) : base(message) { }

    public override string GetMessage()
    {
        return "Encrypted: " + base.GetMessage();
    }
}

public class PriorityDecorator : MessageDecorator
{
    public PriorityDecorator(IMessage message) : base(message) { }

    public override string GetMessage()
    {
        return "Priority: " + base.GetMessage();
    }
}

// Example Usage
public class Program
{
    public static void Main(string[] args)
    {
        IMessage message = new SimpleMessage("Hello, World!");

        message = new EncryptionDecorator(message);
        message = new PriorityDecorator(message);

        Console.WriteLine(message.GetMessage()); // Output: Priority: Encrypted: Hello, World!
    }
}

// Component interface
interface Component {
  execute(): void;
}

// Base Component class
class BasicComponent implements Component {
  public execute(): void {
    console.log("BasicComponent executing...");
  }
}

// Decorator: Log execution
function logExecution(constructor: any) {
  return class extends constructor {
    execute() {
      console.log("Executing decorated method...");
      super.execute();
    }
  };
}

// Decorator: Throttle execution
function throttle(milliseconds: number) {
  return function (constructor: any) {
    return class extends constructor {
      private timeoutId: NodeJS.Timeout | null = null;

      execute() {
        if (!this.timeoutId) {
          super.execute();
          this.timeoutId = setTimeout(() => {
            this.timeoutId = null;
          }, milliseconds);
        }
      }
    };
  };
}

// Apply decorators
@logExecution
@throttle(500)
class EnhancedComponent extends BasicComponent {
  execute() {
    console.log("EnhancedComponent executing...");
    super.execute();
  }
}

// Usage
const enhanced = new EnhancedComponent();

enhanced.execute(); // Logs and throttles
enhanced.execute(); // Throttled
enhanced.execute(); // Throttled

setTimeout(() => {
  enhanced.execute(); // Executes after throttle
}, 600);

/**
 * Decorator Pattern Implementation in JavaScript
 */

// Base Component
const coffee = {
  cost: () => 5,
  description: () => "Simple coffee"
};

// Decorator base
const decorate = (base, ...decorators) => {
  return decorators.reduce((acc, decorator) => decorator(acc), base);
};

// Concrete Decorators
const milkDecorator = (coffee) => {
  return {
    cost: () => coffee.cost() + 2,
    description: () => `Coffee with milk - ${coffee.description()}`
  };
};

const sugarDecorator = (coffee) => {
  return {
    cost: () => coffee.cost() + 1,
    description: () => `Coffee with sugar - ${coffee.description()}`
  };
};

const whippedCreamDecorator = (coffee) => {
    return {
        cost: () => coffee.cost() + 3,
        description: () => `Coffee with whipped cream - ${coffee.description()}`
    };
}

// Usage
const myCoffee = decorate(coffee, milkDecorator, sugarDecorator);
const fancyCoffee = decorate(coffee, milkDecorator, whippedCreamDecorator, sugarDecorator);

console.log(myCoffee.description()); // Output: Coffee with milk - Simple coffee
console.log(myCoffee.cost());       // Output: 7

console.log(fancyCoffee.description()); // Output: Coffee with whipped cream - Coffee with milk - Simple coffee
console.log(fancyCoffee.cost());       // Output: 10

def add_greeting(func):
    """Adds a greeting prefix to the function's output."""
    def wrapper(*args, **kwargs):
        return "Hello, " + func(*args, **kwargs)
    return wrapper

def make_it_loud(func):
    """Converts the function's output to uppercase."""
    def wrapper(*args, **kwargs):
        return func(*args, **kwargs).upper()
    return wrapper

@add_greeting
@make_it_loud
def say_hello(name):
    """A simple function that returns a greeting."""
    return f"hello {name}"

if __name__ == "__main__":
    print(say_hello("world"))  # Output: HELLO, WORLD

// Component Interface
interface Coffee {
    String getDescription();
    double getCost();
}

// Concrete Component
class SimpleCoffee implements Coffee {
    @Override
    public String getDescription() {
        return "Simple coffee";
    }

    @Override
    public double getCost() {
        return 2.0;
    }
}

// Decorator Abstract Class
abstract class CoffeeDecorator implements Coffee {
    protected Coffee coffee;

    public CoffeeDecorator(Coffee coffee) {
        this.coffee = coffee;
    }

    @Override
    public String getDescription() {
        return coffee.getDescription();
    }

    @Override
    public double getCost() {
        return coffee.getCost();
    }
}

// Concrete Decorators
class MilkDecorator extends CoffeeDecorator {
    public MilkDecorator(Coffee coffee) {
        super(coffee);
    }

    @Override
    public String getDescription() {
        return coffee.getDescription() + ", with milk";
    }

    @Override
    public double getCost() {
        return coffee.getCost() + 0.5;
    }
}

class SugarDecorator extends CoffeeDecorator {
    public SugarDecorator(Coffee coffee) {
        super(coffee);
    }

    @Override
    public String getDescription() {
        return coffee.getDescription() + ", with sugar";
    }

    @Override
    public double getCost() {
        return coffee.getCost() + 0.2;
    }
}

// Example Usage
public class DecoratorExample {
    public static void main(String[] args) {
        Coffee coffee = new SimpleCoffee();
        System.out.println("Cost: $" + coffee.getCost() + ", Description: " + coffee.getDescription());

        coffee = new MilkDecorator(coffee);
        System.out.println("Cost: $" + coffee.getCost() + ", Description: " + coffee.getDescription());

        coffee = new SugarDecorator(coffee);
        System.out.println("Cost: $" + coffee.getCost() + ", Description: " + coffee.getDescription());
    }
}