/**
* @param array $request
* @param \ReflectionClass $class
* @param callable $nameMangling
*
* @return ConversionResult
*/
public function convert(array $request, \ReflectionClass $class, callable $nameMangling)
{
$ctx = new Context($this, $this->coercer, $nameMangling);
$object = $this->instance($class);
$setter = $this->setter($object);
$errors = [];
foreach ($class->getProperties() as $prop) {
$name = $nameMangling($prop->getName());
if (!isset($request[$name]) && !$this->reader->getPropertyAnnotation($prop, Optional::class)) {
$errors[] = new MissingFieldError($name);
continue;
} elseif (!\array_key_exists($name, $request)) {
continue;
}
$value = $request[$name];
$typeAnnotation = $this->reader->getPropertyAnnotation($prop, Type::class);
if ($value !== null && $typeAnnotation instanceof Type) {
try {
$result = $this->coercer->coerce($value, $typeAnnotation->type, $ctx);
} catch (CoercionException $e) {
throw ConverterException::in($class->getName(), $prop->getName(), $e);
}
$value = $result->getValue();
$errors = \array_merge($errors, $result->errorsInField($name));
$setter->set($prop->getName(), $value);
} elseif ($value === null) {
$setter->set($prop->getName(), null);
}
}
return ConversionResult::errors($errors, $object);
}
/**
* @inheritdoc
*/
public function coerce($value, $origType, array $typeParams, Context $ctx)
{
if (!\is_array($value)) {
return ConversionResult::error(new TypeError(\gettype($value), 'array'));
}
$errors = [];
if ($typeParams) {
$type = $typeParams[0];
$coerced = [];
$idx = 0;
foreach ($value as $v) {
$result = $ctx->coerce($v, $type);
if ($result->getErrors()) {
$errors = \array_merge($errors, $result->errorsInIdx($idx));
if ($result->getValue() === null) {
return ConversionResult::errors($errors);
}
}
$coerced[] = $result->getValue();
++$idx;
}
$value = $coerced;
} else {
$value = \array_values($value);
}
return ConversionResult::errors($errors, $value);
}
/**
* @inheritdoc
*/
public function coerce($value, $origType, array $typeParams, Context $ctx)
{
if (!\is_array($value)) {
return ConversionResult::error(new TypeError(\gettype($value), 'object'));
}
$errors = [];
if (\count($typeParams) === 1) {
// coerced values
$type = $typeParams[0];
$coerced = [];
foreach ($value as $k => $v) {
$result = $ctx->coerce($v, $type);
if ($result->getErrors()) {
$errors = array_merge($errors, $result->errorsInField($k));
if ($result->getValue() === null) {
return ConversionResult::errors($errors);
}
}
$coerced[$k] = $result->getValue();
}
$value = $coerced;
} elseif (\count($typeParams) === 2) {
// coerced keys and values
list($keyT, $valueT) = $typeParams;
if ($keyT !== "string" && $keyT !== "int") {
throw InvalidTypeException::from("Map<{$keyT}, {$valueT}>");
}
$coerced = [];
foreach ($value as $key => $val) {
$v = $ctx->coerce($val, $valueT);
$k = $ctx->coerce($key, $keyT);
if ($v->getErrors() || $k->getErrors()) {
$errors = array_merge($errors, $v->errorsInField($key), $k->errorsInField($key));
if ($v->getValue() === null || $k->getValue() === null) {
return ConversionResult::errors($errors);
}
}
$coerced[$k->getValue()] = $v->getValue();
}
$value = $coerced;
}
return ConversionResult::errors($errors, $value);
}
