Cache type iso in ElementEncoder, refactor ElementValueBuilder and ElementValueReader

ElementEncoder now captures the type iso once via $typeEncoder->iso($context)
and passes it to ElementValueBuilder::fromIso() and ElementValueReader::forIso(),
avoiding redundant iso rebuilds on every encode/decode invocation.

ElementValueBuilder:
- Constructor is now private; use fromEncoder() or fromIso() static factories
- Stores a list of builder closures composed at construction time
- Value encoding happens lazily via a valueProvider closure during __invoke
- Removed deprecated resolveXsiTypeForValue/shouldIncludeXsiTargetNamespace

ElementValueReader:
- Added forEncoder(context, encoder, element) and forIso(iso, element)
  static methods for callsites with or without a cached iso
- __invoke delegates to forEncoder for backwards compatibility

SoapObjectEncoder, ApacheMapEncoder: switched to ElementValueReader::forEncoder().

Author: veewee

benchmarks/BenchSoapClient.php

@@ -14,7 +14,7 @@ class BenchSoapClient extends \SoapClient
 {
     public ?string $mockResponse = null;
 
-    public function __doRequest(string $request, string $location, string $action, int $version, bool $oneWay = false): ?string
+    public function __doRequest(string $request, string $location, string $action, int $version, bool $oneWay = false, ?string $uriParserClass = null): ?string
     {
         return $this->mockResponse;
     }

src/Encoder/ElementEncoder.php

@@ -32,21 +32,22 @@ public function iso(Context $context): Iso
             ? $this->typeEncoder->enhanceElementContext($context)
             : $context;
 
+        $typeIso = $typeEncoder->iso($context);
+
         return new Iso(
             /**
              * @psalm-param mixed $raw
              */
             static fn (mixed $raw): string => (new XsdTypeXmlElementWriter())(
                 $context,
-                (new ElementValueBuilder($context, $typeEncoder, $raw))
+                ElementValueBuilder::fromIso($context, $typeEncoder, $typeIso, $raw)
             ),
             /**
              * @psalm-param non-empty-string|Element $xml
              * @psalm-return mixed
              */
-            static fn (Element|string $xml): mixed => (new ElementValueReader())(
-                $context,
-                $typeEncoder,
+            static fn (Element|string $xml): mixed => ElementValueReader::forIso(
+                $typeIso,
                 ($xml instanceof Element ? $xml : Element::fromString($xml))->element()
             )
         );

src/Encoder/SoapEnc/ApacheMapEncoder.php

@@ -87,7 +87,7 @@ private function decodeArray(Context $context, Element $value): array
             static function (array $map, DOMElement $item) use ($context, $xpath): array {
                 $key = $xpath->evaluate('string(./key)', string(), $item);
                 /** @psalm-var mixed $value */
-                $value = (new ElementValueReader())(
+                $value = ElementValueReader::forEncoder(
                     $context->withType(XsdType::any()),
                     ScalarTypeEncoder::default(),
                     assert_element($xpath->querySingle('./value', $item))

src/Encoder/SoapEnc/SoapObjectEncoder.php

@@ -78,7 +78,7 @@ private function decodeArray(Context $context, Element $value): object
             static function (array $map, DOMElement $item) use ($context): array {
                 $key = $item->localName ?? 'unkown';
                 /** @psalm-var mixed $value */
-                $value = (new ElementValueReader())(
+                $value = ElementValueReader::forEncoder(
                     $context->withType(XsdType::any()),
                     ScalarTypeEncoder::default(),
                     $item

src/Xml/Reader/ElementValueReader.php

@@ -6,6 +6,7 @@
 use DOMElement;
 use Soap\Encoding\Encoder\Context;
 use Soap\Encoding\Encoder\XmlEncoder;
+use VeeWee\Reflecta\Iso\Iso;
 use function Psl\Type\string;
 use function VeeWee\Xml\Dom\Locator\Node\value as readValue;
 
@@ -20,8 +21,28 @@ public function __invoke(
         XmlEncoder $encoder,
         DOMElement $element
     ): mixed {
+        return self::forEncoder($context, $encoder, $element);
+    }
+
+    /**
+     * @param XmlEncoder<mixed, string> $encoder
+     * @psalm-return mixed
+     */
+    public static function forEncoder(Context $context, XmlEncoder $encoder, DOMElement $element): mixed
+    {
         return $encoder->iso($context)->from(
             readValue($element, string())
         );
     }
+
+    /**
+     * @param Iso<mixed, string> $iso
+     * @psalm-return mixed
+     */
+    public static function forIso(Iso $iso, DOMElement $element): mixed
+    {
+        return $iso->from(
+            readValue($element, string())
+        );
+    }
 }

src/Xml/Writer/ElementValueBuilder.php

@@ -3,10 +3,12 @@
 
 namespace Soap\Encoding\Xml\Writer;
 
+use Closure;
 use Generator;
 use Soap\Encoding\Encoder\Context;
 use Soap\Encoding\Encoder\Feature;
 use Soap\Encoding\Encoder\XmlEncoder;
+use VeeWee\Reflecta\Iso\Iso;
 use XMLWriter;
 use function VeeWee\Xml\Writer\Builder\cdata;
 use function VeeWee\Xml\Writer\Builder\children;
@@ -15,67 +17,61 @@
 final class ElementValueBuilder
 {
     /**
-     * @param XmlEncoder<mixed, string> $encoder
-     * @psalm-param mixed $value
+     * @param list<Closure(XMLWriter): Generator<bool>> $builders
      */
-    public function __construct(
-        private readonly Context $context,
-        private readonly XmlEncoder $encoder,
-        private readonly mixed $value
+    private function __construct(
+        private readonly array $builders,
     ) {
     }
 
     /**
-     * @return Generator<bool>
+     * @param XmlEncoder<mixed, string> $encoder
+     * @psalm-param mixed $value
      */
-    public function __invoke(XMLWriter $writer): Generator
+    public static function fromEncoder(Context $context, XmlEncoder $encoder, mixed $value): self
     {
-        yield from children([
-            $this->buildXsiType(...),
-            $this->buildValue(...),
-        ])($writer);
+        return new self([
+            XsiAttributeBuilder::forEncodedValue($context, $encoder, $value),
+            self::valueWriter($encoder, static fn (): string => $encoder->iso($context)->to($value)),
+        ]);
     }
 
     /**
-     * @return Generator<bool>
+     * @param XmlEncoder<mixed, string> $encoder
+     * @param Iso<mixed, string> $iso
+     * @psalm-param mixed $value
      */
-    private function buildXsiType(XMLWriter $writer): Generator
+    public static function fromIso(Context $context, XmlEncoder $encoder, Iso $iso, mixed $value): self
     {
-        yield from XsiAttributeBuilder::forEncodedValue(
-            $this->context,
-            $this->encoder,
-            $this->value,
-        )($writer);
+        return new self([
+            XsiAttributeBuilder::forEncodedValue($context, $encoder, $value),
+            self::valueWriter($encoder, static fn (): string => $iso->to($value)),
+        ]);
     }
 
     /**
-     * @deprecated Use XsiAttributeBuilder::resolveXsiTypeForValue() instead. Will be removed in 1.0.0.
+     * @return Generator<bool>
      */
-    public static function resolveXsiTypeForValue(Context $context, mixed $value): string
+    public function __invoke(XMLWriter $writer): Generator
     {
-        return XsiAttributeBuilder::resolveXsiTypeForValue($context, $value);
+        yield from children($this->builders)($writer);
     }
 
     /**
-     * @deprecated Use XsiAttributeBuilder::shouldIncludeXsiTargetNamespace() instead. Will be removed in 1.0.0.
+     * @param XmlEncoder<mixed, string> $encoder
+     * @param Closure(): string $valueProvider
+     *
+     * @return Closure(XMLWriter): Generator<bool>
      */
-    public static function shouldIncludeXsiTargetNamespace(Context $context): bool
+    private static function valueWriter(XmlEncoder $encoder, Closure $valueProvider): Closure
     {
-        return XsiAttributeBuilder::shouldIncludeXsiTargetNamespace($context);
-    }
+        $isCData = $encoder instanceof Feature\CData;
 
-    /**
-     * @return Generator<bool>
-     */
-    private function buildValue(XMLWriter $writer): Generator
-    {
-        $encoded = $this->encoder->iso($this->context)->to($this->value);
+        return static function (XMLWriter $writer) use ($isCData, $valueProvider): Generator {
+            $encoded = $valueProvider();
+            $builder = $isCData ? cdata(value($encoded)) : value($encoded);
 
-        $builder = match (true) {
-            $this->encoder instanceof Feature\CData => cdata(value($encoded)),
-            default => value($encoded)
+            yield from $builder($writer);
         };
-
-        yield from $builder($writer);
     }
 }