Get existing normalize instance

@param string $identifier
@return Normalize
@throws NotFound
555870
public function get(string $identifier = '') : Normalize
    {
        if (!$this->exists($identifier)) {
            throw new NotFound("No instance found with the name '{$identifier}'");
        }

        return $this->instances[$identifier];
    }
999705
public function fetch($identifier)
    {
        [$config, $key] = $this->configSplit($identifier);

        return CakeCache::read(static::CACHE_PREFIX . $key, $config);
    }
846901
protected function _quoteIdentifier($identifier)
        {
            if (Arrays::is($identifier)) {
                $result = array_map(array($this, '_quoteOneIdentifier'), $identifier);

                return join(', ', $result);
            } else {
                return $this->_quoteOneIdentifier($identifier);
            }
        }
991396
public function findModelByUniqueIdentifier($identifier)
    {
        $this->filter(new Equals($this->getModelSchema()->uniqueIdentifierColumnName, $identifier));

        return $this[0];
    }
230119
public function getByIdentifier($identifier)
    {
        switch (APP_NATIVE_LOGIN_USING) {

            case 'EMAIL':
                $user = $this->getByEmail($identifier);
                break;

            case 'USERNAME':
                $user = $this->getByUsername($identifier);
                break;

            default:
                Factory::helper('email');
                if (valid_email($identifier)) {
                    $user = $this->getByEmail($identifier);
                } else {
                    $user = $this->getByUsername($identifier);
                }
                break;
        }

        return $user;
    }
1013215
public function loadByIdentifier($identifier)
    {
        $rows = $this->sectionGateway->loadSectionDataByIdentifier($identifier);

        if (empty($rows)) {
            throw new NotFound('Section', $identifier);
        }

        return $this->createSectionFromArray(reset($rows));
    }
1092308
public function resolve($identifier)
    {
        if (!$this->container->has($identifier)) {
            $this->logger->error(
                sprintf(
                    'Could not find object defined by id "%s"',
                    $identifier
                )
            );

            return null;
        }

        return $this->container->get($identifier);
    }
1322677
public function getReferenceValue($identifier)
    {
        $identifier = $this->getReferenceIdentifier($identifier);
        if (!array_key_exists($identifier, $this->references)) {
            throw new \Exception("No reference set with identifier '$identifier'");
        }

        return $this->references[$identifier];
    }
473696
public function findByIdentifier($identifier)
    {
        $object = $this->persistenceManager->getObjectByIdentifier($identifier, $this->entityClassName);
        if ($object === null) {
            foreach ($this->addedResources as $addedResource) {
                if ($this->persistenceManager->getIdentifierByObject($addedResource) === $identifier) {
                    $object = $addedResource;
                    break;
                }
            }
        }

        return $object;
    }
356928
public function find($identifier)
    {
        $identifier = (string) $identifier;

        //Resolve the real identifier in case an alias was passed
        while(array_key_exists($identifier, $this->_aliases)) {
            $identifier = $this->_aliases[$identifier];
        }

        //Find the identifier
        if($this->offsetExists($identifier))
        {
            $result = $this->offsetGet($identifier);

            if($result instanceof KObjectInterface) {
                $result = $result->getIdentifier();
            }
        }
        else  $result = null;

        return $result;
    }
764959
public function offsetGet($identifier)
    {
        $keys = $this->_parseIdentifier($identifier);

        $result = $this->toArray();
        foreach($keys as $key)
        {
            if(is_array($result) && array_key_exists($key, $result)) {
                $result = $result[$key];
            } else {
                $result = null;
                break;
            }
        }

        return $result;
    }
1071215
public function getResource($identifier)
    {
        /** @var ClientEntity $client */
        $client = $this->getRepository()->findOneBy(array('id' => $identifier));
        if (!$client) {
            throw new NotFoundHttpException(
                $this->translator->trans('error.client_not_found', array('%id%' => $identifier))
            );
        }

        return $this->createResourceFromClient($client);
    }
814878
public function getResource($identifier)
    {
        /** @var UserEntity $user */
        $user = $this->userManager->findUserByUsername($identifier);
        if (!$user) {
            throw new NotFoundHttpException(
                $this->translator->trans('error.user_not_found', array('%id%' => $identifier))
            );
        }

        return $this->createResourceFromUser($user);
    }
901676
public function get($identifier = null)
    {
        $result = null;

        if (null === $identifier) {
            $result = self::$lookup;
        } elseif ('doozr.registry' === $identifier) {
            $result = $this;
        } else {
            if (true === isset(self::$lookup[$identifier])) {
                $result = self::$references[self::$lookup[$identifier]];
            }
        }

        return $result;
    }
331783
public function get($identifier)
    {
        if ($this->themeLoaded === false) {
            $this->loadThemes();
        }

        return $this->themeList->get($identifier);
    }
813589
public function getClient($identifier)
    {
        $client = $this->getClientFromPool($identifier);

        if ($client === null) {
            $client = $this->createClient($identifier);
            $this->getSession()->registerClient($client);
        }

        return $client;
    }
1350503
private function getProvider($identifier)
    {
        if (isset($this->interfaceProviders[$identifier])) {
            $this->assertSingleInterfaceProvider($identifier);
            return reset($this->interfaceProviders[$identifier]);
        } elseif (isset($this->classProviders[$identifier])) {
            $this->assertSingleClassProvider($identifier);
            return reset($this->classProviders[$identifier]);
        } else {
            return false;
        }
    }