Компоновщик

<?php
/**
* Базовый класс Компонент объявляет общие операции как для простых, так и для
* сложных объектов структуры.
*/

abstract class Component
{
    /**
    * @var Component|null
    */
    protected $parent;

    /**
    * При необходимости базовый Компонент может объявить интерфейс для
    * установки и получения родителя компонента в древовидной структуре. Он
    * также может предоставить некоторую реализацию по умолчанию для этих
    * методов.
    */
    public function setParent(?Component $parent)
    {
        $this->parent = $parent;
    }

    public function getParent(): Component
    {
        return $this->parent;
    }

    /**
    * В некоторых случаях целесообразно определить операции управления
    * потомками прямо в базовом классе Компонент. Таким образом, вам не нужно
    * будет предоставлять конкретные классы компонентов клиентскому коду, даже
    * во время сборки дерева объектов. Недостаток такого подхода в том, что эти
    * методы будут пустыми для компонентов уровня листа.
    */
    public function add(Component $component): void { }

    public function remove(Component $component): void { }

    /**
    * Вы можете предоставить метод, который позволит клиентскому коду понять,
    * может ли компонент иметь вложенные объекты.
    */
    public function isComposite(): bool
    {
        return false;
    }

    /**
    * Базовый Компонент может сам реализовать некоторое поведение по умолчанию
    * или поручить это конкретным классам, объявив метод, содержащий поведение
    * абстрактным.
    */
    abstract public function operation(): string;
}

/**
* Класс Лист представляет собой конечные объекты структуры. Лист не может иметь
* вложенных компонентов.
*
* Обычно объекты Листьев выполняют фактическую работу, тогда как объекты
* Контейнера лишь делегируют работу своим подкомпонентам.
*/

class Leaf extends Component
{
    public function operation(): string
    {
        return "Leaf";
    }
}

/**
* Класс Контейнер содержит сложные компоненты, которые могут иметь вложенные
* компоненты. Обычно объекты Контейнеры делегируют фактическую работу своим
* детям, а затем «суммируют» результат.
*/

class Composite extends Component
{
    /**
    * @var \SplObjectStorage
    */
    protected $children;

    public function __construct()
    {
        $this->children = new \SplObjectStorage();
    }

    /**
    * Объект контейнера может как добавлять компоненты в свой список вложенных
    * компонентов, так и удалять их, как простые, так и сложные.
    */
    public function add(Component $component): void
    {
        $this->children->attach($component);
        $component->setParent($this);
    }

    public function remove(Component $component): void
    {
        $this->children->detach($component);
        $component->setParent(null);
    }

    public function isComposite(): bool
    {
        return true;
    }

    /**
    * Контейнер выполняет свою основную логику особым образом. Он проходит
    * рекурсивно через всех своих детей, собирая и суммируя их результаты.
    * Поскольку потомки контейнера передают эти вызовы своим потомкам и так
    * далее, в результате обходится всё дерево объектов.
    */
    public function operation(): string
    {
        $results = [];
        foreach ($this->children as $child) {
            $results[] = $child->operation();
        }
        return "Branch(" . implode("+", $results) . ")";
    }
}

/**
* Клиентский код работает со всеми компонентами через базовый интерфейс.
*/

function clientCode(Component $component)
{
    // ...
    echo "RESULT: " . $component->operation();
    // ...
}

/**
* Таким образом, клиентский код может поддерживать простые компоненты-листья...
*/
$simple = new Leaf();
echo "Client: I've got a simple component:\n";
clientCode($simple);
echo "\n\n";

/**
* ...а также сложные контейнеры.
*/
$tree = new Composite();
$branch1 = new Composite();
$branch1->add(new Leaf());
$branch1->add(new Leaf());
$branch2 = new Composite();
$branch2->add(new Leaf());
$tree->add($branch1);
$tree->add($branch2);
echo "Client: Now I've got a composite tree:\n";
clientCode($tree);
echo "\n\n";

