Looking for a design pattern to process or batch process - php

Question

I have the following structure. Until this point each element could be processed one by one.
interface ProcessingStrategyInterface
{
public function process(Element $object): string;
}
class SomeListener
{
/**
* #var array<string, ProcessingStrategyInterface>
*/
protected array $processers;
public function __invoke(DocumentContent $event)
{
/**
* #var array<string, list<Element>> $elements
*/
$elementGroups = $event->getDynamicElements();
foreach ($elementGroups as $type => $elements) {
$processer = $this->processers[$type];
foreach ($elements as $element) {
$result = $processer->process($element);
}
}
// [...]
}
}
Now I have to add a new type of processer which takes the whole list<Element>, and processes them as one, then gives back a string result. For this a new interface could be defined.
interface BatchProcessingStrategyInterface
{
/**
* #param list<Element> $elements
*/
public function batchProcess(array $elements): string;
}
This solution I feel a little bit off:
class SomeListener
{
/**
* #var array<string, ProcessingStrategyInterface|BatchProcessingStrategyInterface>
*/
protected array $processers;
public function __invoke(DocumentContent $event)
{
/**
* #var array<string, list<Element>> $elements
*/
$elementGroups = $event->getDynamicElements();
foreach ($elementGroups as $type => $elements) {
$processer = $this->processers[$type];
if ($processer instanceof BatchProcessingStrategyInterface) {
$result = $processer->batchProcess($elements);
} else {
foreach ($elements as $element) {
$result = $processer->process($element);
}
}
}
// [...]
}
}
I'm wondering if there is a way to solve this in a 100% type-strict way? What I want to achieve is to have single types everywhere by calling them the following way:
class SomeListener
{
/**
* #var array<string, ProcessingStrategyInterface>
*/
protected array $processers;
public function __invoke(DocumentContent $event)
{
/**
* #var array<string, list<Element>> $elements
*/
$elementGroups = $event->getDynamicElements();
foreach ($elementGroups as $type => $elements) {
$processer = $this->processers[$type];
$result = $processer->process($elements);
}
// [...]
}
}

Answer 1

I just came up with a solution with which I can keep to code type-hinted. Basically I just moved the logic a level up into the processor.
interface ProcessingStrategyInterface
{
/**
* #param list<Element> $elements
*/
public function process(array $elements): string;
}
class ProcesserA implements ProcessingStrategyInterface
{
public function process(array $elements): string
{
foreach ($elements as $element) {
$this->processElement($element);
}
}
protected function processElement(Element $element): string
{
// logic
}
}
class BatchProcesserA implements ProcessingStrategyInterface
{
public function process(array $elements): string
{
foreach ($elements as $element) {
$this->processElement($element);
}
}
}

Answer 2

I am not sure, but if I were you, I would make smth like this:
interface ProcessingStrategyInterface {
/**
* #param Element $elements
*/
public function process( Element $elements ): string;
}
interface BatchProcessingStrategyInterface
{
/**
* #param list<Element> $elements
*/
public function process(array $elements): string;
}
class ProcesserA implements ProcessingStrategyInterface {
public function process( Element $element ): string {
// logic
}
}
class BatchProcesserA implements BatchProcessingStrategyInterface {
private ProcessingStrategyInterface $strategy;
public function process( array $elements ): string {
foreach ( $elements as $element ) {
$this->strategy->processElement( $element );
}
}
}