C:/xampp/htdocs/moodle/lib/simpletestlib/reflection_php5.php

Go to the documentation of this file.

<?php
class SimpleReflection {
    var $_interface;

    function SimpleReflection($interface) {
        $this->_interface = $interface;
    }

    function classExists() {
        if (! class_exists($this->_interface)) {
            return false;
        }
        $reflection = new ReflectionClass($this->_interface);
        return ! $reflection->isInterface();
    }

    function classExistsSansAutoload() {
        return class_exists($this->_interface, false);
    }

    function classOrInterfaceExists() {
        return $this->_classOrInterfaceExistsWithAutoload($this->_interface, true);
    }

    function classOrInterfaceExistsSansAutoload() {
        return $this->_classOrInterfaceExistsWithAutoload($this->_interface, false);
    }

    function _classOrInterfaceExistsWithAutoload($interface, $autoload) {
        if (function_exists('interface_exists')) {
            if (interface_exists($this->_interface, $autoload)) {
                return true;
            }
        }
        return class_exists($this->_interface, $autoload);
    }

    function getMethods() {
        return array_unique(get_class_methods($this->_interface));
    }

    function getInterfaces() {
        $reflection = new ReflectionClass($this->_interface);
        if ($reflection->isInterface()) {
            return array($this->_interface);
        }
        return $this->_onlyParents($reflection->getInterfaces());
    }

    function getInterfaceMethods() {
        $methods = array();
        foreach ($this->getInterfaces() as $interface) {
            $methods = array_merge($methods, get_class_methods($interface));
        }
        return array_unique($methods);
    }

    function _isInterfaceMethod($method) {
        return in_array($method, $this->getInterfaceMethods());
    }

    function getParent() {
        $reflection = new ReflectionClass($this->_interface);
        $parent = $reflection->getParentClass();
        if ($parent) {
            return $parent->getName();
        }
        return false;
    }

    function isAbstract() {
        $reflection = new ReflectionClass($this->_interface);
        return $reflection->isAbstract();
    }

    function isInterface() {
        $reflection = new ReflectionClass($this->_interface);
        return $reflection->isInterface();
    }

    function hasFinal() {
        $reflection = new ReflectionClass($this->_interface);
        foreach ($reflection->getMethods() as $method) {
            if ($method->isFinal()) {
                return true;
            }
        }
        return false;
    }

    function _onlyParents($interfaces) {
        $parents = array();
        $blacklist = array();
        foreach ($interfaces as $interface) {
            foreach($interfaces as $possible_parent) {
                if ($interface->getName() == $possible_parent->getName()) {
                    continue;
                }
                if ($interface->isSubClassOf($possible_parent)) {
                    $blacklist[$possible_parent->getName()] = true;
                }
            }
            if (!isset($blacklist[$interface->getName()])) {
                $parents[] = $interface->getName();
            }
        }
        return $parents;
    }

    function _isAbstractMethod($name) {
        $interface = new ReflectionClass($this->_interface);
        if (! $interface->hasMethod($name)) {
            return false;
        }
        return $interface->getMethod($name)->isAbstract();
    }

    function _isConstructor($name) {
        return ($name == '__construct') || ($name == $this->_interface);
    }

    function _isAbstractMethodInParents($name) {
        $interface = new ReflectionClass($this->_interface);
        $parent = $interface->getParentClass();
        while($parent) {
            if (! $parent->hasMethod($name)) {
                return false;
            }
            if ($parent->getMethod($name)->isAbstract()) {
                return true;
            }
            $parent = $parent->getParentClass();
        }
        return false;
    }

    function _isStaticMethod($name) {
        $interface = new ReflectionClass($this->_interface);
        if (! $interface->hasMethod($name)) {
            return false;
        }
        return $interface->getMethod($name)->isStatic();
    }

    function getSignature($name) {
        if ($name == '__set') {
            return 'function __set($key, $value)';
        }
        if ($name == '__call') {
            return 'function __call($method, $arguments)';
        }
        if (version_compare(phpversion(), '5.1.0', '>=')) {
            if (in_array($name, array('__get', '__isset', $name == '__unset'))) {
                return "function {$name}(\$key)";
            }
        }
        if ($name == '__toString') {
            return "function $name()";
        }
        if ($this->_isInterfaceMethod($name) ||
                $this->_isAbstractMethod($name) ||
                $this->_isAbstractMethodInParents($name) ||
                $this->_isStaticMethod($name)) {
            return $this->_getFullSignature($name);
        }
        return "function $name()";
    }

    function _getFullSignature($name) {
        $interface = new ReflectionClass($this->_interface);
        $method = $interface->getMethod($name);
        $reference = $method->returnsReference() ? '&' : '';
        $static = $method->isStatic() ? 'static ' : '';
        return "{$static}function $reference$name(" .
                implode(', ', $this->_getParameterSignatures($method)) .
                ")";
    }

    function _getParameterSignatures($method) {
        $signatures = array();
        foreach ($method->getParameters() as $parameter) {
            $signature = '';
            $type = $parameter->getClass();
            if (is_null($type) && version_compare(phpversion(), '5.1.0', '>=') && $parameter->isArray()) {
                $signature .= 'array ';
            } elseif (!is_null($type)) {
                $signature .= $type->getName() . ' ';
            }
            if ($parameter->isPassedByReference()) {
                $signature .= '&';
            }
            $signature .= '$' . $this->_suppressSpurious($parameter->getName());
            if ($this->_isOptional($parameter)) {
                $signature .= ' = null';
            }
            $signatures[] = $signature;
        }
        return $signatures;
    }

    function _suppressSpurious($name) {
        return str_replace(array('[', ']', ' '), '', $name);
    }

    function _isOptional($parameter) {
        if (method_exists($parameter, 'isOptional')) {
            return $parameter->isOptional();
        }
        return false;
    }
}
?>