Newsgroups: php.internals
Path: news.php.net
Xref: news.php.net php.internals:112473
To: internals@lists.php.net
References: <d1c4689e-9120-4e90-837c-a1b3eac63cd6@www.fastmail.com>
 <79044037-4cd4-4065-a3c1-39a4deea3e09@www.fastmail.com>
 <763bd813-88f4-4981-820d-a1e50e4c2e1e@www.fastmail.com>
Message-ID: <98d8351e-8e7d-dc09-c466-ad986ebe990a@dennis.birkholz.biz>
Date: Tue, 8 Dec 2020 23:04:04 +0100
User-Agent: Mozilla/5.0 (X11; Linux x86_64; rv:78.0) Gecko/20100101
 Thunderbird/78.5.1
MIME-Version: 1.0
In-Reply-To: <763bd813-88f4-4981-820d-a1e50e4c2e1e@www.fastmail.com>
Content-Type: text/plain; charset=utf-8
Content-Language: en-US
Content-Transfer-Encoding: 7bit
Subject: Re: [PHP-DEV] [RFC] Enumerations
From: php@dennis.birkholz.biz (Dennis Birkholz)

Am 08.12.20 um 18:40 schrieb Larry Garfield:
> For serialization, we'll introduce a new serialization marker, enum, which will make it feasible too round-trip an enum while maintaining singleton-ness.  More specifically, the deserialize routine would essentially become $type::from($value), where $type and $value are pulled from the serialized version.

I wonder whether this mechanism could be generalized to a serialization
mechanism that would allow e.g. Database Repositories to pull entities
from a database upon unserialization.

My example would something like this (simplified):

interface IdentifierBasedSerializable {
    static function serializeToIdentifier(self $object) : string;
    static function unserializeFromIdentifier(string $identifier) : self
}


class ExternallyStoredEntity implements IdentifierBasedSerializable {
    static function serializeToIdentifier(self $object) : string {
        return $object->id;
    }

    static function unserializeFromIdentifier(string $identifier): self{
        if (!\array_key_exists($identifier, self::$objectCache)) {
            self::$objectCache[$identifier] = new self($identifier);
        }
        return self::$objectCache[$identifier];
    }

    private static $objectCache = [];
    public string $id;

    public function __construct(string $id) { $this->id = $id; }
}

Until now it is not possible to unserialize an object to the canonical
instance created earlier in the program execution.
Serialization and subsequent unserialization breaks object identity
($a->id === $b->id <=> $a === $b) that is often desired when working
with objects that represent external entities. The list of allowed enum
values is in this regard a very simple database of identifiers.

I know that passing a complex serialization string to a static
unserialization factory method has the serious problem that circular
references can not be handled. But using only an identifier as the sole
contents of the serialization string avoids this problem entirely.

Greets
Dennis