Get PCI Creator hook located at views/js/{{hookFileName}}/$typeIdentifier

@param string $typeIdentifier
@return array
339794
public function getDevImplementation($typeIdentifier){

        //@todo : re-implement it to be more optimal
        $devImplementations = $this->getDevImplementations();
        foreach($devImplementations as $impl){
            if($impl['typeIdentifier'] == $typeIdentifier){
                return $impl;
            }
        }
        return null;
    }
1131403
public function export($type, $identifier, $version=null)
    {
        $model = $this->getPortableModelRegistry()->getModel($type);
        $object = $model->getRegistry()->fetch($identifier, $version);

        if (is_null($object)) {
            throw new PortableElementNotFoundException(
                'Unable to find a PCI associated to identifier: ' . $identifier
            );
        }
        $this->validate($object);
        return $model->getRegistry()->export($object);
    }
929037
public function getType($identifier)
    {
        return isset($this->types[$identifier])? $this->types[$identifier]: null;
    }
1258376
public function GetSource($Type, $Identifier) {
      $SourceTag = "{$Type}:{$Identifier}";
      if (!array_key_exists($SourceTag, $this->Sources)) return FALSE;
      
      return $this->Sources[$SourceTag];
   }
765994
public function getIdentifier()
    {
        $identifier = $this->getFromNode()->getIdentifier() 
                    . '-'
                    . $this->getType()
                    . '-'
                    . $this->getToNode()->getIdentifier();
        
        return $identifier;
    }
222028
protected function readBelongsToManyRelationshipIdentifiers(
        $identifier,
        string $intTableName,
        string $intPrimaryKeyName,
        string $intForeignKeyName
    ): array {
        try {
            $connection = $this->getConnection();
            $query      = $connection->createQueryBuilder();

            $query
                ->select($intForeignKeyName)
                ->from($intTableName)
                ->where($intPrimaryKeyName . '=' . $this->createTypedParameter($query, $identifier));

            $statement = $query->execute();
            $statement->setFetchMode(PDO::FETCH_NUM);
            $result = array_column($statement->fetchAll(), 0);

            return $result;
        } /** @noinspection PhpRedundantCatchClauseInspection */ catch (DBALException $exception) {
            $message = 'Belongs-to-Many relationship reading failed.';
            throw new RepositoryException($message, 0, $exception);
        }
    }
1222333
protected function releaseToken($tokenIdentifier)
    {
        $filtered = array_filter($this->tokens, function ($val) use ($tokenIdentifier) {
            return $val['token'] === $tokenIdentifier;
        });
        $keys = array_keys($filtered);
        $this->tokens[$keys[0]]['available'] = true;
    }
792259
public function getIdentifier()
    {
        // Get identifier
        $identifier = $this->identifier;

        // If identifier must be obfuscated
        if (true === $this->useObfuscation()) {

            // Who is requesting (fingerprint client)
            $headers = getallheaders();

            // Get arguments
            $filter = ['USER-AGENT', 'ACCEPT', 'ACCEPT-LANGUAGE', 'ACCEPT-ENCODING'];

            foreach ($headers as $header => $value) {
                if (false === in_array(strtoupper($header), $filter)) {
                    unset($headers[$header]);
                }
            }

            $identifier = sha1(
                $identifier.
                $this->generateFingerprint(
                    $this->getClientIp(),
                    $headers
                )
            );
        }

        return $identifier;
    }
330144
public function createValidator($validatorIdentifier, array $options = [])
    {
        $validatorPresets = $this->getRootForm()->getValidatorPresets();
        if (isset($validatorPresets[$validatorIdentifier]) && is_array($validatorPresets[$validatorIdentifier]) && isset($validatorPresets[$validatorIdentifier]['implementationClassName'])) {
            $implementationClassName = $validatorPresets[$validatorIdentifier]['implementationClassName'];
            $defaultOptions = isset($validatorPresets[$validatorIdentifier]['options']) ? $validatorPresets[$validatorIdentifier]['options'] : [];

            $options = Arrays::arrayMergeRecursiveOverrule($defaultOptions, $options);

            $validator = new $implementationClassName($options);
            $this->addValidator($validator);
            return $validator;
        } else {
            throw new ValidatorPresetNotFoundException('The validator preset identified by "' . $validatorIdentifier . '" could not be found, or the implementationClassName was not specified.', 1328710202);
        }
    }
