@param JsonDeserializerInterface $deserializer

@return EntryPoint
770485
public function addDeserializer(JsonDeserializerInterface $deserializer): EntryPoint
    {
        foreach ($deserializer->getSupportedTypes() as $type) {
            $this->deserializers[$type] = $deserializer;
        }

        return $this;
    }
317067
public function getValue($object)
    {
        $get = 'get'.ucfirst($this->property);
        $has = 'has'.ucfirst($this->property);
        $is = 'is'.ucfirst($this->property);

        if (method_exists($object, $get)) {
            return $object->$get();
        }

        if (method_exists($object, $has)) {
            return $object->$has();
        }

        if (method_exists($object, $is)) {
            return $object->$is();
        }

        throw DeserializerLogicException::createMissingMethod(get_class($object), [$get, $has, $is]);
    }
948669
public static <T> SetJsonDeserializer<T> newInstance( JsonDeserializer<T> deserializer ) {
        return new SetJsonDeserializer<T>( deserializer );
    }
470690
public function deserializeArrayObjectFromJson(
        JsonDeserializationVisitor $visitor,
        array $data,
        array $type,
        Context $context
    ) {
        return new \ArrayObject($visitor->visitArray($data, $type, $context));
    }
1043012
public static function inProperty(
        string $name,
        Deserializes $deserializer
    ): ExposesDataKey {
        return new self($name, $name, $deserializer);
    }
264229
public static function requestBuilder(callable $serializer)
    {
        return function (callable $handler) use ($serializer) {
            return function (CommandInterface $command) use ($serializer, $handler) {
                return $handler($command, $serializer($command));
            };
        };
    }
727391
public static <T> VectorJsonDeserializer<T> newInstance( JsonDeserializer<T> deserializer ) {
        return new VectorJsonDeserializer<T>( deserializer );
    }
1092166
public static <T extends Comparable<T>> SortedMultisetJsonDeserializer<T> newInstance( JsonDeserializer<T> deserializer ) {
        return new SortedMultisetJsonDeserializer<T>( deserializer );
    }
1166811
public function createService(ServiceLocatorInterface $serviceLocator)
    {
        /** @var HelperPluginManager $serviceLocator */
        $mainServiceManager = $serviceLocator->getServiceLocator();

        $helper = new EnvironmentSelect();

        /** @var EnvironmentRepositoryInterface $environmentRepository */
        $environmentRepository = $mainServiceManager->get('EnvironmentRepository');
        $helper->setEnvironmentRepository($environmentRepository);

        /** @var Application $application */
        $application = $mainServiceManager->get('Application');
        $helper->setRouteMatch($application->getMvcEvent()->getRouteMatch());

        return $helper;
    }
13834
public function addDefaultDeserializers(SerializerInterface $jmsSerializer): EntryPoint
    {
        $this->addDeserializer(new ArticleHandler($jmsSerializer));
        $this->addDeserializer(new OrderHandler($jmsSerializer));
        $this->addDeserializer(new CategoryHandler($jmsSerializer));
        $this->addDeserializer(new MediaHandler($jmsSerializer));
        $this->addDeserializer(new ManufacturerHandler($jmsSerializer));

        return $this;
    }
863454
public function deserialize($serializedObject)
    {
        $serializedCommand = @json_decode($serializedObject, true);

        if (json_last_error() !== JSON_ERROR_NONE) {
            throw new DeserializeException(json_last_error_msg());
        }

        $command = $this->serializer->deserialize($serializedCommand);

        if (!$command instanceof NamedCommand) {
            throw new DeserializeException('The deserialized object is not a command');
        }

        return $command;
    }
1176016
protected function get(RequestDescriptor $descriptor)
    {
        return new Request(
            $descriptor->getMethod(),
            $descriptor->getUrl(),
            $descriptor->getHeaders()
        );
    }
31969
public function getSerializer(string $serializer): SerializerInterface
    {
        $class = class_exists($serializer)
            ? $serializer
            : sprintf('Windwalker\Cache\Serializer\%sSerializer', StringNormalise::toCamelCase($serializer));

        if (!class_exists($class)) {
            throw new \DomainException(sprintf('Cache Serializer: %s not supported.', ucfirst($serializer)));
        }

        return $this->container->newInstance($class);
    }
833108
public function createService(ServiceLocatorInterface $serviceLocator)
    {
        $parser = $serviceLocator->get('ControllerNameParser');
        $logger = $serviceLocator->has('Logger') ? $serviceLocator->get('Logger') : null;

        return new ControllerResolver($serviceLocator, $parser, $logger);
    }
1228973
public function createService(ServiceLocatorInterface $serviceLocator)
    {
        /** @var DataMapperManager $dataMapperManager */
        $dataMapperManager = $serviceLocator->get(DataMapperManager::class);

        $password = $serviceLocator->get('Thorr\OAuth2\DefaultPasswordInterface');

        /** @var ModuleOptions $moduleOptions */
        $moduleOptions = $serviceLocator->get(ModuleOptions::class);

        $adapter = new DataMapperAdapter($dataMapperManager, $password);
        $adapter->setUserClass($moduleOptions->getUserEntityClassName());

        return $adapter;
    }
1219953
public function createService(ServiceLocatorInterface $serviceLocator)
    {
        /** @var DataMapperManager $dataMapperManager */
        $dataMapperManager = $serviceLocator->get(DataMapperManager::class);

        $userMapper        = $dataMapperManager->getDataMapperForEntity(Entity\UserInterface::class);

        /** @var ThirdPartyMapperInterface $thirdPartyMapper */
        $thirdPartyMapper  = $dataMapperManager->getDataMapperForEntity(Entity\ThirdParty::class);

        /** @var TokenMapperInterface $accessTokenMapper */
        $accessTokenMapper = $dataMapperManager->getDataMapperForEntity(Entity\AccessToken::class);

        /** @var ModuleOptions $moduleOptions */
        $moduleOptions = $serviceLocator->get(ModuleOptions::class);

        $grantType = new ThirdPartyGrantType($userMapper, $thirdPartyMapper, $accessTokenMapper, $moduleOptions);

        return $grantType;
    }
644352
public function resolve(callable $deserializeCallback = null)
    {
        if (null === $deserializeCallback) {
            $deserializeCallback = function ($data) { return $data; };
        }

        if (null === $this->resolved) {
            $this->resolved = $this->doResolve();
        }

        return $deserializeCallback($this->resolved);
    }