/** * Performs matching of point of code * * @param mixed $point Specific part of code, can be any Reflection class * @param null|mixed $context Related context, can be class or namespace * @param null|string|object $instance Invocation instance or string for static calls * @param null|array $arguments Dynamic arguments for method * * @return bool */ public function matches($point, $context = null, $instance = null, array $arguments = null) { if (!$this->modifierFilter->matches($point, $context)) { return false; } return $point->name === $this->name || (bool) preg_match("/^(?:{$this->regexp})\$/", $point->name); }
/** * {@inheritdoc} */ public function matches($point) { if (!$this->modifierFilter->matches($point)) { return false; } return $point->name === $this->name || (bool) preg_match("/^(?:{$this->regexp})\$/", $point->name); }
/** * Performs matching of point of code * * @param mixed $method Specific part of code, can be any Reflection class * @param null|string|object $instance Invocation instance or string for static calls * @param null|array $arguments Dynamic arguments for method * * @return bool */ public function matches($method, $instance = null, array $arguments = null) { /** @var $method ReflectionMethod|ParsedReflectionMethod */ if (!$method instanceof ReflectionMethod && !$method instanceof ParsedReflectionMethod) { return false; } if (!$this->modifierFilter->matches($method)) { return false; } return $method->name === $this->methodName || (bool) preg_match("/^(?:{$this->regexp})\$/", $method->name); }
/** * Method invoker * * @param Joinpoint $joinpoint the method invocation joinpoint * * @return mixed the result of the call to {@see Joinpoint->proceed()} */ public final function invoke(Joinpoint $joinpoint) { if ($joinpoint instanceof Invocation) { $point = $joinpoint->getStaticPart(); $instance = $joinpoint->getThis(); $context = new \ReflectionClass($instance); if ($this->pointFilter->matches($point, $context, $instance, $joinpoint->getArguments())) { return $this->interceptor->invoke($joinpoint); } } return $joinpoint->proceed(); }
/** * Performs matching of point of code * * @param mixed $method Specific part of code, can be any Reflection class * @param null|string|object $instance Invocation instance or string for static calls * @param null|array $arguments Dynamic arguments for method * * @return bool */ public function matches($method, $instance = null, array $arguments = null) { // With single parameter (statically) always matches for __call, __callStatic if (!$instance) { return $method->name === '__call' || $method->name === '__callStatic'; } if (!$this->modifierFilter->matches($method)) { return false; } // for __call and __callStatic method name is the first argument on invocation list($methodName) = $arguments; return $methodName === $this->methodName || (bool) preg_match("/^(?:{$this->regexp})\$/", $methodName); }
/** * Performs matching of point of code * * @param mixed $property * * @return bool */ public function matches($property) { /** @var $property ReflectionProperty|ParsedReflectionProperty */ if (!$property instanceof ReflectionProperty && !$property instanceof ParsedReflectionProperty) { return false; } if (!$this->modifierFilter->matches($property)) { return false; } return $property->name === $this->propertyName || (bool) preg_match("/^(?:{$this->regexp})\$/", $property->name); }
/** * Performs matching of point of code * * @param mixed $method Specific part of code, can be any Reflection class * @param null|string|object $instance Invocation instance or string for static calls * @param null|array $arguments Dynamic arguments for method * * @return bool */ public function matches($method, $instance = null, array $arguments = null) { // With single parameter (statically) always matches if (!$instance) { return true; } $trace = debug_backtrace(DEBUG_BACKTRACE_IGNORE_ARGS); foreach ($trace as $stackFrame) { if (!isset($stackFrame['class'])) { continue; } $refClass = new ReflectionClass($stackFrame['class']); if (!$this->internalClassFilter->matches($refClass)) { continue; } $refMethod = new ReflectionMethod($stackFrame['class'], $stackFrame['function']); if ($this->internalPointFilter->matches($refMethod)) { return true; } } return false; }
/** * Performs matching of point of code * * @param mixed $point Specific part of code, can be any Reflection class * * @return bool */ public function matches($point) { return $this->first->matches($point) || $this->second->matches($point); }
/** * Performs matching of point of code * * @param mixed $point Specific part of code, can be any Reflection class * * @return bool */ public function matches($point) { return !$this->first->matches($point); }
/** * Performs matching of point of code * * @param mixed $point Specific part of code, can be any Reflection class * @param null|mixed $context Related context, can be class or namespace * @param null|string|object $instance Invocation instance or string for static calls * @param null|array $arguments Dynamic arguments for method * * @return bool */ public function matches($point, $context = null, $instance = null, array $arguments = null) { return $this->first->matches($point, $context) && $this->second->matches($point, $context); }
/** * Returns list of function advices for specific namespace * * @param ReflectionFileNamespace $namespace * @param Aop\PointcutAdvisor $advisor Advisor for class * @param string $advisorId Identifier of advisor * @param Aop\PointFilter $pointcut Filter for points * * @return array */ private function getFunctionAdvicesFromAdvisor($namespace, $advisor, $advisorId, $pointcut) { $functions = array(); $advices = array(); if (!$functions) { $listOfGlobalFunctions = get_defined_functions(); foreach ($listOfGlobalFunctions['internal'] as $functionName) { $functions[$functionName] = new NamespacedReflectionFunction($functionName, $namespace->getName()); } } foreach ($functions as $functionName => $function) { if ($pointcut->matches($function)) { $advices[AspectContainer::FUNCTION_PREFIX][$functionName][$advisorId] = $advisor->getAdvice(); } } return $advices; }