PHP ClassLoader::defineType方法代码示例

 /**
  * Defines a type
  *
  * @param  string $declaration
  * @param  string[] $extends
  * @return lang.XPClass
  */
 protected function define($declaration, $extends = [Object::class])
 {
     if (!isset(self::$fixtures[$declaration])) {
         $definition = ['kind' => 'class', 'extends' => $extends, 'implements' => [], 'use' => [], 'imports' => [Identity::class => null]];
         self::$fixtures[$declaration] = ClassLoader::defineType(nameof($this) . sizeof(self::$fixtures), $definition, $declaration);
     }
     return self::$fixtures[$declaration];
 }

 /**
  * Defines an anonymous type
  *
  * @param  string $decl Type declaration
  * @param  int $modifiers
  * @return lang.XPClass
  */
 protected function type($decl = null, $modifiers = '')
 {
     if (!isset(self::$fixtures[$decl])) {
         $definition = ['modifiers' => $modifiers, 'kind' => 'class', 'extends' => [Object::class], 'implements' => [], 'use' => [CompareTo::class], 'imports' => [Value::class => null]];
         self::$fixtures[$decl] = ClassLoader::defineType(get_class($this) . sizeof(self::$fixtures), $definition, $decl);
     }
     return self::$fixtures[$decl];
 }

 public function anonymous_instance_from_abstract_base_class()
 {
     \lang\ClassLoader::defineType('net.xp_lang.tests.Command', ['kind' => 'abstract class', 'extends' => ['lang.Object'], 'implements' => ['lang.Runnable'], 'use' => []], []);
     $command = $this->run('return new net.xp_lang.tests.Command() {
   public void run() {
     throw new lang.MethodNotImplementedException("run");
   }
 };');
     $this->assertAnonymousInstanceOf('net.xp_lang.tests.Command', $command);
 }

function newinstance($spec, $args, $def = null)
{
    static $u = 0;
    if ('#' === $spec[0]) {
        $p = strrpos($spec, ' ');
        $annotations = substr($spec, 0, $p) . ' ';
        $spec = substr($spec, $p + 1);
    } else {
        $annotations = '';
    }
    // Create unique name
    $n = "·" . ++$u;
    if (0 === strncmp($spec, 'php.', 4)) {
        $spec = substr($spec, 4);
    } else {
        if (false === strpos($spec, '.')) {
            $spec = \lang\XPClass::nameOf($spec);
        }
    }
    // Handle generics, PHP types and all others.
    if (strstr($spec, '<')) {
        $class = \lang\Type::forName($spec);
        $type = $class->literal();
        $generic = xp::$meta[$class->getName()]['class'][DETAIL_GENERIC];
    } else {
        if (false === strpos($spec, '.')) {
            $type = $spec;
            $generic = null;
        } else {
            try {
                $type = xp::$loader->loadClass0($spec);
            } catch (\lang\ClassLoadingException $e) {
                xp::error($e->getMessage());
            }
            $generic = null;
        }
    }
    $name = strtr($type, '\\', '.') . $n;
    if (interface_exists($type)) {
        $decl = ['kind' => 'class', 'extends' => ['lang.Object'], 'implements' => ['\\' . $type], 'use' => []];
    } else {
        if (trait_exists($type)) {
            $decl = ['kind' => 'class', 'extends' => ['lang.Object'], 'implements' => [], 'use' => ['\\' . $type]];
        } else {
            $decl = ['kind' => 'class', 'extends' => ['\\' . $type], 'implements' => [], 'use' => []];
        }
    }
    $defined = \lang\ClassLoader::defineType($annotations . $name, $decl, $def);
    if (false === strpos($type, '\\')) {
        xp::$cn[$type . $n] = $spec . $n;
    }
    if ($generic) {
        \lang\XPClass::detailsForClass($name);
        xp::$meta[$name]['class'][DETAIL_GENERIC] = $generic;
    }
    if ($defined->hasConstructor()) {
        return $defined->getConstructor()->newInstance($args);
    } else {
        return $defined->newInstance();
    }
}

 /**
  * Creates a type from a given type body
  *
  * @param  string[] $interfaces
  * @param  string $body The string `<T>` is replaced by the unique type name
  * @return lang.XPClass
  */
 protected function declareType($interfaces, $body)
 {
     $declaration = ['kind' => 'class', 'extends' => ['\\lang\\Object'], 'implements' => $interfaces, 'use' => []];
     $unique = typeof($this)->getSimpleName() . '_' . $this->name;
     return ClassLoader::defineType($unique, $declaration, strtr($body, ['<T>' => $unique]));
 }

 public static function defineImplementation()
 {
     $implementation = static::implementation();
     self::$fixture = ClassLoader::defineType($implementation . 'Instance', ['kind' => 'class', 'extends' => [], 'implements' => [], 'use' => [$implementation]], '{ public $buffer; public function __construct($initial) { $this->buffer= (string)$initial; }}');
 }