Returns all escaping interceptors for a given Interception Point.

@param integer $interceptionPoint one of the \TYPO3\Fluid\Core\Parser\InterceptorInterface::INTERCEPT_* constants,
@return \SplObjectStorage<\TYPO3\Fluid\Core\Parser\InterceptorInterface>
509197
public function getEscapingInterceptors($interceptionPoint)
    {
        return isset($this->escapingInterceptors[$interceptionPoint]) ? $this->escapingInterceptors[$interceptionPoint] : new \SplObjectStorage();
    }
1291783
public function interceptMethodCall(ProceedingJoinPointInterface $jointPoint) {
        $key = md5(serialize(array(
                    get_class($jointPoint->getTarget()),
                    $jointPoint->getMethodName(),
                    $jointPoint->getArguments()
                )));
        $value = $this->cache->get($key);

        if ($value === null) {
            $value = $jointPoint->proceed();
            $this->cache->set($key, $value, $this->ttl);
        }
        return $value;
    }
1354644
protected function getOrigin($endPoint)
    {
        $url = parse_url($endPoint);
        $origin = $url['scheme'].'://'.$url['host'];
        if (isset($url['port'])) {
            $origin = $origin.':'.$url['port'];
        }

        return $origin;
    }
635579
public function getByPosition($position)
    {
        $position = (int) $position;

        if (!isset($this->parametersByPosition[$position])) {
            throw new \Exception('Parameter is not defined !');
        }

        return $this->parametersByPosition[$position];
    }
961086
private function _parseInterceptMap($env)
    {
        // Set up authN/authZ if an URL mapping was given.
        if (isset($env['auth.interceptUrlMap']) && is_array($env['auth.interceptUrlMap'])) {
            // We may need to modify the intercept map, so make a copy of it
            $interceptMap = $env['auth.interceptUrlMap'];

            // Always allow HEAD requests unless the user specifically blocked them
            if (!array_key_exists('HEAD', $interceptMap)) {
                $interceptMap['HEAD'] = ['/**' => ['authN' => 'permitAll', 'authZ' => 'permitAll']];
            }

            // If the request method is not in the Intercept Map, throw an exception
            if (!array_key_exists($env['REQUEST_METHOD'], $interceptMap)) {
                throw new \Exception(
                    "Request Type: " . $env['REQUEST_METHOD'] . " does not exist in Auth Intercept Map"
                );
            }

            $antPathMatcher = new AntPathMatcher();
            foreach ($interceptMap[$env['REQUEST_METHOD']] as $pattern => $auth_array) {
                // Break out of the foreach loop if this URL matches the pattern.
                if ($antPathMatcher->match($pattern, $env['PATH_INFO'])) {
                    $this->authN_type = $auth_array['authN'];
                    $this->authZ_roles = $auth_array['authZ'];
                    break;
                }
            }
        }
    }
764940
private function escapeSpecialCharacters($line)
    {
        $line = $this->escapeFirstCharacters($line);

        $line = $this->escapeOtherCharacters($line);

        return $this->escapeOtherCharactersRegex($line);
    }
753543
public function endpoint(ApiEndpoint $endpoint)
    {
        $this->endpointsByName[$endpoint->getName()] = $endpoint;

        switch ($endpoint->getHttpMethod()) {

            case HttpMethods::GET:

                $this->get($endpoint->getPath(), $endpoint->getHandlerMethod(), $this->createRouteName($endpoint));
                break;

            case HttpMethods::POST:

                $this->post($endpoint->getPath(), $endpoint->getHandlerMethod(), $this->createRouteName($endpoint));
                break;

            case HttpMethods::PUT:

                $this->put($endpoint->getPath(), $endpoint->getHandlerMethod(), $this->createRouteName($endpoint));
                break;

            case HttpMethods::DELETE:

                $this->delete($endpoint->getPath(), $endpoint->getHandlerMethod(), $this->createRouteName($endpoint));
                break;
        }

        return $this;
    }
1293203
public function generateKey(InterceptionInterface $interception, CacheAnnotationInterface $annotation) : string
    {
        $format = property_exists($annotation, 'key') ? $annotation->key : '';
        $parameters = array_merge($interception->getParams(), ['interception' => $interception]);
        if ($format && $result = $this->language->evaluate($format, $parameters)) {
            return sha1(serialize($result));
        }

        return $this->keyGenerator->generateKey($interception, $annotation);
    }