/**
* Благодаря тому, что операции управления потомками объявлены в базовом классе
* Компонента, клиентский код может работать как с простыми, так и со сложными
* компонентами, вне зависимости от их конкретных классов.
*/

function clientCode2(Component $component1, Component $component2)
{
    // ...
    if ($component1->isComposite()) {
        $component1->add($component2);
    }
    echo "RESULT: " . $component1->operation();
    // ...
}

echo "Client: I don't need to check the components classes even when managing the tree:\n";
clientCode2($tree, $simple);

<?php
/**
* Базовый класс Компонент объявляет интерфейс для всех конкретных компонентов,
* как простых, так и сложных.
*
* В нашем примере мы сосредоточимся на поведении рендеринга элементов DOM.
*/

abstract class FormElement
{
    /**
    * Можно предположить, что всем элементам DOM будут нужны эти 3 поля.
    */
    protected $name;
    protected $title;
    protected $data;

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

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

    public function setData($data): void
    {
        $this->data = $data;
    }

    public function getData(): array
    {
        return $this->data;
    }

    /**
    * Каждый конкретный элемент DOM должен предоставить свою реализацию
    * рендеринга, но мы можем с уверенностью предположить, что все они будут
    * возвращать строки.
    */
    abstract public function render(): string;
}

/**
* Это компонент-Лист. Как и все Листья, он не может иметь вложенных
* компонентов.
*/

class Input extends FormElement
{
    private $type;

    public function __construct(string $name, string $title, string $type)
    {
        parent::__construct($name, $title);
        $this->type = $type;
    }

    /**
    * Поскольку у компонентов-Листьев нет вложенных компонентов, которые могут
    * выполнять за них основную часть работы, обычно Листья делают большую
    * часть тяжёлой работы внутри паттерна Компоновщик.
    */
    public function render(): string
    {
        return "<label for=\"{$this->name}\">{$this->title}</label>\n" .
            "<input name=\"{$this->name}\" type=\"{$this->type}\" value=\"{$this->data}\">\n";
    }
}

/**
* Базовый класс Контейнер реализует инфраструктуру для управления дочерними
* объектами, повторно используемую всеми Конкретными Контейнерами.
*/ 

abstract class FieldComposite extends FormElement
{
    /**
    * @var FormElement[]
    */
    protected $fields = [];

    /**
    * Методы добавления/удаления подобъектов.
    */
    public function add(FormElement $field): void
    {
        $name = $field->getName();
        $this->fields[$name] = $field;
    }

    public function remove(FormElement $component): void
    {
        $this->fields = array_filter($this->fields, function ($child) use ($component) {
            return $child != $component;
        });
    }

    /**
    * В то время как метод Листа просто выполняет эту работу, метод Контейнера
    * почти всегда должен учитывать его подобъекты.
    *
    * В этом случае контейнер может принимать структурированные данные.
    *
    * @param array $data
    */
    public function setData($data): void
    {
        foreach ($this->fields as $name => $field) {
            if (isset($data[$name])) {
                $field->setData($data[$name]);
            }
        }
    }

    /**
    * Та же логика применима и к получателю. Он возвращает структурированные
    * данные самого контейнера (если они есть), а также все дочерние данные.
    */
    public function getData(): array
    {
        $data = [];
        foreach ($this->fields as $name => $field) {
            $data[$name] = $field->getData();
        }
        return $data;
    }

    /**
    * Базовая реализация рендеринга Контейнера просто объединяет результаты
    * всех дочерних элементов. Конкретные Контейнеры смогут повторно
    * использовать эту реализацию в своих реальных реализациях рендеринга.
    */
    public function render(): string
    {
        $output = "";
        foreach ($this->fields as $name => $field) {
            $output .= $field->render();
        }
        return $output;
    }
}

/**
* Элемент fieldset представляет собой Конкретный Контейнер.
*/ 

class Fieldset extends FieldComposite
{
    public function render(): string
    {
        // Обратите внимание, как комбинированный результат рендеринга потомков
        // включается в тег fieldset.
        $output = parent::render();
        return "<fieldset><legend>{$this->title}</legend>\n$output</fieldset>\n";
    }
}

