/**
* @param array $transformed
* @param string $type
* @return object
* @throws \Exception
*/
protected function revertObject($transformed, $type)
{
$class = new \ReflectionClass($type);
$instance = $class->newInstanceWithoutConstructor();
if (!is_array($transformed)) {
throw new \Exception("Error while reverting [{$type}]. Input is not an array: " . ValuePrinter::serialize($transformed));
}
$reader = new PropertyReader($this->types, $class->getName());
$properties = [];
foreach ($reader->readState() as $property) {
$properties[] = $property->name();
if (array_key_exists($property->name(), $transformed)) {
$value = new TypedValue($transformed[$property->name()], $property->type());
$transformer = $this->transformers->toRevert($value);
$property->set($instance, $transformer->revert($value));
}
}
foreach ($transformed as $key => $value) {
if (!in_array($key, $properties)) {
$transformer = $this->transformers->toRevert($value);
$instance->{$key} = $transformer->revert($value);
}
}
return $instance;
}
/**
* @param TypedValue $transformed
* @return object
*/
public function revert($transformed)
{
/** @var ClassType $type */
$type = $transformed->getType();
$array = [ObjectTransformer::TYPE_KEY => $type->getClass(), ObjectTransformer::DATA_KEY => $transformed->getValue()];
return $this->transformers->toRevert($array)->revert($array);
}
/**
* @param string $key
* @return mixed
* @throws \Exception|NotFoundException
*/
public function read($key)
{
$serialized = $this->readSerialized($key);
$inflated = $this->serializer->inflate($serialized);
$value = new TypedValue($inflated, $this->type);
$reverted = $this->transformers->toRevert($value)->revert($value);
return $reverted;
}
/**
* @param TypedValue $typedArray
* @return array
*/
public function revert($typedArray)
{
$reverted = [];
foreach ($typedArray->getValue() as $key => $value) {
$typedValue = $this->typedItem($typedArray->getType(), $value);
$reverted[$key] = $this->transformers->toRevert($typedValue)->revert($typedValue);
}
return $reverted;
}
/**
* @param array $array
* @return array
*/
public function revert($array)
{
$reverted = [];
foreach ($array as $key => $value) {
$key = str_replace(array_values(self::$ESCAPE_KEYS), array_keys(self::$ESCAPE_KEYS), $key);
$reverted[$key] = $this->transformers->toRevert($value)->revert($value);
}
return $reverted;
}
/**
* @param TypedValue $transformed
* @return mixed
*/
public function revert($transformed)
{
return $this->transformers->toRevert($transformed->getValue())->revert($transformed->getValue());
}
/**
* @param null|TypeMapper $mapper
* @param null|TypeFactory $factory
* @return TransformerRegistry With default Transformers registered
*/
public static function createDefaultTransformerRegistry(TypeMapper $mapper = null, TypeFactory $factory = null)
{
$mapper = $mapper ?: self::getDefaultTypeMapper();
$factory = $factory ?: self::getDefaultTypeFactory();
$registry = new TransformerRegistry();
$registry->add(new DateTimeTransformer($mapper));
$registry->add(new DateTimeImmutableTransformer($mapper));
$registry->add(new TypedNullableObjectTransformer($registry));
$registry->add(new TypedObjectTransformer($registry));
$registry->add(new TypedArrayTransformer($registry));
$registry->add(new TypedValueTransformer($registry));
$registry->add(new GenericObjectTransformer($registry, $mapper, $factory));
$registry->add(new ArrayTransformer($registry));
$registry->add(new PrimitiveTransformer());
return $registry;
}
/**
* @param TypedValue $transformed
* @return mixed
*/
public function revert($transformed)
{
$innerValue = $this->makeInnerTypedValue($transformed);
return $this->transformers->toRevert($innerValue)->revert($innerValue);
}