173553
public function getElementByIdentifier($elementIdentifier)
    {
        return isset($this->elementsByIdentifier[$elementIdentifier]) ? $this->elementsByIdentifier[$elementIdentifier] : null;
    }
403896
public static function createFileMonitorAtBoot($identifier, Bootstrap $bootstrap)
    {
        $fileMonitorCache = $bootstrap->getEarlyInstance(CacheManager::class)->getCache('Flow_Monitor');

        // The change detector needs to be instantiated and registered manually because
        // it has a complex dependency (cache) but still needs to be a singleton.
        $fileChangeDetector = new ChangeDetectionStrategy\ModificationTimeStrategy();
        $fileChangeDetector->injectCache($fileMonitorCache);
        $bootstrap->getObjectManager()->registerShutdownObject($fileChangeDetector, 'shutdownObject');

        $fileMonitor = new FileMonitor($identifier);
        $fileMonitor->injectCache($fileMonitorCache);
        $fileMonitor->injectChangeDetectionStrategy($fileChangeDetector);
        $fileMonitor->injectSignalDispatcher($bootstrap->getEarlyInstance(Dispatcher::class));
        $fileMonitor->injectLogger($bootstrap->getEarlyInstance(PsrLoggerFactoryInterface::class)->get('systemLogger'));

        return $fileMonitor;
    }
329191
public function get($entryIdentifier)
    {
        if (!$this->has($entryIdentifier)) {
            return false;
        }
        $result = parent::get($entryIdentifier);
        if (!\is_string($result)) {
            return false;
        }

        return \unserialize($result);
    }
506899
public function getIdField($pDbContainer = NULL)
    {
        if ($pDbContainer === NULL) {
            $pDbContainer = $this->_dbContainer;
        }

        return $pDbContainer . static::PREFIX_SEPARATOR . static::IDFIELD;
    }
275513
public function getDeliveryItemType($resultIdentifier)
    {
        $resultsViewerService = $this->getServiceLocator()->get(ResultsViewerService::SERVICE_ID);
        return $resultsViewerService->getDeliveryItemType($resultIdentifier);
    }
273623
protected function getOneByIdentifier($identifier)
	{
		return $this->aggregate[IdentifierServiceProvider::getProviderKey()]->get([['field' => 'id', 'value' =>  $identifier->getEntityKey(), 'operator' => '=', 'or' => false]]);
	}
1204014
public function getPermissions($type, $identifier)
    {
        $accessControls = $this->accessControlRepository->findByTypeAndId($type, $identifier);

        $permissions = [];
        foreach ($accessControls as $accessControl) {
            $permissions[$accessControl->getRole()->getId()] = $this->maskConverter->convertPermissionsToArray(
                $accessControl->getPermissions()
            );
        }

        return $permissions;
    }
633931
public function get(string $identifier): \Psr\Log\LoggerInterface
    {
        if (isset($this->instances[$identifier])) {
            return $this->instances[$identifier];
        }

        if (!isset($this->configuration[$identifier])) {
            throw new \InvalidArgumentException(sprintf('The given log identifier "%s" was not configured for the "%s" factory.', htmlspecialchars($identifier), self::class), 1515355505545);
        }

        if (!class_exists(Logger::class)) {
            throw new \Exception('To use the default logging you have to have the "neos/flow-log" package installed. It seems you miss it, so install it via "composer require neos/flow-log".', 1515437383589);
        }

        $backends = $this->instantiateBackends($this->configuration[$identifier]);

        $logger = new Logger($backends);
        $this->instances[$identifier] = $logger;
        return $logger;
    }