Merge pull request #7165 from morozov/collections-in-tables

Use object collections in Table

Author: morozov

src/Schema/Collections/Exception/SetAlreadyContainsName.php

@@ -0,0 +1,20 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Doctrine\DBAL\Schema\Collections\Exception;
+
+use Doctrine\DBAL\Schema\Collections\Exception;
+use Doctrine\DBAL\Schema\Name;
+use LogicException;
+
+use function sprintf;
+
+/** @internal */
+final class SetAlreadyContainsName extends LogicException implements Exception
+{
+    public static function new(Name $name): self
+    {
+        return new self(sprintf('Set already contains name %s.', $name->toString()));
+    }
+}

src/Schema/Collections/Exception/SetDoesNotContainName.php

@@ -0,0 +1,20 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Doctrine\DBAL\Schema\Collections\Exception;
+
+use Doctrine\DBAL\Schema\Collections\Exception;
+use Doctrine\DBAL\Schema\Name;
+use LogicException;
+
+use function sprintf;
+
+/** @internal */
+final class SetDoesNotContainName extends LogicException implements Exception
+{
+    public static function new(Name $name): self
+    {
+        return new self(sprintf('Set does not contain name %s.', $name->toString()));
+    }
+}

src/Schema/Collections/NameSet.php

@@ -0,0 +1,46 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Doctrine\DBAL\Schema\Collections;
+
+use Doctrine\DBAL\Schema\Collections\Exception\SetAlreadyContainsName;
+use Doctrine\DBAL\Schema\Collections\Exception\SetDoesNotContainName;
+use Doctrine\DBAL\Schema\Name;
+use IteratorAggregate;
+
+/**
+ * A set of unique {@see Name}s.
+ *
+ * @internal
+ *
+ * @template N of Name
+ * @template-extends IteratorAggregate<int, N>
+ */
+interface NameSet extends IteratorAggregate
+{
+    /**
+     * Returns whether the set contains the given name.
+     *
+     * @phpstan-param N $name
+     */
+    public function contains(Name $name): bool;
+
+    /**
+     * Adds the given name to the set.
+     *
+     * @phpstan-param N $name
+     *
+     * @throws SetAlreadyContainsName If the set already contains the name.
+     */
+    public function add(Name $name): void;
+
+    /**
+     * Removes the given name from the set.
+     *
+     * @phpstan-param N $name
+     *
+     * @throws SetDoesNotContainName If the set does not contain the name.
+     */
+    public function remove(Name $name): void;
+}

src/Schema/Collections/OptionallyUnqualifiedNamedObjectSet.php

@@ -100,6 +100,39 @@ public function modify(UnqualifiedName $elementName, callable $modification): vo
         $this->replace($key, $position, $modification($this->elements[$position]));
     }
 
+    public function modifyByPosition(int $position, callable $modification): void
+    {
+        if (! isset($this->elements[$position])) {
+            return;
+        }
+
+        $current     = $this->elements[$position];
+        $currentName = $current->getObjectName();
+
+        $element = $modification($current);
+
+        if ($currentName !== null) {
+            $oldKey = $this->getKey($currentName);
+            $this->replace($oldKey, $position, $element);
+
+            return;
+        }
+
+        $newName = $element->getObjectName();
+        if ($newName !== null) {
+            $newKey = $this->getKey($newName);
+
+            if (isset($this->elementPositionsByKey[$newKey])) {
+                throw ObjectAlreadyExists::new($newName);
+            }
+
+            $this->elementPositionsByKey[$newKey] = $position;
+        }
+
+        // @phpstan-ignore assign.propertyType
+        $this->elements[$position] = $element;
+    }
+
     public function clear(): void
     {
         $this->elements = $this->elementPositionsByKey = [];

src/Schema/Collections/UnqualifiedNameSet.php

@@ -0,0 +1,69 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Doctrine\DBAL\Schema\Collections;
+
+use Doctrine\DBAL\Schema\Collections\Exception\SetAlreadyContainsName;
+use Doctrine\DBAL\Schema\Collections\Exception\SetDoesNotContainName;
+use Doctrine\DBAL\Schema\Name;
+use Doctrine\DBAL\Schema\Name\UnqualifiedName;
+use Traversable;
+
+use function strtolower;
+
+/**
+ * A set of unique {@see UnqualifiedName}s
+ *
+ * @internal
+ *
+ * @template-implements NameSet<UnqualifiedName>
+ */
+final class UnqualifiedNameSet implements NameSet
+{
+    /** @var array<string, UnqualifiedName> */
+    private array $elements = [];
+
+    public function contains(Name $name): bool
+    {
+        $key = $this->getKey($name);
+
+        return isset($this->elements[$key]);
+    }
+
+    public function add(Name $name): void
+    {
+        $key = $this->getKey($name);
+
+        if (isset($this->elements[$key])) {
+            throw SetAlreadyContainsName::new($name);
+        }
+
+        $this->elements[$key] = $name;
+    }
+
+    public function remove(Name $name): void
+    {
+        $key = $this->getKey($name);
+
+        if (! isset($this->elements[$key])) {
+            throw SetDoesNotContainName::new($name);
+        }
+
+        unset($this->elements[$key]);
+    }
+
+    /** @return Traversable<int, UnqualifiedName> */
+    public function getIterator(): Traversable
+    {
+        foreach ($this->elements as $element) {
+            yield $element;
+        }
+    }
+
+    /** @param UnqualifiedName $name */
+    private function getKey(Name $name): string
+    {
+        return strtolower($name->getIdentifier()->getValue());
+    }
+}

src/Schema/Collections/UnqualifiedNamedObjectSet.php

@@ -12,6 +12,7 @@
 
 use function array_combine;
 use function array_keys;
+use function array_map;
 use function array_search;
 use function array_values;
 use function assert;
@@ -106,6 +107,18 @@ public function getIterator(): Traversable
         }
     }
 
+    /**
+     * As long as there are mutable implementations of <code>NamedObject<UnqualifiedName></code>, cloning the set will
+     * require cloning its elements as well.
+     */
+    public function __clone()
+    {
+        $this->elements = array_map(
+            static fn (NamedObject $element): NamedObject => clone $element,
+            $this->elements,
+        );
+    }
+
     /**
      * Replaces the element corresponding to the old key with the provided element. The position of the element in the
      * set is preserved.