Add WeakClosure

Author: SerafimArts

src/ObservableCaptureSet.php

@@ -0,0 +1,62 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Boson\Component\WeakType;
+
+use Boson\Component\WeakType\Internal\ReferenceReleaseCallback;
+
+/**
+ * The implementation calls the {@see ObservableCaptureSet::watch()} `$onRelease`
+ * callback only if {@see ObservableCaptureSet} does not references to the object.
+ *
+ * @template TEntry of object = object
+ *
+ * @template-implements \IteratorAggregate<array-key, TEntry>
+ * @template-implements ObservableSetInterface<TEntry>
+ */
+final readonly class ObservableCaptureSet implements ObservableSetInterface, \IteratorAggregate
+{
+    /**
+     * @var \SplObjectStorage<TEntry, ReferenceReleaseCallback<TEntry>>
+     */
+    private \SplObjectStorage $memory;
+
+    public function __construct()
+    {
+        $this->memory = new \SplObjectStorage();
+    }
+
+    /**
+     * @param TEntry $entry
+     * @param \Closure(TEntry):void $onRelease
+     *
+     * @return TEntry
+     */
+    public function watch(object $entry, \Closure $onRelease): object
+    {
+        $this->memory[$entry] = new ReferenceReleaseCallback($entry, $onRelease);
+
+        return $entry;
+    }
+
+    public function detach(object $entry): void
+    {
+        unset($this->memory[$entry]);
+    }
+
+    public function getIterator(): \Traversable
+    {
+        foreach ($this->memory as $entry) {
+            yield $entry;
+        }
+    }
+
+    /**
+     * @return int<0, max>
+     */
+    public function count(): int
+    {
+        return $this->memory->count();
+    }
+}

src/ObservableMapInterface.php

@@ -0,0 +1,57 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Boson\Component\WeakType;
+
+/**
+ * Allows to store a set of objects with referenced values and track their
+ * destruction (react to GC cleanup).
+ *
+ * ```
+ * $map->watch($id, $ref, function (object $ref): void {
+ *     echo vsprintf('ID has been destroyed, something can be done with its reference %s(%d)', [
+ *         $ref::class,
+ *         spl_object_id($ref),
+ *     ]);
+ * ));
+ * ```
+ *
+ * @template TObservable of object = object
+ * @template TValue of object = object
+ *
+ * @template-extends \Traversable<TObservable, TValue>
+ */
+interface ObservableMapInterface extends \Countable, \Traversable
+{
+    /**
+     * @param TObservable $key
+     * @param TValue $value
+     * @param \Closure(TValue):void $onRelease
+     *
+     * @return TObservable
+     */
+    public function watch(object $key, object $value, \Closure $onRelease): object;
+
+    /**
+     * @param TObservable $key
+     *
+     * @return TValue|null
+     */
+    public function find(object $key): ?object;
+
+    /**
+     * @param TObservable $key
+     */
+    public function has(object $key): bool;
+
+    /**
+     * @param TObservable $key
+     */
+    public function detach(object $key): void;
+
+    /**
+     * @return int<0, max>
+     */
+    public function count(): int;
+}

src/ObservableSet.php

@@ -0,0 +1,67 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Boson\Component\WeakType;
+
+use Boson\Component\WeakType\Internal\ReferenceReleaseCallback;
+
+/**
+ * The implementation calls the {@see ObservableSet::watch()} `$onRelease`
+ * callback only if there are no references left to the object.
+ *
+ * @template TEntry of object = object
+ *
+ * @template-implements \IteratorAggregate<array-key, TEntry>
+ * @template-implements ObservableSetInterface<TEntry>
+ */
+final readonly class ObservableSet implements ObservableSetInterface, \IteratorAggregate
+{
+    /**
+     * @var \SplObjectStorage<TEntry, void>
+     */
+    private \SplObjectStorage $references;
+
+    /**
+     * @var \WeakMap<TEntry, ReferenceReleaseCallback<TEntry>>
+     */
+    private \WeakMap $memory;
+
+    public function __construct()
+    {
+        $this->references = new \SplObjectStorage();
+        $this->memory = new \WeakMap();
+    }
+
+    /**
+     * @param TEntry $entry
+     * @param \Closure(TEntry):void $onRelease
+     *
+     * @return TEntry
+     */
+    public function watch(object $entry, \Closure $onRelease): object
+    {
+        $this->memory[$entry] = new ReferenceReleaseCallback($entry, $onRelease);
+        $this->references->offsetSet($entry, null);
+
+        return $entry;
+    }
+
+    public function detach(object $entry): void
+    {
+        unset($this->memory[$entry], $this->references[$entry]);
+    }
+
+    public function getIterator(): \Traversable
+    {
+        return $this->references;
+    }
+
+    /**
+     * @return int<0, max>
+     */
+    public function count(): int
+    {
+        return $this->memory->count();
+    }
+}

src/ObservableSetInterface.php

