488 lines
15 KiB
PHP
488 lines
15 KiB
PHP
<?php
|
|
namespace nur\sery\wip\php;
|
|
|
|
use Closure;
|
|
use nur\config\Ref;
|
|
use nur\sery\cv;
|
|
use nur\sery\StateException;
|
|
use nur\sery\ValueException;
|
|
use ReflectionClass;
|
|
use ReflectionFunction;
|
|
use ReflectionMethod;
|
|
|
|
/**
|
|
* Class func: outils pour appeler fonctions et méthodes dynamiquement
|
|
*
|
|
* les fonctions supportées sont:
|
|
* - fonctions simples (globales ou dans un namespace)
|
|
* - fonctions statiques
|
|
* - méthodes
|
|
* - Closure
|
|
* - constructeur (l'appel de cette "fonction" provoque l'instanciation d'un
|
|
* objet)
|
|
*
|
|
* les fonctions statiques et les méthodes peuvent être liées (associées à une
|
|
* classe ou à un objet) ou non liées (il faut les lier avant de pouvoir les
|
|
* utiliser)
|
|
*/
|
|
class func {
|
|
/**
|
|
* vérifier que $func est une fonction simple et la normaliser le cas échéant.
|
|
* retourner true si c'est une fonction simple, false sinon
|
|
*
|
|
* les formes suivantes sont supportées:
|
|
* - "function" si une classe du même nom n'existe pas déjà
|
|
* - [false, "function", ...$args] c'est la forme normalisée
|
|
*
|
|
* @param bool $strict vérifier l'inexistence de la classe et l'existence de
|
|
* la fonction (ne pas uniquement faire une vérification syntaxique)
|
|
*/
|
|
static function verifix_simple(&$func, bool $strict=true): bool {
|
|
if (is_string($func)) {
|
|
$func = [false, $func];
|
|
} elseif (is_array($func)) {
|
|
if (!array_key_exists(0, $func)) return false;
|
|
if ($func[0] !== false) return false;
|
|
if (!array_key_exists(1, $func)) return false;
|
|
if (!is_string($func[1])) return false;
|
|
} else {
|
|
return false;
|
|
}
|
|
$f = $func[1];
|
|
if ($f === "") return false;
|
|
if (strpos($f, "::") !== false) return false;
|
|
if (strpos($f, "->") !== false) return false;
|
|
if ($strict) {
|
|
if (class_exists($f)) return false;
|
|
if (!function_exists($f)) return false;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
/**
|
|
* vérifier que $func est une fonction simple avec les règles de
|
|
* {@link self::verifix_simple()}
|
|
*/
|
|
static function is_simple($func, bool $strict=true): bool {
|
|
return self::verifix_simple($func, $strict);
|
|
}
|
|
|
|
private static function _is_invalid(?string $m): bool {
|
|
return $m === null || $m === "" || $m === "::" || $m === "->";
|
|
}
|
|
|
|
private static function _is_nfunction(?string $m): bool {
|
|
return strpos($m, "\\") !== false;
|
|
}
|
|
|
|
private static function _parse_static(?string &$m): bool {
|
|
$pos = strpos($m, "::");
|
|
if ($pos === false) return false;
|
|
$m = substr($m, $pos + 2);
|
|
return true;
|
|
}
|
|
|
|
private static function _parse_method(?string &$m): bool {
|
|
$pos = strpos($m, "->");
|
|
if ($pos === false) return false;
|
|
$m = substr($m, $pos + 2);
|
|
return true;
|
|
}
|
|
|
|
private static function _parse_class_s(?string $cs, ?string &$c, ?string &$s): bool {
|
|
if (self::_is_invalid($cs) || self::_parse_method($cs)) return false;
|
|
$pos = strpos($cs, "::");
|
|
if ($pos === false) return false;
|
|
if ($pos === 0) return false;
|
|
$tmpc = substr($cs, 0, $pos);
|
|
$cs = substr($cs, $pos + 2);
|
|
if (self::_is_nfunction($cs)) return false;
|
|
[$c, $s] = [$tmpc, cv::vn($cs)];
|
|
return true;
|
|
}
|
|
|
|
private static function _parse_c_static(?string $cs, ?string &$c, ?string &$s, ?bool &$bound): bool {
|
|
if (self::_is_invalid($cs) || self::_parse_method($cs)) return false;
|
|
$pos = strpos($cs, "::");
|
|
if ($pos === false) return false;
|
|
if ($pos == strlen($cs) - 2) return false;
|
|
if ($pos > 0) {
|
|
$tmpc = substr($cs, 0, $pos);
|
|
$bound = true;
|
|
} else {
|
|
$tmpc = null;
|
|
$bound = false;
|
|
}
|
|
$cs = substr($cs, $pos + 2);
|
|
if (self::_is_nfunction($cs)) return false;
|
|
[$c, $s] = [$tmpc, cv::vn($cs)];
|
|
return true;
|
|
}
|
|
|
|
/**
|
|
* vérifier que $func est une méthode statique, et la normaliser le cas
|
|
* échéant. retourner true si c'est une méthode statique, false sinon
|
|
*
|
|
* les formes suivantes sont supportées (XXX étant null ou n'importe quelle
|
|
* valeur scalaire de n'importe quel type sauf false)
|
|
* - "XXX::function"
|
|
* - ["XXX::function", ...$args]
|
|
* - [XXX, "::function", ...$args]
|
|
* - [XXX, "function", ...$args] c'est la forme normalisée
|
|
*
|
|
* Si XXX est une classe, la méthode statique est liée. sinon, elle doit être
|
|
* liée à une classe avant d'être utilisée
|
|
*
|
|
* @param bool $strict vérifier l'existence de la classe et de la méthode si
|
|
* la méthode est liée (ne pas uniquement faire une vérification syntaxique)
|
|
*/
|
|
static function verifix_static(&$func, bool $strict=true, ?bool &$bound=null): bool {
|
|
if (is_string($func)) {
|
|
if (!self::_parse_c_static($func, $c, $f, $bound)) return false;
|
|
$func = [$c, $f];
|
|
} elseif (is_array($func)) {
|
|
if (!array_key_exists(0, $func)) return false;
|
|
$c = $func[0];
|
|
if ($c === false) return false;
|
|
if (self::_parse_class_s($c, $c, $f)) {
|
|
$func[0] = $c;
|
|
if ($f !== null) {
|
|
# ["class::method"] --> ["class", "method"]
|
|
array_splice($func, 1, 0, [$f]);
|
|
}
|
|
$bound = true;
|
|
} elseif (self::_parse_c_static($c, $c, $f, $bound)) {
|
|
# ["::method"] --> [null, "method"]
|
|
array_splice($func, 0, 0, [null]);
|
|
$func[1] = $f;
|
|
} else {
|
|
if (self::_is_invalid($c)) $c = null;
|
|
$func[0] = $c;
|
|
$bound = is_string($c);
|
|
}
|
|
#
|
|
if (!array_key_exists(1, $func)) return false;
|
|
$f = $func[1];
|
|
if (!is_string($f)) return false;
|
|
if (self::_parse_c_static($f, $rc, $f, $rbound)) {
|
|
if ($rc !== null && $c === null) {
|
|
$c = $rc;
|
|
$bound = $rbound;
|
|
}
|
|
} elseif (self::_is_invalid($f)) {
|
|
return false;
|
|
} elseif (self::_is_nfunction($f)) {
|
|
return false;
|
|
} elseif (self::_parse_method($f)) {
|
|
return false;
|
|
} elseif (self::_parse_static($f)) {
|
|
}
|
|
$func[1] = $f;
|
|
} else {
|
|
return false;
|
|
}
|
|
if ($strict && $bound && !method_exists($c, $f)) return false;
|
|
return true;
|
|
}
|
|
|
|
/**
|
|
* vérifier que $func est une méthode statique avec les règles de
|
|
* {@link self::verifix_static()}
|
|
*/
|
|
static function is_static($func, bool $strict=true, ?bool &$bound=null): bool {
|
|
return self::verifix_static($func, $strict, $bound);
|
|
}
|
|
|
|
private static function _parse_class_m(?string $cm, ?string &$c, ?string &$m): bool {
|
|
if (self::_is_invalid($cm) || self::_parse_static($cm)) return false;
|
|
$pos = strpos($cm, "->");
|
|
if ($pos === false) return false;
|
|
if ($pos === 0) return false;
|
|
$tmpc = substr($cm, 0, $pos);
|
|
$cm = substr($cm, $pos + 2);
|
|
if (self::_is_nfunction($cm)) return false;
|
|
[$c, $m] = [$tmpc, cv::vn($cm)];
|
|
return true;
|
|
}
|
|
|
|
private static function _parse_c_method(?string $cm, ?string &$c, ?string &$m, ?bool &$bound): bool {
|
|
if (self::_is_invalid($cm) || self::_parse_static($cm)) return false;
|
|
$pos = strpos($cm, "->");
|
|
if ($pos === false) return false;
|
|
if ($pos == strlen($cm) - 2) return false;
|
|
if ($pos > 0) {
|
|
$tmpc = substr($cm, 0, $pos);
|
|
$bound = true;
|
|
} else {
|
|
$tmpc = null;
|
|
$bound = false;
|
|
}
|
|
$cm = substr($cm, $pos + 2);
|
|
if (self::_is_nfunction($cm)) return false;
|
|
[$c, $m] = [$tmpc, cv::vn($cm)];
|
|
return true;
|
|
}
|
|
|
|
/**
|
|
* vérifier que $func est une méthode non statique, et la normaliser le cas
|
|
* échéant. retourner true si c'est une méthode non statique, false sinon
|
|
*
|
|
* les formes suivantes sont supportées (XXX étant null ou n'importe quelle
|
|
* valeur scalaire de n'importe quel type sauf false)
|
|
* - "XXX->function"
|
|
* - ["XXX->function", ...$args]
|
|
* - [XXX, "->function", ...$args]
|
|
* - [XXX, "function", ...$args] c'est la forme normalisée
|
|
*
|
|
* Si XXX est une classe, la méthode est liée. sinon, elle doit être liée à un
|
|
* objet avant d'être utilisée
|
|
*
|
|
* @param bool $strict vérifier l'existence de la classe et de la méthode si
|
|
* la méthode est liée (ne pas uniquement faire une vérification syntaxique)
|
|
*/
|
|
static function verifix_method(&$func, bool $strict=true, ?bool &$bound=null): bool {
|
|
if (is_string($func)) {
|
|
if (!self::_parse_c_method($func, $c, $f, $bound)) return false;
|
|
$func = [$c, $f];
|
|
} elseif (is_array($func)) {
|
|
if (!array_key_exists(0, $func)) return false;
|
|
$c = $func[0];
|
|
if ($c === false) return false;
|
|
if (self::_parse_class_m($c, $c, $f)) {
|
|
$func[0] = $c;
|
|
if ($f !== null) {
|
|
# ["class->method"] --> ["class", "method"]
|
|
array_splice($func, 1, 0, [$f]);
|
|
}
|
|
$bound = true;
|
|
} elseif (self::_parse_c_method($c, $c, $f, $bound)) {
|
|
# ["->method"] --> [null, "method"]
|
|
array_splice($func, 0, 0, [null]);
|
|
$func[1] = $f;
|
|
} else {
|
|
if (self::_is_invalid($c)) $c = null;
|
|
$func[0] = $c;
|
|
$bound = is_string($c);
|
|
}
|
|
#
|
|
if (!array_key_exists(1, $func)) return false;
|
|
$f = $func[1];
|
|
if (!is_string($f)) return false;
|
|
if (self::_parse_c_method($f, $rc, $f, $rbound)) {
|
|
if ($rc !== null && $c === null) {
|
|
$c = $rc;
|
|
$bound = $rbound;
|
|
}
|
|
} elseif (self::_is_invalid($f)) {
|
|
return false;
|
|
} elseif (self::_is_nfunction($f)) {
|
|
return false;
|
|
} elseif (self::_parse_static($f)) {
|
|
return false;
|
|
} elseif (self::_parse_method($f)) {
|
|
}
|
|
$func[1] = $f;
|
|
} else {
|
|
return false;
|
|
}
|
|
if ($strict && $bound && !method_exists($c, $f)) return false;
|
|
return true;
|
|
}
|
|
|
|
/**
|
|
* vérifier que $func est une méthode non statique avec les règles de
|
|
* {@link self::verifix_method()}
|
|
*/
|
|
static function is_method($func, bool $strict=true, ?bool &$bound=null): bool {
|
|
return self::verifix_method($func, $strict, $bound);
|
|
}
|
|
|
|
static function verifix_cons(&$func, bool $strict=true): bool {
|
|
if (is_string($func)) {
|
|
|
|
} elseif (is_array($func)) {
|
|
|
|
} else {
|
|
return false;
|
|
}
|
|
return false;#XXX
|
|
}
|
|
|
|
static function with($func, bool $strict=true): self {
|
|
if ($func instanceof Closure) {
|
|
return new self($func);
|
|
} elseif (self::verifix_simple($func, $strict)) {
|
|
return new self($func);
|
|
} elseif (self::verifix_cons($func, $strict)) {
|
|
return new self($func);
|
|
} else {
|
|
if (self::verifix_static($func, $strict, $bound)) {
|
|
} elseif (self::verifix_method($func, $strict, $bound)) {
|
|
} else {
|
|
throw ValueException::invalid_type($func, "callable");
|
|
}
|
|
if (!$bound) throw ValueException::invalid_value($func, null, "is not bound");
|
|
return new self($func);
|
|
}
|
|
}
|
|
|
|
static function call($func, ...$args) {
|
|
return self::with($func)->invoke($args);
|
|
}
|
|
|
|
static function with_object($func, object $object, bool $rebind=false, bool $strict=true): self {
|
|
if ($func instanceof Closure) {
|
|
return new self($func);
|
|
} elseif (self::verifix_simple($func, $strict)) {
|
|
return new self($func);
|
|
} elseif (self::verifix_cons($func, $strict)) {
|
|
return new self($func);
|
|
} else {
|
|
if (self::verifix_method($func, $strict, $bound)) {
|
|
} elseif (self::verifix_static($func, $strict, $bound)) {
|
|
} else {
|
|
throw ValueException::invalid_type($func, "callable");
|
|
}
|
|
if (!$bound || $rebind) $func[0] = $object;
|
|
return new self($func);
|
|
}
|
|
}
|
|
|
|
static function with_class($func, $class, bool $rebind=false, bool $strict=true): self {
|
|
if ($func instanceof Closure) {
|
|
return new self($func);
|
|
} elseif (self::verifix_simple($func, $strict)) {
|
|
return new self($func);
|
|
} elseif (self::verifix_cons($func, $strict)) {
|
|
return new self($func);
|
|
} else {
|
|
if (self::verifix_method($func, $strict, $bound)) {
|
|
} elseif (self::verifix_static($func, $strict, $bound)) {
|
|
} else {
|
|
throw ValueException::invalid_type($func, "callable");
|
|
}
|
|
if (!$bound || $rebind) {
|
|
if (is_object($class)) $class = get_class($class);
|
|
$func[0] = $class;
|
|
}
|
|
return new self($func);
|
|
}
|
|
}
|
|
|
|
#############################################################################
|
|
|
|
const TYPE_CLOSURE = 0, TYPE_SIMPLE = 1, TYPE_STATIC = 2, TYPE_METHOD = 3, TYPE_CLASS = 4;
|
|
|
|
function __construct($func) {
|
|
$object = null;
|
|
$prefixArgs = [];
|
|
if ($func instanceof Closure) {
|
|
$type = self::TYPE_CLOSURE;
|
|
$reflection = new ReflectionFunction($func);
|
|
$object = $func;
|
|
} elseif ($func instanceof ReflectionFunction) {
|
|
$type = self::TYPE_SIMPLE;
|
|
$reflection = $func;
|
|
} elseif ($func instanceof ReflectionMethod) {
|
|
$type = self::TYPE_STATIC;
|
|
$reflection = $func;
|
|
} elseif ($func instanceof ReflectionClass) {
|
|
$type = self::TYPE_CLASS;
|
|
$reflection = $func;
|
|
} elseif (is_array($func)) {
|
|
if (count($func) > 2) {
|
|
$prefixArgs = array_slice($func, 2);
|
|
$func = array_slice($func, 0, 2);
|
|
}
|
|
[$c, $f] = $func;
|
|
if ($c === false) {
|
|
# fonction simple
|
|
$type = self::TYPE_SIMPLE;
|
|
$reflection = new ReflectionFunction($f);
|
|
} elseif ($f === false) {
|
|
# classe
|
|
$type = self::TYPE_CLASS;
|
|
$reflection = new ReflectionClass($c);
|
|
} elseif ($c !== null) {
|
|
# methode
|
|
$reflection = new ReflectionMethod($func);
|
|
if (is_object($c)) {
|
|
$type = self::TYPE_METHOD;
|
|
$object = $c;
|
|
} else {
|
|
$type = self::TYPE_STATIC;
|
|
}
|
|
} else {
|
|
throw new StateException("invalid func");
|
|
}
|
|
} else {
|
|
throw new StateException("invalid func");
|
|
}
|
|
if ($reflection instanceof ReflectionClass) {
|
|
$constructor = $reflection->getConstructor();
|
|
if ($constructor === null) {
|
|
$variadic = false;
|
|
$minArgs = $maxArgs = 0;
|
|
} else {
|
|
$variadic = $constructor->isVariadic();
|
|
$minArgs = $constructor->getNumberOfRequiredParameters();
|
|
$maxArgs = $constructor->getNumberOfParameters();
|
|
}
|
|
} else {
|
|
$variadic = $reflection->isVariadic();
|
|
$minArgs = $reflection->getNumberOfRequiredParameters();
|
|
$maxArgs = $reflection->getNumberOfParameters();
|
|
}
|
|
|
|
$this->type = $type;
|
|
$this->reflection = $reflection;
|
|
$this->variadic = $variadic;
|
|
$this->minArgs = $minArgs;
|
|
$this->maxArgs = $maxArgs;
|
|
$this->object = $object;
|
|
$this->prefixArgs = $prefixArgs;
|
|
}
|
|
|
|
protected int $type;
|
|
|
|
/** @var ReflectionFunction|ReflectionMethod|ReflectionClass */
|
|
protected $reflection;
|
|
|
|
protected bool $variadic;
|
|
|
|
protected int $minArgs;
|
|
|
|
protected int $maxArgs;
|
|
|
|
protected ?object $object;
|
|
|
|
protected array $prefixArgs;
|
|
|
|
function invoke(?array $args=null) {
|
|
$args = array_merge($this->prefixArgs, $args ?? []);
|
|
if (!$this->variadic) $args = array_slice($args, 0, $this->maxArgs);
|
|
$minArgs = $this->minArgs;
|
|
while (count($args) < $minArgs) $args[] = null;
|
|
|
|
switch ($this->type) {
|
|
case self::TYPE_CLOSURE:
|
|
/** @var Closure $closure */
|
|
$closure = $this->object;
|
|
return $closure(...$args);
|
|
case self::TYPE_SIMPLE:
|
|
case self::TYPE_STATIC:
|
|
/** @var ReflectionFunction $function */
|
|
$function = $this->reflection;
|
|
return $function->invoke(...$args);
|
|
case self::TYPE_METHOD:
|
|
/** @var ReflectionMethod $method */
|
|
$method = $this->reflection;
|
|
return $method->invoke($this->object, ...$args);
|
|
case self::TYPE_CLASS:
|
|
/** @var ReflectionClass $class */
|
|
$class = $this->reflection;
|
|
return $class->newInstance(...$args);
|
|
}
|
|
}
|
|
}
|