PHP ReflectionExtension类代码示例

 /**
  * @return array
  */
 protected function getTagsForExtension($name)
 {
     if (!extension_loaded($name)) {
         return array();
     }
     $tags = array();
     $module = new \ReflectionExtension($name);
     // Export constants.
     foreach ($module->getConstants() as $name => $value) {
         $tags[] = new Tag($name, 'constant', Tag::DEFINITION);
     }
     // Export functions.
     foreach ($module->getFunctions() as $function) {
         $tags[] = new Tag($function->getName(), 'function', TAG::DEFINITION);
     }
     // Export classes.
     foreach ($module->getClasses() as $class) {
         $tags[] = new Tag($class->getName(), 'class', TAG::DEFINITION);
         foreach ($class->getMethods() as $method) {
             $tags[] = new Tag(sprintf('%s::%s', $class->getName(), $method->getName()), 'function', TAG::DEFINITION);
         }
         foreach ($class->getProperties() as $property) {
             $tags[] = new Tag(sprintf('%s::%s', $class->getName(), $property->getName()), 'variable', TAG::DEFINITION);
         }
         foreach ($class->getConstants() as $constant => $value) {
             $tags[] = new Tag(sprintf('%s::%s', $class->getName(), $constant), 'constant', TAG::DEFINITION);
         }
     }
     return $tags;
 }

 public function prepare_storage()
 {
     // Generate tables
     midgard_storage::create_base_storage();
     // And update as necessary
     $re = new ReflectionExtension('midgard2');
     $classes = $re->getClasses();
     foreach ($classes as $refclass) {
         if ($refclass->isAbstract() || $refclass->isInterface()) {
             continue;
         }
         $type = $refclass->getName();
         if (!is_subclass_of($type, 'MidgardDBObject')) {
             continue;
         }
         if (midgard_storage::class_storage_exists($type)) {
             // FIXME: Skip updates until http://trac.midgard-project.org/ticket/1426 is fixed
             continue;
             if (!midgard_storage::update_class_storage($type)) {
                 $this->markTestSkipped('Could not update ' . $type . ' tables in test database');
             }
             continue;
         }
         if (!midgard_storage::create_class_storage($type)) {
             $this->markTestSkipped('Could not create ' . $type . ' tables in test database');
         }
     }
     // And update as necessary
     return;
     if (!midgard_user::auth('root', 'password')) {
         echo "auth failed\n";
         $this->markTestSkipped('Could not authenticate as ROOT');
     }
 }

 protected function initialize()
 {
     parent::initialize();
     $versionParser = new VersionParser();
     try {
         $prettyVersion = PHP_VERSION;
         $version = $versionParser->normalize($prettyVersion);
     } catch (\UnexpectedValueException $e) {
         $prettyVersion = preg_replace('#^(.+?)(-.+)?$#', '$1', PHP_VERSION);
         $version = $versionParser->normalize($prettyVersion);
     }
     $php = new MemoryPackage('php', $version, $prettyVersion);
     $php->setDescription('The PHP interpreter');
     parent::addPackage($php);
     foreach (get_loaded_extensions() as $name) {
         if (in_array($name, array('standard', 'Core'))) {
             continue;
         }
         $reflExt = new \ReflectionExtension($name);
         try {
             $prettyVersion = $reflExt->getVersion();
             $version = $versionParser->normalize($prettyVersion);
         } catch (\UnexpectedValueException $e) {
             $prettyVersion = '0';
             $version = $versionParser->normalize($prettyVersion);
         }
         $ext = new MemoryPackage('ext-' . $name, $version, $prettyVersion);
         $ext->setDescription('The ' . $name . ' PHP extension');
         parent::addPackage($ext);
     }
 }

 /**
  * 欢迎页面
  */
 public function welcomeOp()
 {
     /**
      * 管理员信息
      */
     $model_admin = Model('admin');
     $tmp = $this->getAdminInfo();
     $condition['admin_id'] = $tmp['id'];
     $admin_info = $model_admin->infoAdmin($condition);
     $admin_info['admin_login_time'] = date('Y-m-d H:i:s', $admin_info['admin_login_time'] == '' ? time() : $admin_info['admin_login_time']);
     /**
      * 系统信息
      */
     $version = C('version');
     $setup_date = C('setup_date');
     $statistics['os'] = PHP_OS;
     $statistics['web_server'] = $_SERVER['SERVER_SOFTWARE'];
     $statistics['php_version'] = PHP_VERSION;
     $statistics['sql_version'] = Db::getServerInfo();
     $statistics['shop_version'] = $version;
     $statistics['setup_date'] = substr($setup_date, 0, 10);
     // 运维舫 c extension
     try {
         $r = new ReflectionExtension('shopnc');
         $statistics['php_version'] .= ' / ' . $r->getVersion();
     } catch (ReflectionException $ex) {
     }
     Tpl::output('statistics', $statistics);
     Tpl::output('admin_info', $admin_info);
     Tpl::showpage('welcome');
 }

 public function testExtension()
 {
     if (!extension_loaded('hstore')) {
         return;
     }
     $r = new \ReflectionExtension('hstore');
     $this->assertContains('Intaro\\HStore\\Coder', $r->getClassNames());
 }

 public function __construct()
 {
     parent::__construct();
     foreach (get_loaded_extensions() as $ext) {
         $re = new \ReflectionExtension($ext);
         $extensions = $this->append(NULL, array($ext, $re));
         $this->addFunctions($extensions, $re->getFunctions());
         $this->addClasses($extensions, $re->getClasses());
     }
 }

 public static function tExtension($test, $ext)
 {
     try {
         $ref = new ReflectionExtension($ext);
         $v = $ref->getVersion();
         self::setTestData($test, '%s found%s', $ref->getName(), $v ? ' v' . $v : '');
         return true;
     } catch (ReflectionException $e) {
         self::setTestData($test, $e->getMessage());
     }
     return false;
 }

 /**
  * Constructor.
  */
 protected function __construct()
 {
     $this->memcached = new \Memcached();
     $this->memcached->addServer(Config::getCacheHost(), Config::getCachePort());
     $this->memcached->setOption(\Memcached::OPT_PREFIX_KEY, Config::getCachePrefix());
     //determine if deleteMulti() is supported
     if (defined('HHVM_VERSION')) {
         $this->hasMultiDelete = false;
     } else {
         $ext = new \ReflectionExtension('memcached');
         $this->hasMultiDelete = version_compare($ext->getVersion(), '2.0.0', '>=');
     }
 }

 /**
  * @param string[] $extensionNames
  * @return string[]
  * @throws UnknownExtensionException if the extension cannot be found
  */
 public function __invoke(array $extensionNames) : array
 {
     $definedSymbols = [];
     foreach ($extensionNames as $extensionName) {
         try {
             $extensionReflection = new \ReflectionExtension($extensionName);
             $definedSymbols = array_merge($definedSymbols, array_keys($extensionReflection->getConstants()), array_keys($extensionReflection->getFunctions()), $extensionReflection->getClassNames());
         } catch (\Exception $e) {
             throw new UnknownExtensionException($e->getMessage());
         }
     }
     return $definedSymbols;
 }

 function __construct(SymbolTable $symbolTable, \Guardrail\Output\OutputInterface $output)
 {
     parent::__construct($symbolTable, $output);
     foreach (get_loaded_extensions() as $extension) {
         try {
             $reflectedExtension = new \ReflectionExtension($extension);
             foreach ($reflectedExtension->getConstants() as $constant => $value) {
                 $this->reflectedConstants[$constant] = true;
             }
         } catch (\ReflectionException $e) {
         }
     }
 }

 protected function getIcuVersion()
 {
     if (defined('INTL_ICU_VERSION')) {
         $version = INTL_ICU_VERSION;
     } else {
         $reflector = new \ReflectionExtension('intl');
         ob_start();
         $reflector->info();
         $output = strip_tags(ob_get_clean());
         preg_match('/^ICU version +(?:=> )?(.*)$/m', $output, $matches);
         $version = $matches[1];
     }
     return $version;
 }

 private static function mustHaveExtension($ext)
 {
     if (!extension_loaded($ext)) {
         echo "ERROR: The PHP extension '{$ext}' is not installed. You must " . "install it to run aphlict on this machine.\n";
         exit(1);
     }
     $extension = new ReflectionExtension($ext);
     foreach ($extension->getFunctions() as $function) {
         $function = $function->name;
         if (!function_exists($function)) {
             echo "ERROR: The PHP function {$function}() is disabled. You must " . "enable it to run aphlict on this machine.\n";
             exit(1);
         }
     }
 }

 private static function mustHaveExtension($ext)
 {
     if (!extension_loaded($ext)) {
         echo pht("ERROR: The PHP extension '%s' is not installed. You must " . "install it to run Aphlict on this machine.", $ext) . "\n";
         exit(1);
     }
     $extension = new ReflectionExtension($ext);
     foreach ($extension->getFunctions() as $function) {
         $function = $function->name;
         if (!function_exists($function)) {
             echo pht('ERROR: The PHP function %s is disabled. You must ' . 'enable it to run Aphlict on this machine.', $function . '()') . "\n";
             exit(1);
         }
     }
 }

 /**
  * @return array
  */
 public function opcodeCacheData()
 {
     $cacheData = array();
     foreach (static::$opcacheExtenstions as $name => $data) {
         list($title, $iniSetting) = $data;
         if ($this->hasCache($name, $iniSetting)) {
             $cacheData['title'] = $title;
             $cacheData['name'] = $name;
             $ref = new \ReflectionExtension($name);
             $cacheData['version'] = $ref->getVersion();
             $cacheData['settings'] = $ref->getINIEntries();
             break;
         }
     }
     return $cacheData;
 }

 function expectArgumentError($message)
 {
     try {
         $extension = new \ReflectionExtension('functional');
         $extensionFunctions = array_keys($extension->getFunctions());
         $isDefinedInExtension = F\every($this->functions, function ($function) use($extensionFunctions) {
             return in_array($function, $extensionFunctions, true);
         });
         if ($isDefinedInExtension) {
             $this->setExpectedException('PHPUnit_Framework_Error_Warning', $message);
         } else {
             $this->setExpectedException('Functional\\Exceptions\\InvalidArgumentException', $message);
         }
     } catch (\ReflectionException $e) {
         $this->setExpectedException('Functional\\Exceptions\\InvalidArgumentException', $message);
     }
 }