PHP Closure::bindTo方法代码示例

 /**
  * Constructs a test suite, which may contain nested suites and specs. The
  * anonymous function passed to the constructor contains the body of the
  * suite to be ran, and it is bound to the suite.
  *
  * @param string   $title   A title to be associated with the suite
  * @param \Closure $closure The closure to invoke when the suite is ran
  * @param Suite    $parent  An optional parent suite
  */
 public function __construct($title, \Closure $closure, Suite $parent = null)
 {
     $this->title = $title;
     if (version_compare(PHP_VERSION, '5.4.0', ">=")) {
         $this->closure = $closure->bindTo($this);
     } else {
         $this->closure = $closure;
     }
     $this->specs = array();
     $this->suites = array();
     $this->store = array();
     $this->parent = $parent;
 }

 /**
  * Invokes original method and return result from it
  *
  * @return mixed
  */
 public function proceed()
 {
     if (isset($this->advices[$this->current])) {
         /** @var $currentInterceptor \Go\Aop\Intercept\Interceptor */
         $currentInterceptor = $this->advices[$this->current++];
         return $currentInterceptor->invoke($this);
     }
     // Fill the closure only once if it's empty
     if (!$this->closureToCall) {
         $this->closureToCall = $this->reflectionMethod->getClosure($this->instance);
     }
     // Rebind the closure if instance was changed since last time
     if ($this->previousInstance !== $this->instance) {
         $this->closureToCall = $this->closureToCall->bindTo($this->instance, $this->reflectionMethod->class);
         $this->previousInstance = $this->instance;
     }
     $closureToCall = $this->closureToCall;
     $args = $this->arguments;
     switch (count($args)) {
         case 0:
             return $closureToCall();
         case 1:
             return $closureToCall($args[0]);
         case 2:
             return $closureToCall($args[0], $args[1]);
         case 3:
             return $closureToCall($args[0], $args[1], $args[2]);
         case 4:
             return $closureToCall($args[0], $args[1], $args[2], $args[3]);
         case 5:
             return $closureToCall($args[0], $args[1], $args[2], $args[3], $args[4]);
         default:
             return forward_static_call_array($closureToCall, $args);
     }
 }

 public function get()
 {
     if (!$this->closure instanceof \Closure) {
         throw new \RuntimeException("Cannot get a key with an undefined closure");
     }
     if ($this->enabled) {
         $data = $this->predis->get($this->getKeyName($this->key));
     }
     if ($data === null) {
         $boundCallback = $this->closure->bindTo($this);
         $data = $boundCallback();
         if ($this->enabled) {
             $this->predis->setex($this->getKeyName($this->key), $this->ttl, serialize($data));
         }
         if ($this->onMiss instanceof \Closure) {
             call_user_func_array($this->onMiss, [$this, $data]);
         }
         return $data;
     } else {
         $value = unserialize($data);
         if ($this->onHit instanceof \Closure) {
             call_user_func_array($this->onHit, [$this, $value]);
         }
         return $value;
     }
 }

 /**
  * Handles the event
  *
  * @param Event $event
  * @return mixed|void
  */
 public function discern(Event $event)
 {
     if ($this->eventInstance && !$event instanceof $this->eventInstance) {
         return;
     }
     $callback = $this->callback->bindTo($this, $this);
     $callback($event);
 }

 /**
  * Execute the console command.
  *
  * @param \Symfony\Component\Console\Input\InputInterface   $input
  * @param \Symfony\Component\Console\Output\OutputInterface $output
  *
  * @return mixed
  */
 protected function execute(InputInterface $input, OutputInterface $output)
 {
     $inputs = array_merge($input->getArguments(), $input->getOptions());
     $parameters = [];
     foreach ((new ReflectionFunction($this->callback))->getParameters() as $parameter) {
         if (isset($inputs[$parameter->name])) {
             $parameters[$parameter->name] = $inputs[$parameter->name];
         }
     }
     return $this->getInvoker()->call($this->callback->bindTo($this, $this), $parameters);
 }

 /**
  * Runs the stub.
  *
  * @param  string $self   The context form which the stub need to be executed.
  * @param  array  $params The call parameters array.
  * @return mixed          The returned stub result.
  */
 public function __invoke($self, $params)
 {
     if ($this->_closure) {
         if (is_string($self)) {
             $closure = $this->_closure->bindTo(null, $self);
         } else {
             $closure = $this->_closure->bindTo($self, get_class($self));
         }
         return call_user_func_array($closure, $params);
     }
     if (isset($this->_returns[$this->_index])) {
         return $this->_returns[$this->_index++];
     }
     return $this->_returns ? end($this->_returns) : null;
 }

 /**
  * Invokes original method and return result from it
  *
  * @return mixed
  */
 public function proceed()
 {
     if (isset($this->advices[$this->current])) {
         /** @var $currentInterceptor MethodInterceptor */
         $currentInterceptor = $this->advices[$this->current++];
         return $currentInterceptor->invoke($this);
     }
     // Rebind the closure if scope (class name) was changed since last time
     if ($this->previousScope !== $this->instance) {
         $this->closureToCall = $this->closureToCall->bindTo(null, $this->instance);
         $this->previousScope = $this->instance;
     }
     $closureToCall = $this->closureToCall;
     return $closureToCall($this->arguments);
 }

 /**
  * @return void
  */
 public final function customInit()
 {
     if ($this->customInitClosure instanceof \Closure) {
         $customInitClosure = $this->customInitClosure->bindTo($this, $this);
         $customInitClosure();
     }
 }

 public function on($event, \Closure $callback)
 {
     if (is_string($event)) {
         $this->events[$event] = $callback->bindTo($this, $this);
     }
     return $this;
 }

 /**
  * Constructs a Spec, to be associated with a particular suite, and ran
  * by the test runner. The closure is bound to the suite.
  *
  * @param string   $title   A title to be associated with the spec
  * @param \Closure $closure The closure to invoke when the spec is called
  * @param Suite    $suite   The suite within which this spec was defined
  */
 public function __construct($title, \Closure $closure = null, Suite $suite)
 {
     $this->title = $title;
     $this->suite = $suite;
     if ($closure) {
         $this->closure = $closure->bindTo($suite);
     }
 }

 /**
  * Registers a route.
  *
  * @param  string $name
  * @param  \Closure $handler
  *
  * @return Route
  */
 public function add($name, \Closure $handler)
 {
     // Bind the handler to the Router class
     $route = new Route($name, $handler->bindTo($this, $this));
     // Insert the route
     $this->routes[$name] = $route;
     return $route;
 }

 public function fingerprint(\Closure $fingerprint = null)
 {
     if (func_num_args() > 0) {
         $this->_fingerprint = $fingerprint->bindTo($this);
         return $this;
     }
     return $this->_fingerprint;
 }

 /**
  * @param string $prefix
  * @param \Closure $closure
  */
 public function group($prefix, \Closure $closure)
 {
     $original = $this->prefix;
     $this->prefix = sprintf('/%s/%s', trim($original, '/'), trim($prefix, '/'));
     $callback = $closure->bindTo($this);
     $callback();
     $this->prefix = $original;
 }

 public function __construct(\Closure $closure, Suite $suite)
 {
     $this->suite = $suite;
     if (version_compare(PHP_VERSION, '5.4.0', '>=')) {
         $this->closure = $closure->bindTo($suite);
     } else {
         $this->closure = $closure;
     }
 }

 /**
  * Invokes original method and return result from it
  *
  * @return mixed
  */
 public function proceed()
 {
     if (isset($this->advices[$this->current])) {
         /** @var $currentInterceptor Interceptor */
         $currentInterceptor = $this->advices[$this->current++];
         return $currentInterceptor->invoke($this);
     }
     // Fill the closure only once if it's empty
     if (!$this->closureToCall) {
         $this->closureToCall = $this->reflectionMethod->getClosure($this->instance);
     }
     // Rebind the closure if instance was changed since last time
     if ($this->previousInstance !== $this->instance) {
         $this->closureToCall = $this->closureToCall->bindTo($this->instance, $this->reflectionMethod->class);
         $this->previousInstance = $this->instance;
     }
     $closureToCall = $this->closureToCall;
     return $closureToCall(...$this->arguments);
 }