766908
public function interceptMethodCall(ProceedingJoinPointInterface $jointPoint) {
        try {
            return $jointPoint->proceed();
        } catch (Exception $e) {
            $methodName = $jointPoint->getMethodName();
            $partialTrace = array();
            $trace = $e->getTrace();
            $depth = 0;
            foreach ($trace as $entry) {
                if ($depth > $this->maxTraceDepth) {
                    $partialTrace[] = "... trace truncated";
                    break;
                }
                $file = isset($entry['file']) ? $entry['file'] : "";
                $function = isset($entry['function']) ? $entry['function'] : "";
                $line = isset($entry['line']) ? $entry['line'] : "";

                $partialTrace[] = sprintf("%s:%s:%s", $file, $function, $line);
                $depth++;
            }

            $msg = sprintf("Exception in %s:%s:%s (%d) %s", $e->getFile(), $e->getLine(), $methodName, $e->getCode(), $e->getMessage());
            $this->logger->logWarning($msg, implode("\n", $partialTrace));
            throw $e;
        }
    }
1218904
public static function getExtractPropertys($object)
    {
        $list = AnnotationManager::getPropertiesAnnotations(BeanFactory::getObjectClass($object), ExtractProperty::class);
        if(null !== $list)
        {
            return $list;
        }
        else
        {
            return [];
        }
    }
31070
public function parse(AroundJoinPoint $joinPoint)
    {
        $class = get_parent_class($joinPoint->getTarget());
        $injectArgs = AnnotationManager::getMethodAnnotations($class, $joinPoint->getMethod(), InjectArg::class);
        $args = ClassObject::convertArgsToKV($class, $joinPoint->getMethod(), $joinPoint->getArgs());

        foreach($injectArgs as $injectArg)
        {
            $args[$injectArg->name] = $injectArg->value;
        }

        $args = array_values($args);

        return $joinPoint->proceed($args);
    }
929771
public function parseLock(AroundJoinPoint $joinPoint)
    {
        $class = get_parent_class($joinPoint->getTarget());
        // Lockable 注解
        $lockable = AnnotationManager::getMethodAnnotations($class, $joinPoint->getMethod(), Lockable::class)[0] ?? null;
        return $this->parseLockable($joinPoint->getTarget(), $joinPoint->getMethod(), $joinPoint->getArgs(), $lockable, function() use($joinPoint){
            return $joinPoint->proceed();
        });
    }
981048
private static function parseEndPoint(string $endPoint)
    {
        $endPoint = trim($endPoint, '/');
        $endPointArray = explode('/', $endPoint);
        if ($endPointArray[0] == "api") {
            return $endPoint;
        }
        array_unshift($endPointArray, "api");

        return implode('/', array_filter($endPointArray));
    }
259473
public function get(string $endPoint)
    {
        $parsedEndPoint = self::parseEndPoint($endPoint);
        return $this->sendRequest($parsedEndPoint, "GET");
    }
362196
public function bindInterceptor(AbstractMatcher $classMatcher, AbstractMatcher $methodMatcher, array $interceptors)
    {
        $pointcut = new Pointcut($classMatcher, $methodMatcher, $interceptors);
        $this->container->addPointcut($pointcut);
        foreach ($interceptors as $interceptor) {
            (new Bind($this->container, $interceptor))->to($interceptor)->in(Scope::SINGLETON);
        }
    }
283654
private function parseInterceptMap($request)
    {
        // Set up authN/authZ if an URL mapping was given.
        if (isset($this->config['interceptUrlMap']) && is_array($this->config['interceptUrlMap'])) {
            // We may need to modify the intercept map, so make a copy of it
            $interceptMap = $this->config['interceptUrlMap'];

            // Always allow HEAD requests unless the user specifically blocked them
            if (!array_key_exists('HEAD', $interceptMap)) {
                $interceptMap['HEAD'] = ['/**' => ['authN' => 'permitAll', 'authZ' => 'permitAll']];
            }

            // If the request method is not in the intercept map, throw an exception
            if (!array_key_exists($request->getMethod(), $interceptMap)) {
                throw new \Exception(
                    "Request Type: " . $request->getMethod() . " does not exist in Auth Intercept Map"
                );
            }

            $antPathMatcher = new AntPathMatcher();
            foreach ($interceptMap[$request->getMethod()] as $pattern => $auth_array) {
                // Support RegEx or Ant patterns
                if ($pattern[0] == '^') {
                    $match = preg_match('/'.$pattern.'/', $request->getUri()->getPath());
                } else {
                    $match = $antPathMatcher->match($pattern, $request->getUri()->getPath());
                }
                // Break out of the foreach loop if this URL matches the pattern.
                if ($match) {
                    $this->authN_type = $auth_array['authN'];
                    $this->authZ_roles = $auth_array['authZ'];
                    break;
                }
            }
        }
    }
1169572
public function endpoint(Endpoint $endpoint = null)
    {
        if ($endpoint === null) {
            return $this->getRepository();
        }

        $this->repository($endpoint);

        return $this;
    }