ProxyClassBuilder

No description

Injects the reflection service

Injects the (system) logger based on PSR-3.

Injects an instance of the pointcut expression parser

Injects the cache for storing information about objects

Injects the Adviced Constructor Interceptor Builder

Injects the Adviced Method Interceptor Builder

No description

Builds proxy class code which weaves advices into the respective target classes.

The object configurations provided by the Compiler are searched for possible aspect annotations. If an aspect class is found, the pointcut expressions are parsed and a new aspect with one or more advisors is added to the aspect registry of the AOP framework. Finally all advices are woven into their target classes by generating proxy classes.

In general, the command neos.flow:core:compile is responsible for compilation and calls this method to do so.

In order to distinguish between an emerged / changed possible target class and a class which has been matched previously but just didn't have to be proxied, the latter are kept track of by an "unproxiedClass-*" cache entry.

Traverses the aspect containers to find a pointcut from the aspect class name and pointcut method name

Determines which of the given classes are potentially proxyable and returns their names in an array.

Checks the annotations of the specified classes for aspect tags and creates an aspect with advisors accordingly.

Creates and returns an aspect from the annotations found in a class which is tagged as an aspect. The object acting as an advice will already be fetched (and therefore instantiated if necessary).

Builds methods for a single AOP proxy class for the specified class.

Makes sure that any sub classes of an adviced class also build the advices array on construction.

Adds code to build the methods and advices array in case the parent class has some.

Returns the methods of the target class.

Creates code for an array of target methods and their advices.

Example:

$this->Flow_Aop_Proxy_targetMethodsAndGroupedAdvices = array( 'getSomeProperty' => array( \Neos\Flow\Aop\Advice\AroundAdvice::class => array( new \Neos\Flow\Aop\Advice\AroundAdvice(\Neos\Foo\SomeAspect::class, 'aroundAdvice', \Neos\Flow\Core\Bootstrap::$staticObjectManager, function() { ... }), ), ), );

Traverses all intercepted methods and their advices and builds PHP code to intercept methods if necessary.

The generated code is added directly to the proxy class by calling the respective methods of the Compiler API.

Traverses all aspect containers, their aspects and their advisors and adds the methods and their advices to the (usually empty) array of intercepted methods.

Traverses all methods which were introduced by interfaces and adds them to the intercepted methods array if they didn't exist already.

Traverses all aspect containers and returns an array of interface introductions which match the target class.

Traverses all aspect containers and returns an array of property introductions which match the target class.

Traverses all aspect containers and returns an array of trait introductions which match the target class.

Returns an array of interface names introduced by the given introductions

Returns all methods declared by the introduced interfaces

Renders a short message which gives a hint on where the currently parsed pointcut expression was defined.