PHP ReflectionFunction::getClosure方法代码示例

 /**
  * @param  mixed   class, object, callable
  * @param  string  method
  * @return \Closure
  */
 public static function closure($callable, $m = NULL)
 {
     if ($m !== NULL) {
         $callable = array($callable, $m);
     } elseif (is_string($callable) && count($tmp = explode('::', $callable)) === 2) {
         $callable = $tmp;
     } elseif ($callable instanceof \Closure) {
         return $callable;
     } elseif (is_object($callable)) {
         $callable = array($callable, '__invoke');
     }
     if (PHP_VERSION_ID >= 50400) {
         if (is_string($callable) && function_exists($callable)) {
             $r = new \ReflectionFunction($callable);
             return $r->getClosure();
         } elseif (is_array($callable) && method_exists($callable[0], $callable[1])) {
             $r = new \ReflectionMethod($callable[0], $callable[1]);
             return $r->getClosure($callable[0]);
         }
     }
     self::check($callable);
     $_callable_ = $callable;
     return function () use($_callable_) {
         return call_user_func_array($_callable_, func_get_args());
     };
 }

 /**
  * Constructor
  *
  * @param string $name
  * @param function $fn
  */
 public function __construct($name, $fn)
 {
     $this->fn = $fn;
     $this->name = $name;
     if (!Preview::is_php53()) {
         $ref = new \ReflectionFunction($fn);
         $this->fn = $ref->getClosure();
     }
 }

 /**
  * Casts the given callable to Closure
  * @param callable $callable
  * @return \Closure
  * @throws \InvalidArgumentException
  */
 protected function castToClosure($callable)
 {
     if (!is_callable($callable)) {
         throw new \InvalidArgumentException('Argument 1 must be callable, ' . gettype($callable) . ' given.');
     }
     $result = null;
     if (is_object($callable)) {
         if ($callable instanceof \Closure) {
             $result = $callable;
         } else {
             if (method_exists($callable, '__invoke')) {
                 $r = new \ReflectionObject($callable);
                 $result = $r->getMethod('__invoke')->getClosure($callable);
             }
         }
     } else {
         try {
             $r = new \ReflectionMethod($callable);
             $result = $r->getClosure();
         } catch (\Exception $e) {
             try {
                 $r = new \ReflectionFunction($callable);
                 $result = $r->getClosure();
             } catch (\Exception $e) {
                 if (is_array($callable)) {
                     $r = new \ReflectionObject($callable[0]);
                     $result = $r->getMethod($callable[1])->getClosure($callable[0]);
                 }
             }
         }
     }
     if ($result === null) {
         throw new \InvalidArgumentException('Unsupported callable given.');
     }
     return $result;
 }

 /**
  * Returns the function/method as closure.
  *
  * @return \Closure
  */
 public function getClosure()
 {
     if (PHP_VERSION_ID >= 50400) {
         return parent::getClosure();
     } else {
         $that = $this;
         return function () use($that) {
             return $that->invokeArgs(func_get_args());
         };
     }
 }

 /**
  * {@inheritDoc}
  */
 public function getClosure()
 {
     $this->initializeInternalReflection();
     return parent::getClosure();
 }

 public function getClosure()
 {
     return PHP_VERSION_ID < 50400 ? Nette\Utils\Callback::closure($this->value) : parent::getClosure();
 }

<?php

/* Prototype  : public mixed ReflectionFunction::getClosure()
 * Description: Returns a dynamically created closure for the function
 * Source code: ext/reflection/php_reflection.c
 * Alias to functions:
 */
echo "*** Testing ReflectionFunction::getClosure() : error conditions ***\n";
function foo()
{
    var_dump("Inside foo function");
}
$func = new ReflectionFunction('foo');
$closure = $func->getClosure('bar');
?>
===DONE===

 /**
  * Gets the closure instance.
  *
  * @return \Closure
  */
 public function getClosure()
 {
     return $this->reflection->getClosure();
 }

<?php

/* Prototype  : public mixed ReflectionFunction::getClosure()
 * Description: Returns a dynamically created closure for the function 
 * Source code: ext/reflection/php_reflection.c
 * Alias to functions: 
 */
echo "*** Testing ReflectionFunction::getClosure() : basic functionality ***\n";
function foo()
{
    var_dump("Inside foo function");
}
function bar($arg)
{
    var_dump("Arg is " . $arg);
}
$func = new ReflectionFunction('foo');
$closure = $func->getClosure();
$closure();
$func = new ReflectionFunction('bar');
$closure = $func->getClosure();
$closure('succeeded');
?>
===DONE===

{
    return $a + 2;
}
$foo = function ($a) {
    return $a + 3;
};
$bar = new Bar(10);
// Dynamic methods
$rf = new ReflectionMethod($bar, 'baz');
var_dump($rf->getClosure() === NULL);
var_dump(call_user_func($rf->getClosure($bar), 1));
$rf = new ReflectionMethod('Bar', 'baz');
var_dump($rf->getClosure() === NULL);
var_dump(call_user_func($rf->getClosure($bar), 1));
$rf = new ReflectionMethod('Bar::baz');
var_dump($rf->getClosure() === NULL);
var_dump(call_user_func($rf->getClosure($bar), 1));
// Static methods
$rf = new ReflectionMethod($bar, 'foo');
var_dump(call_user_func($rf->getClosure(), 1));
$rf = new ReflectionMethod('Bar', 'foo');
var_dump(call_user_func($rf->getClosure(), 1));
$rf = new ReflectionMethod('Bar::foo');
var_dump(call_user_func($rf->getClosure(), 1));
// Function
$rf = new ReflectionFunction('foo');
var_dump(call_user_func($rf->getClosure(), 1));
// Closure
$rf = new ReflectionFunction($foo);
var_dump(call_user_func($rf->getClosure(), 1));