/**
* Так же как и элемент формы.
*/

class Form extends FieldComposite
{
    protected $url;

    public function __construct(string $name, string $title, string $url)
    {
        parent::__construct($name, $title);
        $this->url = $url;
    }

    public function render(): string
    {
        $output = parent::render();
        return "<form action=\"{$this->url}\">\n<h3>{$this->title}</h3>\n$output</form>\n";
    }
}

/**
* Клиентский код получает удобный интерфейс для построения сложных древовидных
* структур.
*/

function getProductForm(): FormElement
{
    $form = new Form('product', "Add product", "/product/add");
    $form->add(new Input('name', "Name", 'text'));
    $form->add(new Input('description', "Description", 'text'));

    $picture = new Fieldset('photo', "Product photo");
    $picture->add(new Input('caption', "Caption", 'text'));
    $picture->add(new Input('image', "Image", 'file'));
    $form->add($picture);

    return $form;
}

/**
* Структура формы может быть заполнена данными из разных источников. Клиент не
* должен проходить через все поля формы, чтобы назначить данные различным
* полям, так как форма сама может справиться с этим.
*/

function loadProductData(FormElement $form)
{
    $data = [
        'name' => 'Apple MacBook',
        'description' => 'A decent laptop.',
        'photo' => [
            'caption' => 'Front photo.',
            'image' => 'photo1.png',
        ],
    ];
    $form->setData($data);
}

/**
* Клиентский код может работать с элементами формы, используя абстрактный
* интерфейс. Таким образом, не имеет значения, работает ли клиент с простым
* компонентом или сложным составным деревом.
*/

function renderProduct(FormElement $form)
{
    // ..
    echo $form->render();
    // ..
}

$form = getProductForm();
loadProductData($form);
renderProduct($form);

<?php
interface FileSystemNode {
    public function getSize(): int;
    public function printTree(int $indent = 0): void;
    public function search(string $name): array;
}

// TODO: реализовать File implements FileSystemNode:
// - __construct(string $name, int $size)
// - getSize() -> возвращает $size
// - printTree($indent) -> выводит str_repeat('  ', $indent) . "📄 name (size bytes)"
// - search($name) -> [$this] если $this->name === $name, иначе []

// TODO: реализовать Directory implements FileSystemNode:
// - __construct(string $name)
// - add(FileSystemNode $node), remove(FileSystemNode $node)
// - getSize() -> сумма размеров всех дочерних узлов
// - printTree($indent) -> str_repeat('  ', $indent) . "📁 name/" и рекурсия по детям
// - search($name) -> собирает совпадения по всему дереву

// Ожидаемый клиентский код:
// $root = new Directory('project');
// $src = new Directory('src');
// $src->add(new File('main.py', 1200));
// $src->add(new File('utils.py', 800));
// $tests = new Directory('tests');
// $tests->add(new File('test_main.py', 600));
// $root->add($src);
// $root->add($tests);
// $root->add(new File('README.md', 300));

// $root->printTree();
// echo "Общий размер: " . $root->getSize() . " байт\n";

<?php
interface CartItem {
    public function totalPrice(): float;
    public function describe(int $indent = 0): string;
}

// TODO: реализовать Product implements CartItem:
// - __construct(string $name, float $price, int $qty = 1)
// - totalPrice() -> $price * $qty
// - describe($indent) -> str_repeat('  ', $indent) . "{name} x{qty} = {total} руб."

// TODO: реализовать Bundle implements CartItem:
// - __construct(string $name, float $discountPct = 0.0)
// - add(CartItem $item), remove(CartItem $item)
// - totalPrice() -> сумма детей * (1 - discountPct / 100)
// - describe($indent) -> выводит название, скидку и рекурсивно детей

// Ожидаемый клиентский код:
// $officeKit = new Bundle('Офисный набор', discountPct: 10);
// $officeKit->add(new Product('Ручка', 50, qty: 3));
// $officeKit->add(new Product('Тетрадь', 80, qty: 2));

