{@inheritdoc}

@see SerializerInterface::deserialize()
171149
public function deserialize($data, $type, $format, array $context = array())
    {
        if (!isset($this->handlers[$format])) {
            throw new \BadMethodCallException(sprintf(
                'Unsupported format "%s", only [%s] are',
                $format, implode(', ', array_keys($this->handlers))
            ));
        }

        return $this->handlers[$format]->deserialize($data, $type);
    }
238335
public function deserialize($data, $object, array $options = [])
    {
        $properties = $this->getSerializableProperties($object, [self::INCLUDE_MANY_TO_ONE]);
        //update the mapObjectToEntity method instead of doing this
        $data = json_decode(json_encode($data));

        return $this->mapObjectToEntity(
            $properties,
            $this->resolveData($properties, $data, get_class($object)),
            $object
        );
    }
448965
private function deserialize($value)
    {
        $decoded = base64_decode($value, true);
        if ($decoded === false) {
            return false;
        }

        $decompressed = gzuncompress($decoded);
        return $decompressed;
    }
1257130
public function deserialize(): object
    {
        $this->buffer->position($this->assetOffset / 2);

        $usernameLength = $this->buffer->readUInt8();

        $this->transaction->asset = [
            'delegate' => [
                'username' => $this->buffer->position($this->assetOffset + 2)->readHexBytes($usernameLength * 2),
            ],
        ];

        return $this->parseSignatures($this->assetOffset + ($usernameLength + 1) * 2);
    }
234781
public static function deserializeObject(array $data)
    {
        $result = new static($data['resourceType'], isset($data['created']) ? Helper::string2dateTime($data['created']) : null);
        if (isset($data['lastModified'])) {
            $result->lastModified = Helper::string2dateTime($data['lastModified']);
        }
        if (isset($data['location'])) {
            $result->location = $data['location'];
        }
        if (isset($data['version'])) {
            $result->version = $data['version'];
        }

        return $result;
    }
696302
static function smartUnserialize(string $data)
    {
        try {
            $value = @unserialize($data);
        } catch (\Throwable $e) {
            throw new DeserializationFailedException('An exception was thrown during unserialization', 0, $e);
        }

        // distinguish between "false on error" and a serialized FALSE value
        if ($value === false && $data !== self::getSerializedFalse()) {
            throw new DeserializationFailedException('Unserialization failed - data possibly malformed');
        }

        return $value;
    }
758243
public static function deserializeObject(array $data)
    {
        /** @var Schema $result */
        $result = self::deserializeCommonAttributes($data);
        $result->name = $data['name'];
        $result->description = $data['description'];
        $result->attributes = [];
        foreach ($data['attributes'] as $attribute) {
            $result->attributes[] = Schema\Attribute::deserializeObject($attribute);
        }

        return $result;
    }
131066
public function deserialize($attributes)
    {
        if (isset($attributes['className'])) {
            $className = $attributes['className'];
            $job = new $className();
            unset($attributes['className']);
            $job->setType($attributes['type']);
            unset($attributes['type']);
            $job->setAttributes($attributes);
            return $job;
        }
    }
304694
public static function deserialize(array $data): CryptographicDetails {
        // json string to array
        if ( ! isset($data['encryption'])) {
            throw new CannotDeserializeCryptographicDetails('Encryption type could not be identified from serialized form.');
        }

        // pull out the encryption key
        $encryption = $data['encryption'];
        unset($data['encryption']);

        // base64 decode
        $details = array_map(function($value) {
            return base64_decode($value);
        }, $data);

        return new static($encryption, $details);
    }
838177
public function deserialize($data, $object, $options = [])
    {
        // search for the correct serializer
        if ($meta = $this->om->getClassMetaData(get_class($object))) {
            $class = $meta->name;
        }

        $serializer = $this->get($class);

        if (method_exists($serializer, 'deserialize')) {
            $serializer->deserialize($data, $object, $options);
        }

        return $object;
    }
850463
public function apiSerialize($object, $options = [])
    {
        if (!empty($object)) {
            return $this->serializerProvider->serialize($object, $options);
        }

        return $object;
    }
114222
public function deserialize($document)
    {
        $goalStateInfo = Utilities::unserialize($document);

        return new GoalState(
            $goalStateInfo['Incarnation'],
            $goalStateInfo['ExpectedState'],
            $goalStateInfo['RoleEnvironmentPath'],
            new \DateTime($goalStateInfo['Deadline']),
            $goalStateInfo['CurrentStateEndpoint']
        );
    }
1153203
public function deserialize(array $data, Item $item = null, array $options = [])
    {
        return $this->serializer->deserialize($data, $item, $options);
    }
867770
@SuppressWarnings("unchecked")
  public T deserialize() throws ClassNotFoundException {
    try {
      ByteArrayInputStream byteStream = new ByteArrayInputStream(data);
      GZIPInputStream gzipStream = new GZIPInputStream(byteStream);
      try {
        ObjectInputStream objectStream = new ObjectInputStream(gzipStream);
        object = (T) objectStream.readObject();
        return object;
      } finally {
        gzipStream.close();
      }
    } catch (IOException e) {
      throw new UnexpectedException(e);
    }
  }
1105503
protected Object deserialize(byte[] in) {
        Object rv = null;
        try {
            if (in != null) {
                ByteArrayInputStream bis = new ByteArrayInputStream(in);
                ObjectInputStream is = new ObjectInputStream(bis);
                rv = is.readObject();
                is.close();
                bis.close();
            }
        } catch (IOException e) {
            logger.warn("Caught IOException decoding %d bytes of data", e);
        } catch (ClassNotFoundException e) {
            logger.warn("Caught CNFE decoding %d bytes of data", e);
        }
        return rv;
    }
235889
public function unserialize($serialized) // [\SplDoublyLinkedList]
	{
		try
		{
			if(null === $this->last)
			{
				$this->first = unserialize($serialized);
			}
			else
			{
				$this->last->next = unserialize($serialized);
			}
		}
		catch(\Exception $e)
		{
			$error = $e->getMessage();
			
			throw new UnserializeException(substr($error, strpos($error, ': ') + 2));
		}
		
		$n    = 0;
		$iter = $this->first;
		$last = null;
		
		while(null !== $iter)
		{
			$last = $iter;
			$iter = $iter->next;
			++$n;
		}
		
		$this->last = $last;
		$this->size = $n;
	}
305059
public function deserialize(): Transaction
    {
        $transaction = new Transaction();
        $transaction->version = $this->buffer->readUInt8();
        $transaction->network = $this->buffer->readUInt8();
        $transaction->type = $this->buffer->readUInt8();
        $transaction->timestamp = $this->buffer->readUInt32();
        $transaction->senderPublicKey = $this->buffer->readHex(33);
        $transaction->fee = $this->buffer->readUInt64();

        $vendorFieldLength = $this->buffer->readUInt8();
        if ($vendorFieldLength > 0) {
            $transaction->vendorFieldHex = $this->buffer->readHex($vendorFieldLength);
        }

        $assetOffset = (41 + 8 + 1) * 2 + $vendorFieldLength * 2;

        $transaction = $this->handleType($assetOffset, $transaction);

        if (! isset($transaction->amount)) {
            $transaction->amount = 0;
        }

        if (! isset($transaction->version) || 1 === $transaction->version) {
            $transaction = $this->handleVersionOne($transaction);
        }

        if (2 === $transaction->version) {
            $transaction = $this->handleVersionTwo($transaction);
        }

        return $transaction;
    }