@@ -0,0 +1,42 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Boson\Component\WeakType;
+
+/**
+ * Allows to store a set of objects and track their
+ * destruction (react to GC cleanup).
+ *
+ *  ```
+ *  $set->watch($object, function (ExampleObject $ref) {
+ *       echo vsprintf('ExampleObject(%d) has been destroyed', [
+ *           get_object_id($ref),
+ *       ]);
+ *  ));
+ *  ```
+ *
+ * @template TObservable of object = object
+ *
+ * @template-extends \Traversable<array-key, TObservable>
+ */
+interface ObservableSetInterface extends \Countable, \Traversable
+{
+    /**
+     * @param TObservable $entry
+     * @param \Closure(TObservable):void $onRelease
+     *
+     * @return TObservable
+     */
+    public function watch(object $entry, \Closure $onRelease): object;
+
+    /**
+     * @param TObservable $entry
+     */
+    public function detach(object $entry): void;
+
+    /**
+     * @return int<0, max>
+     */
+    public function count(): int;
+}

src/ObservableWeakMap.php

@@ -7,32 +7,21 @@
 use Boson\Component\WeakType\Internal\ReferenceReleaseCallback;
 
 /**
- * Allows to store a set of objects with referenced values and
- * track their destruction (react to GC cleanup).
+ * When adding an object using {@see ObservableWeakMap::watch()} method,
+ * this implementation does not increase its refcount.
  *
- * ```
- * // ObservableWeakMap<ExampleId, CData>
- * $map = new ObservableWeakMap();
- *
- * $map->watch($id, $data, function (CData $ref) {
- *     echo vsprintf('ID has been destroyed, something can be done with its reference %s(%d)', [
- *         $ref::class,
- *         get_object_id($ref),
- *     ]);
- * ));
- * ```
- *
- * @api
- *
- * @template TKey of object = object
+ * @template TObservable of object = object
  * @template TValue of object = object
  *
- * @template-implements \IteratorAggregate<TKey, TValue>
+ * @template-implements \IteratorAggregate<TObservable, TValue>
+ * @template-implements ObservableMapInterface<TObservable, TValue>
  */
-final readonly class ObservableWeakMap implements \IteratorAggregate, \Countable
+final readonly class ObservableWeakMap implements
+    ObservableMapInterface,
+    \IteratorAggregate
 {
     /**
-     * @var \WeakMap<TKey, ReferenceReleaseCallback<TValue>>
+     * @var \WeakMap<TObservable, ReferenceReleaseCallback<TValue>>
      */
     private \WeakMap $memory;
 
@@ -41,25 +30,13 @@ public function __construct()
         $this->memory = new \WeakMap();
     }
 
-    /**
-     * @param TKey $key
-     * @param TValue $value
-     * @param \Closure(TValue):void $onRelease
-     *
-     * @return TKey
-     */
     public function watch(object $key, object $value, \Closure $onRelease): object
     {
         $this->memory[$key] = new ReferenceReleaseCallback($value, $onRelease);
 
         return $key;
     }
 
-    /**
-     * @param TKey $key
-     *
-     * @return TValue|null
-     */
     public function find(object $key): ?object
     {
         if (!$this->memory->offsetExists($key)) {
@@ -69,6 +46,16 @@ public function find(object $key): ?object
         return $this->memory[$key]->reference;
     }
 
+    public function has(object $key): bool
+    {
+        return $this->memory->offsetExists($key);
+    }
+
+    public function detach(object $key): void
+    {
+        unset($this->memory[$key]);
+    }
+
     public function getIterator(): \Traversable
     {
         foreach ($this->memory as $key => $ref) {

src/ObservableWeakSet.php

@@ -7,25 +7,18 @@
 use Boson\Component\WeakType\Internal\ReferenceReleaseCallback;
 
 /**
- * Allows to store a set of objects and track their
- * destruction (react to GC cleanup).
+ * When adding an object using {@see ObservableWeakSet::watch()} method,
+ * this implementation does not increase its refcount.
  *
- * ```
- * // ObservableWeakSet<ExampleObject>
- * $set = new ObservableWeakSet();
- *
- * $set->watch($object, function (ExampleObject $ref) {
- *      echo vsprintf('ExampleObject(%d) has been destroyed', [
- *          get_object_id($ref),
- *      ]);
- * ));
- * ```
+ * The implementation calls the {@see ObservableWeakSet::watch()} `$onRelease`
+ * callback only if there are no references left to the object.
  *
  * @template TEntry of object = object
  *
  * @template-implements \IteratorAggregate<array-key, TEntry>
+ * @template-implements ObservableSetInterface<TEntry>
  */
-final readonly class ObservableWeakSet implements \IteratorAggregate, \Countable
+final readonly class ObservableWeakSet implements ObservableSetInterface, \IteratorAggregate
 {
     /**
      * @var \WeakMap<TEntry, ReferenceReleaseCallback<TEntry>>
@@ -50,6 +43,11 @@ public function watch(object $entry, \Closure $onRelease): object
         return $entry;
     }
 
+    public function detach(object $entry): void
+    {
+        unset($this->memory[$entry]);
+    }
+
     public function getIterator(): \Traversable
     {
         foreach ($this->memory as $key => $_) {