<?php

$closure = function () {
    echo "Invoked!\n";
};
$method = new ReflectionFunction($closure);
$closure2 = $method->getClosure();
$closure2();
$closure2->__invoke();
unset($closure);
$closure2();
$closure2->__invoke();
$closure = function () {
    echo "Invoked!\n";
};
$method = new ReflectionMethod($closure, '__invoke');
$closure2 = $method->getClosure($closure);
$closure2();
$closure2->__invoke();
unset($closure);
$closure2();
$closure2->__invoke();
?>
===DONE===

 /**
  * Load config from file.
  *
  * @param string $file config file path
  * @return object Configuration object.
  */
 public function load_from_file($file)
 {
     $options = (require_once $file);
     if (!is_array($options)) {
         $options = array();
     }
     $this->update($options);
     if (!Preview::is_php53()) {
         // PHP 5.4 and above will automatically
         // bind current $this (if any) to closure.
         // For example, if we call load_from_file method
         // the hooks defined in config file will be bound to
         // the current configuration object($this).
         // So we unbind hook closure.
         $hooks = array("before_hook", "after_hook", "before_each_hook", "after_each_hook");
         foreach ($hooks as $hook) {
             if ($this->{$hook}) {
                 $ref = new \ReflectionFunction($this->{$hook});
                 $this->{$hook} = $ref->getClosure();
             }
         }
     }
 }

 /**
  * constructor
  *
  * @param string $title
  * @param function $fn
  */
 public function __construct($title, $fn)
 {
     $this->context = new \stdClass();
     $this->title = $title;
     $this->pending = !isset($fn);
     $this->timer = new Timer();
     $this->fn = $fn;
     if ($fn) {
         $ref = new \ReflectionFunction($fn);
         $this->filename = $ref->getFileName();
         $this->startline = $ref->getStartLine();
         $this->endline = $ref->getEndLine();
         if (!Preview::is_php53()) {
             $this->fn = $ref->getClosure();
         }
     }
 }

/**
 * Converts any valid PHP callable into a Closure. Requires PHP 5.4.0+.
 *
 * The ramifications of this are many, but basically it means that any function
 * or method can be converted into a Closure, bound to another scope, and
 * executed easily. Works properly even with private methods.
 *
 * - On success, returns a Closure corresponding to the provided callable.
 * - If the parameter is not callable, issues an E_USER_WARNING and returns a
 *   Closure which only returns null.
 * - In the event of a strange or unrecoverable situation (e.g. providing a
 *   non-static method without an object), an UnexpectedValueException is
 *   thrown.
 *
 * @author Matthew Lanigan <rintaun@gmail.com>
 * @copyright (c) 2012, Matthew Lanigan
 * @license http://www.opensource.org/licenses/mit-license.php MIT License
 * @link https://gist.github.com/2773168 Official closurize() gist
 * @param callable $callable
 * @return \Closure
 * @throws \UnexpectedValueException
 */
function closurize($callable)
{
    if ($callable instanceof \Closure) {
        return $callable;
    }
    $is_callable = function ($callable) {
        return \is_callable($callable);
    };
    $error = function () {
        $debug = \debug_backtrace(\DEBUG_BACKTRACE_PROVIDE_OBJECT, 2);
        $fmt = 'Parameter 1 for closurize() must be callable ' . 'in %s on line %d (issued at %s on line %d)';
        $error = \sprintf($fmt, $debug[1]['file'], $debug[1]['line'], $debug[0]['file'], $debug[0]['line']);
        \trigger_error($error, \E_USER_WARNING);
        return function () {
            return null;
        };
    };
    $object = null;
    $class = null;
    $debug = \debug_backtrace(\DEBUG_BACKTRACE_PROVIDE_OBJECT, 2);
    if (isset($debug[1]['object']) && \is_object($debug[1]['object'])) {
        $object = $debug[1]['object'];
        $class = $debug[1]['class'];
        $is_callable = $is_callable->bindTo($object, $object);
    }
    if (!$is_callable($callable)) {
        if (isset($callable[0]) && is_object($callable[0])) {
            $is_callable = $is_callable->bindTo($callable[0], $callable[0]);
        } else {
            if (isset($callable[0]) && \class_exists($callable[0])) {
                $is_callable = $is_callable->bindTo(null, $callable[0]);
            }
        }
        if (!$is_callable($callable)) {
            return $error();
        }
    }
    if (\is_string($callable) && \strpos($callable, '::') === false) {
        $ref = new \ReflectionFunction($callable);
        return $ref->getClosure();
    } else {
        if (\is_string($callable)) {
            $callable = \explode('::', $callable);
        }
    }
    if (!\is_array($callable)) {
        throw new \UnexpectedValueException('Callable is not string, array, ' . 'or Closure');
    }
    if (\is_object($callable[0])) {
        $ref = new \ReflectionMethod($callable[0], $callable[1]);
        return $ref->getClosure($callable[0]);
    }
    if (!\is_string($callable[0])) {
        throw new \UnexpectedValueException('Callable class is not string ' . 'or object');
    }
    switch ($callable[0]) {
        case 'self':
            if (!\is_object($object) && \is_null($class)) {
                return $error();
            }
            $self = function () {
                return \get_class();
            };
            $self = $self->bindTo($object, $class);
            $ref = new \ReflectionMethod($self(), $callable[1]);
            $callable[0] = $object;
            break;
        case 'static':
            if (!\is_object($object)) {
                return $error();
            }
            $static = function () {
                return \get_called_class();
            };
            $static = $static->bindTo($object, $class);
            $ref = new \ReflectionMethod($static(), $callable[1]);
            $callable[0] = $object;
            break;
//.........这里部分代码省略.........