// $gaming = new Bundle('Игровой комплект', discountPct: 5);
// $gaming->add(new Product('Мышь', 2500));
// $gaming->add(new Product('Коврик', 800));
// $gaming->add($officeKit);

// $cart = new Bundle('Корзина');
// $cart->add($gaming);
// $cart->add(new Product('HDMI кабель', 350));

// echo $cart->describe();
// echo "Итого: " . number_format($cart->totalPrice(), 2) . " руб.\n";

<?php
interface OrgUnit {
    public function getSalaryBudget(): float;
    public function getHeadcount(): int;
    public function printStructure(int $indent = 0): void;
}

// TODO: реализовать Employee implements OrgUnit:
// - __construct(string $name, string $position, float $salary)
// - getSalaryBudget() -> $salary
// - getHeadcount() -> 1
// - printStructure($indent) -> выводит имя, должность и зарплату

// TODO: реализовать Department implements OrgUnit:
// - __construct(string $name)
// - add(OrgUnit $unit), remove(OrgUnit $unit)
// - getSalaryBudget() -> сумма бюджетов всех дочерних узлов
// - getHeadcount() -> сумма числа сотрудников всех дочерних узлов
// - printStructure($indent) -> "[{name}]" и рекурсия по детям

// Ожидаемый клиентский код:
// $dev = new Department('Разработка');
// $dev->add(new Employee('Анна', 'Tech Lead', 250000));
// $dev->add(new Employee('Иван', 'Backend Dev', 180000));

// $qa = new Department('QA');
// $qa->add(new Employee('Пётр', 'QA Lead', 200000));
// $qa->add(new Employee('Света', 'QA Engineer', 150000));

// $it = new Department('IT-дирекция');
// $it->add($dev);
// $it->add($qa);
// $it->add(new Employee('Алексей', 'CTO', 400000));

// $it->printStructure();
// echo "Бюджет IT: " . number_format($it->getSalaryBudget(), 0, '.', ' ') . " руб.\n";
// echo "Сотрудников: " . $it->getHeadcount() . "\n";

<?php
interface MenuComponent {
    public function printMenu(int $indent = 0): void;
    public function getTotalItems(): int;
    public function filterVegetarian(): ?MenuComponent;
}

// TODO: реализовать MenuItem implements MenuComponent:
// - __construct(string $name, string $description, float $price, bool $vegetarian = false)
// - printMenu($indent) -> выводит название, цену и "(вег.)" если $vegetarian
// - getTotalItems() -> 1
// - filterVegetarian() -> $this если $vegetarian, иначе null

// TODO: реализовать MenuSection implements MenuComponent:
// - __construct(string $name)
// - add(MenuComponent $component), remove(MenuComponent $component)
// - printMenu($indent) -> выводит название секции и рекурсивно детей
// - getTotalItems() -> сумма getTotalItems() всех детей
// - filterVegetarian() -> новую MenuSection только с вегетарианскими детьми
//   (если нет вегетарианских детей — возвращает null)

// Ожидаемый клиентский код:
// $menu = new MenuSection('Главное меню');
// $breakfast = new MenuSection('Завтраки');
// $breakfast->add(new MenuItem('Овсянка', 'С ягодами', 290, vegetarian: true));
// $breakfast->add(new MenuItem('Яичница', 'С беконом', 350));
// $breakfast->add(new MenuItem('Авокадо тост', 'На ржаном хлебе', 420, vegetarian: true));

// $mains = new MenuSection('Основные блюда');
// $mains->add(new MenuItem('Стейк', 'Говядина рибай', 1800));
// $mains->add(new MenuItem('Паста примавера', 'Овощи и соус песто', 650, vegetarian: true));

// $menu->add($breakfast);
// $menu->add($mains);

// $menu->printMenu();
// echo "\nВсего позиций: " . $menu->getTotalItems() . "\n";
// $vegMenu = $menu->filterVegetarian();
// echo "\n--- Вегетарианское меню ---\n";
// $vegMenu->printMenu();