PHP Serializer::deserialize方法代码示例

 public function testCustomSubscribingHandler()
 {
     $fixture = file_get_contents(FIXTURE_ROOT . '/Unit/Serializer/JmsSerializer/test_entity_1.json');
     $resultEntity = $this->realJms->deserialize($fixture, 'Elastification\\Client\\Serializer\\JmsSerializer\\SearchResponseEntity', 'json');
     $this->assertInstanceOf('Elastification\\Client\\Serializer\\JmsSerializer\\SearchResponseEntity', $resultEntity);
     /* @var $resultEntity \Elastification\Client\Serializer\JmsSerializer\SearchResponseEntity */
     $this->assertEquals(1, $resultEntity->took);
     $this->assertEquals(false, $resultEntity->timed_out);
     $this->assertInstanceOf('Elastification\\Client\\Serializer\\JmsSerializer\\Shards', $resultEntity->_shards);
     $this->assertEquals(1, $resultEntity->_shards->total);
     $this->assertEquals(1, $resultEntity->_shards->successful);
     $this->assertEquals(0, $resultEntity->_shards->failed);
     $this->assertInstanceOf('Elastification\\Client\\Serializer\\JmsSerializer\\Hits', $resultEntity->hits);
     $this->assertEquals(1, $resultEntity->hits->total);
     $this->assertEquals(0, $resultEntity->hits->maxScore);
     $this->assertCount(1, $resultEntity->hits->hits);
     $hit = $resultEntity->hits->hits[0];
     $this->assertInstanceOf('Elastification\\Client\\Serializer\\JmsSerializer\\Hit', $hit);
     $this->assertEquals('4372-4412104-928-DL', $hit->_id);
     $this->assertEquals('elastification', $hit->_index);
     $this->assertEquals('test', $hit->_type);
     $this->assertEquals(1.993935, $hit->_score);
     $entity = $hit->_source;
     $this->assertInstanceOf('Elastification\\Client\\Tests\\Fixtures\\Unit\\Serializer\\JmsSerializer\\TestEntity', $entity);
     $this->assertEquals(123, $entity->a);
 }

 /**
  * @param \Doctrine\ORM\Event\LifecycleEventArgs $args
  */
 public function postPersist(LifecycleEventArgs $args)
 {
     $layoutBlock = $args->getEntity();
     if ($layoutBlock instanceof LayoutBlock) {
         if ($contentObject = $layoutBlock->getSnapshotContent()) {
             $contentObject = $this->serializer->deserialize($contentObject, $layoutBlock->getClassType(), 'json');
             $em = $args->getEntityManager();
             try {
                 $em->persist($contentObject);
                 $contentObject = $em->merge($contentObject);
                 $reflection = new \ReflectionClass($contentObject);
                 foreach ($reflection->getProperties() as $property) {
                     $method = sprintf('get%s', ucfirst($property->getName()));
                     if ($reflection->hasMethod($method) && ($var = $contentObject->{$method}())) {
                         if ($var instanceof ArrayCollection) {
                             foreach ($var as $v) {
                                 $em->merge($v);
                             }
                         }
                     }
                 }
             } catch (EntityNotFoundException $e) {
                 $em->detach($contentObject);
                 $classType = $layoutBlock->getClassType();
                 $contentObject = new $classType();
                 $em->persist($contentObject);
             }
             $em->flush($contentObject);
             $layoutBlock->setObjectId($contentObject->getId());
             $em->persist($layoutBlock);
             $em->flush($layoutBlock);
         }
     }
 }

 /**
  * @param InputInterface  $input
  * @param OutputInterface $output
  *
  * @return bool
  */
 protected function execute(InputInterface $input, OutputInterface $output)
 {
     foreach ($this->sources as $name => $class) {
         $result = $this->serializer->deserialize(file_get_contents(getcwd() . '/tests/Common/Api/test_cases/protocols/output/fixtures/' . $name . '.xml'), $class, 'xml');
         file_put_contents(getcwd() . '/tests/Common/Api/test_cases/protocols/output/fixtures/' . $name . '.serialized', serialize($result->getBody()));
         $output->writeln('Processed ' . $name . ' serialized file.');
     }
 }

 public function deserialize($data, $type)
 {
     $result = $this->serializer->deserialize($data, $type, 'json');
     if (preg_match('/ArrayCollection/', $type)) {
         $result = new ArrayList($result);
     }
     return $result;
 }

 public function testDeserializeJson()
 {
     $json = '{"foo":"bar","baz":[1,2,3]}';
     /** @var Metadata $metadata */
     $metadata = $this->serializer->deserialize($json, Metadata::class, 'json');
     $this->assertInstanceOf(Metadata::class, $metadata);
     $this->assertEquals(['baz' => [1, 2, 3], 'foo' => 'bar'], $metadata->toArray());
 }

 /**
  * @param AbstractJsonEvent $event
  * 
  * @return AbstractJsonEvent
  */
 public function deserialize(AbstractJsonEvent $event)
 {
     $deSerialized = $this->serializer->deserialize($event->getJson(), get_class($event), self::JSON_FORMAT);
     $deSerialized->type = $event->type;
     $deSerialized->content = $event->content;
     $deSerialized->setName($event->getName());
     return $deSerialized;
 }

 /**
  * @param ServiceEvent $event
  */
 public function onResponseEvent(ServiceEvent $event)
 {
     $service = $event->getService();
     if ($service instanceof ServiceConfigurableInterface && null !== $service->getOption('response_type')) {
         /** @var Service $service */
         $service->getResponse()->setDeserializedContent($this->serializer->deserialize($service->getResponse()->getContent(), $service->getOption('response_type'), $service->getOption('response_format')));
     }
 }

 public function testDiscriminatorIsInferredForGenericBaseClass()
 {
     $student = new Student();
     $json = $this->serializer->serialize($student, 'json');
     $this->assertEquals('{"type":"student"}', $json);
     $deserialized = $this->serializer->deserialize($json, Person::class, 'json');
     $this->assertEquals($student, $deserialized);
 }

 /**
  * @return \App\Satis\Model\ConfigLock|array|\JMS\Serializer\scalar|mixed|object
  * @throws \Illuminate\Contracts\Filesystem\FileNotFoundException
  */
 protected function getLockFile()
 {
     if ($this->filesystem->exists($this->lockFilename)) {
         $configLock = $this->serializer->deserialize($this->filesystem->get($this->lockFilename), 'App\\Satis\\Model\\ConfigLock', 'json');
     } else {
         $configLock = new ConfigLock();
     }
     return $configLock;
 }

 /**
  * Deserializes request content.
  *
  * @param ResponseInterface $response
  * @param string            $type
  * @param string            $format
  *
  * @return mixed
  *
  * @throws \Exception
  */
 protected function deserialize(ResponseInterface $response, $type, $format = 'json')
 {
     try {
         return $this->serializer->deserialize((string) $response->getBody(), $type, $format);
     } catch (\Exception $exception) {
         $this->logger->error('[WebServiceClient] Deserialization problem on webservice call.', array('response' => (string) $response->getBody(), 'exception' => $exception));
         throw $exception;
     }
 }

 public function testDeserializeJson()
 {
     $json = '{"uuid":"ed34c88e-78b0-11e3-9ade-406c8f20ad00"}';
     /** @var ObjectWithUuid $object */
     $object = $this->serializer->deserialize($json, ObjectWithUuid::class, 'json');
     $uuid = $object->getUuid();
     $this->assertInstanceOf(UuidInterface::class, $uuid);
     $this->assertEquals('ed34c88e-78b0-11e3-9ade-406c8f20ad00', (string) $uuid);
 }

 /**
  * @test
  */
 public function it_can_be_deserialized()
 {
     $modelData = $this->getModelData();
     $modelClass = $this->getModelClass();
     /** @var AbstractModel $model */
     $model = $this->serializer->deserialize(json_encode($modelData), $modelClass, 'json');
     $this->assertInstanceOf($modelClass, $model);
     $this->assertInstanceOf('CL\\Slack\\Model\\AbstractModel', $model);
     $this->assertModel($modelData, $model);
 }

 public function test_CreateAnimal_success()
 {
     $this->testUtils->createUser()->toEleveur();
     $this->client->request('POST', '/animal');
     $this->assertEquals(Response::HTTP_OK, $this->client->getResponse()->getStatusCode());
     /** @var PageAnimal $pageAnimal */
     $pageAnimal = $this->serializer->deserialize($this->client->getResponse()->getContent(), PageAnimal::class, 'json');
     $this->client->request('GET', '/animal/' . $pageAnimal->getId());
     $this->assertEquals(Response::HTTP_OK, $this->client->getResponse()->getStatusCode());
 }

 /**
  * @param $data
  * @param $entityName
  * @return mixed
  */
 public function hydrateEntity($data, $entityName)
 {
     if (empty($data)) {
         $data = array();
     }
     if (is_string($data)) {
         $data = json_decode($data, true);
     }
     return $this->serializer->deserialize(json_encode($this->transformer->transformHydrateData($data)), $entityName, 'json');
 }

 /**
  * {@inheritdoc}
  */
 public function reverseTransform($data)
 {
     if ($data === null) {
         return null;
     }
     try {
         return $this->serializer->deserialize($data, $this->class, $this->format);
     } catch (JMSException $e) {
         throw new StorageException('The JMS serializer failed deserializing the data: ' . $e->getMessage(), 0, $e);
     }
 }