Wala shell

Advanced PHP File Manager

Server IP: 127.0.0.1 | PHP Version: 8.3.30 | Domains Hosted: 54

Name	Size	Last Modified	Actions
📁 ..	-	2025-05-25 12:37
📄 CustomNormalizer.php <?php /* * This file is part of the Symfony package. * * (c) Fabien Potencier <fabien@symfony.com> * * For the full copyright and license information, please view the LICENSE * file that was distributed with this source code. / namespace Symfony\Component\Serializer\Normalizer; /* * @author Jordi Boggiano <j.boggiano@seld.be> / class CustomNormalizer extends SerializerAwareNormalizer implements NormalizerInterface, DenormalizerInterface { /* * {@inheritdoc} / public function normalize($object, $format = null, array $context = array()) { return $object->normalize($this->serializer, $format, $context); } /* * {@inheritdoc} / public function denormalize($data, $class, $format = null, array $context = array()) { $object = new $class(); $object->denormalize($this->serializer, $data, $format, $context); return $object; } /* * Checks if the given class implements the NormalizableInterface. * * @param mixed $data Data to normalize. * @param string $format The format being (de-)serialized from or into. * * @return Boolean / public function supportsNormalization($data, $format = null) { return $data instanceof NormalizableInterface; } /* * Checks if the given class implements the NormalizableInterface. * * @param mixed $data Data to denormalize from. * @param string $type The class to which the data should be denormalized. * @param string $format The format being deserialized from. * * @return Boolean */ public function supportsDenormalization($data, $type, $format = null) { $class = new \ReflectionClass($type); return $class->isSubclassOf('Symfony\Component\Serializer\Normalizer\DenormalizableInterface'); } }	1.83 KB	2024-07-17 10:22
📄 DenormalizableInterface.php <?php /* * This file is part of the Symfony package. * * (c) Fabien Potencier <fabien@symfony.com> * * For the full copyright and license information, please view the LICENSE * file that was distributed with this source code. / namespace Symfony\Component\Serializer\Normalizer; /* * Defines the most basic interface a class must implement to be denormalizable * * If a denormalizer is registered for the class and it doesn't implement * the Denormalizable interfaces, the normalizer will be used instead * * @author Jordi Boggiano <j.boggiano@seld.be> / interface DenormalizableInterface { /* * Denormalizes the object back from an array of scalars\|arrays. * * It is important to understand that the denormalize() call should denormalize * recursively all child objects of the implementor. * * @param DenormalizerInterface $denormalizer The denormalizer is given so that you * can use it to denormalize objects contained within this object. * @param array\|scalar $data The data from which to re-create the object. * @param string\|null $format The format is optionally given to be able to denormalize differently * based on different input formats. * @param array $context options for denormalizing */ public function denormalize(DenormalizerInterface $denormalizer, $data, $format = null, array $context = array()); }	1.39 KB	2024-07-17 10:22
📄 DenormalizerInterface.php <?php /* * This file is part of the Symfony package. * * (c) Fabien Potencier <fabien@symfony.com> * * For the full copyright and license information, please view the LICENSE * file that was distributed with this source code. / namespace Symfony\Component\Serializer\Normalizer; /* * Defines the interface of denormalizers. * * @author Jordi Boggiano <j.boggiano@seld.be> / interface DenormalizerInterface { /* * Denormalizes data back into an object of the given class * * @param mixed $data data to restore * @param string $class the expected class to instantiate * @param string $format format the given data was extracted from * @param array $context options available to the denormalizer * * @return object / public function denormalize($data, $class, $format = null, array $context = array()); /* * Checks whether the given class is supported for denormalization by this normalizer * * @param mixed $data Data to denormalize from. * @param string $type The class to which the data should be denormalized. * @param string $format The format being deserialized from. * * @return Boolean */ public function supportsDenormalization($data, $type, $format = null); }	1.27 KB	2024-07-17 10:22
📄 GetSetMethodNormalizer.php <?php /* * This file is part of the Symfony package. * * (c) Fabien Potencier <fabien@symfony.com> * * For the full copyright and license information, please view the LICENSE * file that was distributed with this source code. / namespace Symfony\Component\Serializer\Normalizer; use Symfony\Component\Serializer\Exception\InvalidArgumentException; use Symfony\Component\Serializer\Exception\RuntimeException; /* * Converts between objects with getter and setter methods and arrays. * * The normalization process looks at all public methods and calls the ones * which have a name starting with get and take no parameters. The result is a * map from property names (method name stripped of the get prefix and converted * to lower case) to property values. Property values are normalized through the * serializer. * * The denormalization first looks at the constructor of the given class to see * if any of the parameters have the same name as one of the properties. The * constructor is then called with all parameters or an exception is thrown if * any required parameters were not present as properties. Then the denormalizer * walks through the given map of property names to property values to see if a * setter method exists for any of the properties. If a setter exists it is * called with the property value. No automatic denormalization of the value * takes place. * * @author Nils Adermann <naderman@naderman.de> / class GetSetMethodNormalizer extends SerializerAwareNormalizer implements NormalizerInterface, DenormalizerInterface { protected $callbacks = array(); protected $ignoredAttributes = array(); protected $camelizedAttributes = array(); /* * Set normalization callbacks. * * @param callable[] $callbacks help normalize the result * * @throws InvalidArgumentException if a non-callable callback is set / public function setCallbacks(array $callbacks) { foreach ($callbacks as $attribute => $callback) { if (!is_callable($callback)) { throw new InvalidArgumentException(sprintf('The given callback for attribute "%s" is not callable.', $attribute)); } } $this->callbacks = $callbacks; } /* * Set ignored attributes for normalization * * @param array $ignoredAttributes / public function setIgnoredAttributes(array $ignoredAttributes) { $this->ignoredAttributes = $ignoredAttributes; } /* * Set attributes to be camelized on denormalize * * @param array $camelizedAttributes / public function setCamelizedAttributes(array $camelizedAttributes) { $this->camelizedAttributes = $camelizedAttributes; } /* * {@inheritdoc} / public function normalize($object, $format = null, array $context = array()) { $reflectionObject = new \ReflectionObject($object); $reflectionMethods = $reflectionObject->getMethods(\ReflectionMethod::IS_PUBLIC); $attributes = array(); foreach ($reflectionMethods as $method) { if ($this->isGetMethod($method)) { $attributeName = lcfirst(substr($method->name, 3)); if (in_array($attributeName, $this->ignoredAttributes)) { continue; } $attributeValue = $method->invoke($object); if (array_key_exists($attributeName, $this->callbacks)) { $attributeValue = call_user_func($this->callbacks[$attributeName], $attributeValue); } if (null !== $attributeValue && !is_scalar($attributeValue)) { if (!$this->serializer instanceof NormalizerInterface) { throw new \LogicException(sprintf('Cannot normalize attribute "%s" because injected serializer is not a normalizer', $attributeName)); } $attributeValue = $this->serializer->normalize($attributeValue, $format); } $attributes[$attributeName] = $attributeValue; } } return $attributes; } /* * {@inheritdoc} / public function denormalize($data, $class, $format = null, array $context = array()) { $reflectionClass = new \ReflectionClass($class); $constructor = $reflectionClass->getConstructor(); if ($constructor) { $constructorParameters = $constructor->getParameters(); $params = array(); foreach ($constructorParameters as $constructorParameter) { $paramName = lcfirst($this->formatAttribute($constructorParameter->name)); if (isset($data[$paramName])) { $params[] = $data[$paramName]; // don't run set for a parameter passed to the constructor unset($data[$paramName]); } elseif (!$constructorParameter->isOptional()) { throw new RuntimeException( 'Cannot create an instance of '.$class. ' from serialized data because its constructor requires '. 'parameter "'.$constructorParameter->name. '" to be present.'); } } $object = $reflectionClass->newInstanceArgs($params); } else { $object = new $class; } foreach ($data as $attribute => $value) { $setter = 'set'.$this->formatAttribute($attribute); if (method_exists($object, $setter)) { $object->$setter($value); } } return $object; } /* * Format attribute name to access parameters or methods * As option, if attribute name is found on camelizedAttributes array * returns attribute name in camelcase format * * @param string $attributeName * @return string / protected function formatAttribute($attributeName) { if (in_array($attributeName, $this->camelizedAttributes)) { return preg_replace_callback( '/(^\|_\|\.)+(.)/', function ($match) { return ('.' === $match[1] ? '_' : '').strtoupper($match[2]); }, $attributeName ); } return $attributeName; } /* * {@inheritDoc} / public function supportsNormalization($data, $format = null) { return is_object($data) && $this->supports(get_class($data)); } /* * {@inheritDoc} / public function supportsDenormalization($data, $type, $format = null) { return $this->supports($type); } /* * Checks if the given class has any get{Property} method. * * @param string $class * * @return Boolean / private function supports($class) { $class = new \ReflectionClass($class); $methods = $class->getMethods(\ReflectionMethod::IS_PUBLIC); foreach ($methods as $method) { if ($this->isGetMethod($method)) { return true; } } return false; } /* * Checks if a method's name is get.* and can be called without parameters. * * @param \ReflectionMethod $method the method to check * * @return Boolean whether the method is a getter. */ private function isGetMethod(\ReflectionMethod $method) { return ( 0 === strpos($method->name, 'get') && 3 < strlen($method->name) && 0 === $method->getNumberOfRequiredParameters() ); } }	7.54 KB	2024-07-17 10:22
📄 NormalizableInterface.php <?php /* * This file is part of the Symfony package. * * (c) Fabien Potencier <fabien@symfony.com> * * For the full copyright and license information, please view the LICENSE * file that was distributed with this source code. / namespace Symfony\Component\Serializer\Normalizer; /* * Defines the most basic interface a class must implement to be normalizable * * If a normalizer is registered for the class and it doesn't implement * the Normalizable interfaces, the normalizer will be used instead * * @author Jordi Boggiano <j.boggiano@seld.be> / interface NormalizableInterface { /* * Normalizes the object into an array of scalars\|arrays. * * It is important to understand that the normalize() call should normalize * recursively all child objects of the implementor. * * @param NormalizerInterface $normalizer The normalizer is given so that you * can use it to normalize objects contained within this object. * @param string\|null $format The format is optionally given to be able to normalize differently * based on different output formats. * @param array $context Options for normalizing this object * * @return array\|scalar */ public function normalize(NormalizerInterface $normalizer, $format = null, array $context = array()); }	1.31 KB	2024-07-17 10:22
📄 NormalizerInterface.php <?php /* * This file is part of the Symfony package. * * (c) Fabien Potencier <fabien@symfony.com> * * For the full copyright and license information, please view the LICENSE * file that was distributed with this source code. / namespace Symfony\Component\Serializer\Normalizer; /* * Defines the interface of normalizers. * * @author Jordi Boggiano <j.boggiano@seld.be> / interface NormalizerInterface { /* * Normalizes an object into a set of arrays/scalars * * @param object $object object to normalize * @param string $format format the normalization result will be encoded as * @param array $context Context options for the normalizer * * @return array\|scalar / public function normalize($object, $format = null, array $context = array()); /* * Checks whether the given class is supported for normalization by this normalizer * * @param mixed $data Data to normalize. * @param string $format The format being (de-)serialized from or into. * * @return Boolean */ public function supportsNormalization($data, $format = null); }	1.12 KB	2024-07-17 10:22
📄 SerializerAwareNormalizer.php <?php /* * This file is part of the Symfony package. * * (c) Fabien Potencier <fabien@symfony.com> * * For the full copyright and license information, please view the LICENSE * file that was distributed with this source code. / namespace Symfony\Component\Serializer\Normalizer; use Symfony\Component\Serializer\SerializerInterface; use Symfony\Component\Serializer\SerializerAwareInterface; /* * SerializerAware Normalizer implementation * * @author Jordi Boggiano <j.boggiano@seld.be> / abstract class SerializerAwareNormalizer implements SerializerAwareInterface { /* * @var SerializerInterface / protected $serializer; /* * {@inheritdoc} */ public function setSerializer(SerializerInterface $serializer) { $this->serializer = $serializer; } }	821 B	2024-07-17 10:22

Terminal