PHP ClassType::addProperty方法代码示例

 protected function execute(InputInterface $input, OutputInterface $output)
 {
     $config = $this->getApplication()->getConfig();
     $dialog = $this->getHelper('dialog');
     $className = $input->getArgument('className');
     $modelName = $input->getArgument('modelName');
     $endPoint = $input->getArgument('endPoint');
     $model = $this->getModel($modelName);
     $buildDirectory = $config['build']['classes'];
     $buildPath = $buildDirectory . '/' . $className . '.php';
     if (file_exists($buildPath)) {
         if (!$dialog->askConfirmation($output, sprintf('<question>Class file "%s" exists, overwrite?</question>', $buildPath), false)) {
             return;
         }
     }
     $modelConfig = ['properties' => $model->properties];
     $configsDirectory = $config['build']['configs'];
     $configPath = realpath($configsDirectory . '/' . $modelName . '.json');
     if (file_exists($configPath)) {
         $modelConfig = json_decode(file_get_contents($configPath), true);
     }
     $namespace = new PhpNamespace($config['namespace']);
     $namespace->addUse($config['extends']);
     $class = new ClassType($className, $namespace);
     $class->addExtend($config['extends']);
     if (!empty($endPoint)) {
         $class->addConst("ENDPOINT", $endPoint);
     }
     foreach ($model->properties as $propertyName => $propertyDef) {
         if (in_array($propertyName, $modelConfig['properties'], true)) {
             $property = $class->addProperty($propertyName)->setVisibility('public');
             $accessorMethod = $class->addMethod($this->toCamelCase("get_" . $propertyName));
             $accessorMethod->setBody('return $this->' . $propertyName . ';');
             $mutatorMethod = $class->addMethod($this->toCamelCase("set_" . $propertyName));
             $mutatorMethod->addParameter($propertyName);
             $mutatorMethod->setBody('$this->' . $propertyName . ' = $' . $propertyName . ';');
             if (is_string($propertyDef['type'])) {
                 $property->addDocument("@var {$propertyDef['type']}");
             } else {
                 $property->addDocument("@var mixed");
             }
         } else {
             $output->writeln(sprintf("<info>Skipped property %s</info>", $propertyName));
         }
     }
     file_put_contents($buildPath, str_replace("\t", "    ", "<?php\n{$namespace}{$class}"));
     // TODO: replace with PHP_CodeSniffer library
     exec(sprintf('vendor/bin/phpcbf --standard=PSR2 --encoding=utf-8 "%s"', $buildPath));
     $output->writeln(sprintf("<info>Class %s created</info>", $buildPath));
 }

//.........这里部分代码省略.........
                             $this->info('Aggiungo parametro al costruttore', ['class' => $this->currentClass->getName(), 'parameter' => $name, 'className' => $fieldClassFull, 'default' => $defaultValue, 'autoinizialize' => $isAutoinizialize]);
                             //PHP7 ONLY
                             // if ($fieldClassFull == 'int') {
                             //     $parameter->setTypeHint('int');
                             // }
                             if (!$first) {
                                 $parameter = $methodConstructor->addParameter($name, null);
                             } else {
                                 $parameter = $methodConstructor->addParameter($name);
                             }
                             if ($fieldClassFull == 'array') {
                                 $parameter->setTypeHint('array');
                             } else {
                                 if ($defaultValue != null) {
                                     /* @var $parameter \Nette\PhpGenerator\Parameter */
                                     $parameter->setDefaultValue('' . $defaultValue);
                                 }
                             }
                         }
                     }
                 }
             }
             $this->info('Check autoinizialize field', ['class' => $this->currentClass->getName(), 'field' => $name, 'autoinizialize' => $isAutoinizialize, 'default' => $defaultValue]);
             $comment = 'no description available';
             if (array_key_exists('description', $fieldProperties)) {
                 $comment = $fieldProperties['description'];
             } else {
                 if (!is_null($typesDescription) && array_key_exists($fieldClassName, $typesDescription)) {
                     $comment = $typesDescription[$fieldClassName];
                 }
             }
             if (!$config->isInterface) {
                 /** $field @var \Nette\PhpGenerator\Property */
                 $field = $this->currentClass->addProperty($name);
                 $field->setStatic($isStatic);
                 if ($config->isEnum) {
                     $field->setVisibility('protected');
                 } else {
                     $field->setVisibility('private');
                 }
                 $field->addComment($comment)->addComment('@var ' . $fieldClassFull);
             }
             $createSetter = $config->haveSetter;
             if (array_key_exists('setter', $fieldProperties)) {
                 $createSetter = $fieldProperties['setter'];
             }
             $createGetter = $config->haveGetter;
             if (array_key_exists('getter', $fieldProperties)) {
                 $createGetter = $fieldProperties['getter'];
             }
             if ($config->isInterface) {
                 if ($createGetter) {
                     $this->addGetter($name, $fieldClassFull, $isStatic, false);
                 }
                 if ($createSetter) {
                     $this->addSetter($name, $fieldClassFull, $isStatic, false);
                 }
             } else {
                 if ($createGetter) {
                     $this->addGetter($name, $fieldClassFull, $isStatic, true);
                 }
                 if ($createSetter) {
                     $this->addSetter($name, $fieldClassFull, $isStatic, true);
                 }
             }
             if (!$isAutoinizialize) {

 public function onGenerate(AbstractMetaSpec $spec, MetaSpecMatcher $matcher, Type $type, ClassType $class)
 {
     $ns = $class->getNamespace();
     $ns->addUse("Skrz\\Meta\\XML\\XmlMetaInterface");
     $ns->addUse($type->getName(), null, $typeAlias);
     $class->addImplement("Skrz\\Meta\\XML\\XmlMetaInterface");
     $groups = array();
     $i = 0;
     $valueGroupIdMask = 0;
     foreach ($type->getProperties() as $property) {
         foreach ($property->getAnnotations("Skrz\\Meta\\XML\\XmlAnnotationInterface") as $xmlAnnotation) {
             /** @var XmlAnnotationInterface $xmlAnnotation */
             if (!isset($groups[$xmlAnnotation->getGroup()])) {
                 $groups[$xmlAnnotation->getGroup()] = 1 << $i++;
             }
             if ($xmlAnnotation instanceof XmlValue) {
                 $valueGroupIdMask |= $groups[$xmlAnnotation->getGroup()];
             }
         }
     }
     $class->addProperty("xmlGroups", $groups)->setStatic(true);
     // fromXml()
     $fromXml = $class->addMethod("fromXml");
     $fromXml->setStatic(true);
     $fromXml->addParameter("xml");
     $fromXml->addParameter("group")->setOptional(true);
     $fromXml->addParameter("object")->setOptional(true);
     $fromXml->addComment("Creates \\{$type->getName()} from XML")->addComment("")->addComment("@param \\XMLReader|\\DOMElement \$xml")->addComment("@param string \$group")->addComment("@param {$typeAlias} \$object")->addComment("")->addComment("@throws \\InvalidArgumentException")->addComment("")->addComment("@return {$typeAlias}");
     $fromXml->addBody("if (!isset(self::\$xmlGroups[\$group])) {")->addBody("\tthrow new \\InvalidArgumentException('Group \\'' . \$group . '\\' not supported for ' . " . var_export($type->getName(), true) . " . '.');")->addBody("} else {")->addBody("\t\$id = self::\$xmlGroups[\$group];")->addBody("}")->addBody("")->addBody("if (\$object === null) {")->addBody("\t\$object = new {$typeAlias}();")->addBody("} elseif (!(\$object instanceof {$typeAlias})) {")->addBody("\tthrow new \\InvalidArgumentException('You have to pass object of class {$type->getName()}.');")->addBody("}")->addBody("")->addBody("if (\$xml instanceof \\XMLReader) {")->addBody("\treturn self::fromXmlReader(\$xml, \$group, \$id, \$object);")->addBody("} elseif (\$xml instanceof \\DOMElement) {")->addBody("\treturn self::fromXmlElement(\$xml, \$group, \$id, \$object);")->addBody("} else {")->addBody("\tthrow new \\InvalidArgumentException('Expected XMLReader or DOMElement, got ' . gettype(\$xml) . (is_object(\$xml) ? ' of class ' . get_class(\$xml) : '') . '.');")->addBody("}");
     $fromXmlReader = $class->addMethod("fromXmlReader");
     $fromXmlReader->setStatic(true)->setVisibility("private");
     $fromXmlReader->addParameter("xml")->setTypeHint("\\XMLReader");
     $fromXmlReader->addParameter("group");
     $fromXmlReader->addParameter("id");
     $fromXmlReader->addParameter("object")->setTypeHint($type->getName());
     $fromXmlReader->addBody("if (\$xml->nodeType !== \\XMLReader::ELEMENT) {")->addBody("\tthrow new \\InvalidArgumentException('Expects XMLReader to be positioned on ELEMENT node.');")->addBody("}")->addBody("");
     $attributesByName = array();
     foreach ($type->getProperties() as $property) {
         foreach ($property->getAnnotations("Skrz\\Meta\\XML\\XmlAttribute") as $xmlAttribute) {
             /** @var XmlAttribute $xmlAttribute */
             $groupId = $groups[$xmlAttribute->group];
             $name = strtolower($xmlAttribute->name);
             if (!isset($attributesByName[$name])) {
                 $attributesByName[$name] = "";
             }
             $attributesByName[$name] .= "if ((\$id & {$groupId}) > 0 && \$xml->namespaceURI === " . var_export($xmlAttribute->namespace, true) . ") {\n";
             $attributesByName[$name] .= Strings::indent($this->assignObjectProperty($xmlAttribute, $property, "\$xml->value"), 1, "\t") . "\n";
             $attributesByName[$name] .= "}\n";
         }
     }
     if (!empty($attributesByName)) {
         $fromXmlReader->addBody("if (\$xml->moveToFirstAttribute()) {")->addBody("\tdo {")->addBody("\t\tswitch (strtolower(\$xml->localName)) {");
         $i = 0;
         foreach ($attributesByName as $name => $code) {
             $fromXmlReader->addBody("\t\t\tcase " . var_export($name, true) . ":")->addBody(Strings::indent($code, 4, "\t"))->addBody("\t\t\t\tbreak;");
             if ($i < count($attributesByName) - 1) {
                 $fromXmlReader->addBody("");
             }
             ++$i;
         }
         $fromXmlReader->addBody("\t\t}")->addBody("\t} while (\$xml->moveToNextAttribute());")->addBody("")->addBody("\t\$xml->moveToElement();")->addBody("}")->addBody("");
     }
     $fromXmlReader->addBody("if ((\$id & {$valueGroupIdMask}) > 0) {");
     $valueCount = 0;
     foreach ($type->getProperties() as $property) {
         foreach ($property->getAnnotations("Skrz\\Meta\\XML\\XmlValue") as $xmlValue) {
             /** @var XmlValue $xmlValue */
             $groupId = $groups[$xmlValue->group];
             $fromXmlReader->addBody("\tif ((\$id & {$groupId}) > 0) {")->addBody("\t\t\$value = self::xmlReadValue(\$xml);")->addBody(Strings::indent($this->assignObjectProperty($xmlValue, $property, "\$value"), 2, "\t"))->addBody("\t}")->addBody("");
             ++$valueCount;
         }
     }
     if (!$valueCount) {
         $fromXmlReader->addBody("\t// @XmlValue not specified");
     }
     $fromXmlReader->addBody("} else {");
     $elementsByName = array();
     $endElementsByName = array();
     $wrappers = [];
     foreach ($type->getProperties() as $property) {
         foreach ($property->getAnnotations("Skrz\\Meta\\XML\\XmlElementWrapper") as $xmlElementWrapper) {
             /** @var XmlElementWrapper $xmlElementWrapper */
             $groupId = $groups[$xmlElementWrapper->group];
             $name = strtolower($xmlElementWrapper->name);
             $wrapperId = $xmlElementWrapper->group . ":" . $property->getName();
             if (!isset($wrappers[$wrapperId])) {
                 $wrappers[$wrapperId] = 1 << count($wrappers);
             }
             if (!isset($elementsByName[$name])) {
                 $elementsByName[$name] = "";
             }
             $elementsByName[$name] .= "if ((\$id & {$groupId}) > 0 && \$xml->namespaceURI === " . var_export($xmlElementWrapper->namespace, true) . " && \$depth === 2) {\n";
             $elementsByName[$name] .= "\t\$wrapped |= {$wrappers[$wrapperId]};\n";
             $elementsByName[$name] .= "}\n";
             if (!isset($endElementsByName[$name])) {
                 $endElementsByName[$name] = "";
             }
             $endElementsByName[$name] .= "if ((\$id & {$groupId}) > 0 && \$xml->namespaceURI === " . var_export($xmlElementWrapper->namespace, true) . " && \$depth === 2) {\n";
             $endElementsByName[$name] .= "\t\$wrapped &= ~{$wrappers[$wrapperId]};\n";
             $endElementsByName[$name] .= "}\n";
//.........这里部分代码省略.........

 public function onGenerate(AbstractMetaSpec $spec, MetaSpecMatcher $matcher, Type $type, ClassType $class)
 {
     $namespace = $class->getNamespace();
     // extend base class
     $namespace->addUse($type->getName(), null, $typeAlias);
     $class->addExtend($type->getName());
     $class->addComment("Meta class for \\{$type->getName()}")->addComment("")->addComment("!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!")->addComment("!!!                                                     !!!")->addComment("!!!   THIS CLASS HAS BEEN AUTO-GENERATED, DO NOT EDIT   !!!")->addComment("!!!                                                     !!!")->addComment("!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!");
     // constructor
     $constructor = $class->addMethod("__construct");
     $constructor->addComment("Constructor")->addBody("self::\$instance = \$this; // avoids cyclic dependency stack overflow");
     if ($type->getConstructor()) {
         if ($type->getConstructor()->isPublic()) {
             $constructor->setVisibility("public");
         } elseif ($type->getConstructor()->isProtected()) {
             $constructor->setVisibility("protected");
         } elseif ($type->getConstructor()->isPrivate()) {
             $constructor->setVisibility("private");
         }
     } else {
         $constructor->setVisibility("private");
     }
     // implement base interface
     $namespace->addUse("Skrz\\Meta\\MetaInterface", null, $metaInterfaceAlias);
     $class->addImplement("Skrz\\Meta\\MetaInterface");
     // getInstance() method
     $instance = $class->addProperty("instance");
     $instance->setStatic(true);
     $instance->setVisibility("private");
     $instance->addComment("@var {$class->getName()}");
     $getInstance = $class->addMethod("getInstance");
     $getInstance->setStatic(true);
     $getInstance->addComment("Returns instance of this meta class")->addComment("")->addComment("@return {$class->getName()}");
     $getInstance->addBody("if (self::\$instance === null) {")->addBody("\tnew self(); // self::\$instance assigned in __construct")->addBody("}")->addBody("return self::\$instance;");
     // create() method
     $create = $class->addMethod("create");
     $create->setStatic(true);
     $create->addComment("Creates new instance of \\{$type->getName()}")->addComment("")->addComment("@throws \\InvalidArgumentException")->addComment("")->addComment("@return {$typeAlias}");
     $create->addBody("switch (func_num_args()) {");
     $maxArguments = 8;
     $constructMethod = $type->getConstructor();
     for ($i = 0; $i <= $maxArguments; ++$i) {
         $create->addBody("\tcase {$i}:");
         if ($constructMethod && $i < $constructMethod->getNumberOfRequiredParameters()) {
             $create->addBody("\t\tthrow new \\InvalidArgumentException('At least {$constructMethod->getNumberOfRequiredParameters()} arguments have to be supplied.');");
         } else {
             $args = array();
             for ($j = 0; $j < $i; ++$j) {
                 $args[] = "func_get_arg({$j})";
             }
             $create->addBody("\t\treturn new {$typeAlias}(" . implode(", ", $args) . ");");
         }
     }
     $create->addBody("\tdefault:");
     $create->addBody("\t\tthrow new \\InvalidArgumentException('More than {$maxArguments} arguments supplied, please be reasonable.');");
     $create->addBody("}");
     // reset() method
     $reset = $class->addMethod("reset");
     $reset->setStatic(true);
     $reset->addComment("Resets properties of \\{$type->getName()} to default values\n")->addComment("")->addComment("@param {$typeAlias} \$object")->addComment("")->addComment("@throws \\InvalidArgumentException")->addComment("")->addComment("@return void");
     $reset->addParameter("object");
     $reset->addBody("if (!(\$object instanceof {$typeAlias})) {")->addBody("\tthrow new \\InvalidArgumentException('You have to pass object of class {$type->getName()}.');")->addBody("}");
     foreach ($type->getProperties() as $property) {
         if ($property->hasAnnotation("Skrz\\Meta\\Transient")) {
             continue;
         }
         if ($property->isPrivate()) {
             throw new MetaException("Private property '{$type->getName()}::\${$property->getName()}'. " . "Either make the property protected/public if you need to process it, " . "or mark it using @Transient annotation.");
         }
         $reset->addBody("\$object->{$property->getName()} = " . var_export($property->getDefaultValue(), true) . ";");
     }
     // hash() method
     $hash = $class->addMethod("hash");
     $hash->setStatic(true);
     $hash->addComment("Computes hash of \\{$type->getName()}")->addComment("")->addComment("@param object \$object")->addComment("@param string|resource \$algoOrCtx")->addComment("@param bool \$raw")->addComment("")->addComment("@return string|void");
     $hash->addParameter("object");
     $hash->addParameter("algoOrCtx")->setDefaultValue("md5")->setOptional(true);
     $hash->addParameter("raw")->setDefaultValue(false)->setOptional(true);
     $hash->addBody("if (is_string(\$algoOrCtx)) {")->addBody("\t\$ctx = hash_init(\$algoOrCtx);")->addBody("} else {")->addBody("\t\$ctx = \$algoOrCtx;")->addBody("}")->addBody("");
     foreach ($type->getProperties() as $property) {
         if ($property->hasAnnotation("Skrz\\Meta\\Transient")) {
             continue;
         }
         if ($property->hasAnnotation("Skrz\\Meta\\Hash")) {
             continue;
         }
         $objectPath = "\$object->{$property->getName()}";
         $hash->addBody("if (isset({$objectPath})) {");
         $hash->addBody("\thash_update(\$ctx, " . var_export($property->getName(), true) . ");");
         $baseType = $property->getType();
         $indent = "\t";
         $before = "";
         $after = "";
         for ($i = 0; $baseType instanceof ArrayType; ++$i) {
             $arrayType = $baseType;
             $baseType = $arrayType->getBaseType();
             $before .= "{$indent}foreach ({$objectPath} instanceof \\Traversable ? {$objectPath} : (array){$objectPath} as \$v{$i}) {\n";
             $after = "{$indent}}\n" . $after;
             $indent .= "\t";
             $objectPath = "\$v{$i}";
         }
//.........这里部分代码省略.........

 /**
  * Generates body of service method.
  * @return string
  */
 private function generateService($name)
 {
     $def = $this->builder->getDefinition($name);
     if ($def->isDynamic()) {
         return PhpHelpers::formatArgs('throw new Nette\\DI\\ServiceCreationException(?);', ["Unable to create dynamic service '{$name}', it must be added using addService()"]);
     }
     $entity = $def->getFactory()->getEntity();
     $serviceRef = $this->builder->getServiceName($entity);
     $factory = $serviceRef && !$def->getFactory()->arguments && !$def->getSetup() && $def->getImplementMode() !== $def::IMPLEMENT_MODE_CREATE ? new Statement(['@' . ContainerBuilder::THIS_CONTAINER, 'getService'], [$serviceRef]) : $def->getFactory();
     $this->currentService = NULL;
     $code = '$service = ' . $this->formatStatement($factory) . ";\n";
     if (($class = $def->getClass()) && !$serviceRef && $class !== $entity && !(is_string($entity) && preg_match('#^[\\w\\\\]+\\z#', $entity) && is_subclass_of($entity, $class))) {
         $code .= PhpHelpers::formatArgs("if (!\$service instanceof {$class}) {\n" . "\tthrow new Nette\\UnexpectedValueException(?);\n}\n", ["Unable to create service '{$name}', value returned by factory is not {$class} type."]);
     }
     $this->currentService = $name;
     foreach ($def->getSetup() as $setup) {
         $code .= $this->formatStatement($setup) . ";\n";
     }
     $code .= 'return $service;';
     if (!$def->getImplement()) {
         return $code;
     }
     $factoryClass = new Nette\PhpGenerator\ClassType();
     $factoryClass->setName('($this)')->addImplement($def->getImplement());
     $factoryClass->addProperty('container')->setVisibility('private');
     $factoryClass->addMethod('__construct')->addBody('$this->container = $container;')->addParameter('container')->setTypeHint($this->className);
     $factoryClass->addMethod($def->getImplementMode())->setParameters($this->convertParameters($def->parameters))->setBody(str_replace('$this', '$this->container', $code))->setReturnType(PHP_VERSION_ID >= 70000 ? $def->getClass() : NULL);
     if (PHP_VERSION_ID < 70000) {
         $this->generatedClasses[] = $factoryClass;
         $factoryClass->setName(str_replace(['\\', '.'], '_', "{$this->className}_{$def->getImplement()}Impl_{$name}"));
         return "return new {$factoryClass->getName()}(\$this);";
     }
     return 'return new ' . rtrim($factoryClass) . ';';
 }

 public function onGenerate(AbstractMetaSpec $spec, MetaSpecMatcher $matcher, Type $type, ClassType $class)
 {
     $groups = array();
     $inputOutputClasses = array($type->getName() => true);
     $i = 0;
     foreach ($this->defaultGroups as $defaultGroup) {
         $groups[$defaultGroup] = 1 << $i++;
     }
     $ns = $class->getNamespace();
     $ns->addUse("Skrz\\Meta\\PHP\\PhpMetaInterface");
     $ns->addUse($type->getName(), null, $typeAlias);
     $ns->addUse("Skrz\\Meta\\Stack", null, $stackAlias);
     $class->addImplement("Skrz\\Meta\\PHP\\PhpMetaInterface");
     // get groups
     foreach ($type->getProperties() as $property) {
         foreach ($property->getAnnotations("Skrz\\Meta\\PHP\\PhpArrayOffset") as $arrayOffset) {
             /** @var PhpArrayOffset $arrayOffset */
             if (!isset($groups[$arrayOffset->group])) {
                 $groups[$arrayOffset->group] = 1 << $i++;
             }
         }
     }
     // get discriminator
     $discriminatorOffsetMap = array();
     $discriminatorClassMap = array();
     $discriminatorMetaMap = array();
     foreach ($type->getAnnotations("Skrz\\Meta\\PHP\\PhpDiscriminatorOffset") as $discriminatorOffset) {
         /** @var PhpDiscriminatorOffset $discriminatorOffset */
         if (!isset($groups[$discriminatorOffset->group])) {
             $groups[$discriminatorOffset->group] = 1 << $i++;
         }
         $discriminatorOffsetMap[$groups[$discriminatorOffset->group]] = $discriminatorOffset->offset;
     }
     foreach ($type->getAnnotations("Skrz\\Meta\\PHP\\PhpDiscriminatorMap") as $discriminatorMap) {
         /** @var PhpDiscriminatorMap $discriminatorMap */
         if (!isset($groups[$discriminatorMap->group])) {
             $groups[$discriminatorMap->group] = 1 << $i++;
         }
         if (isset($discriminatorMetaMap[$groups[$discriminatorMap->group]])) {
             throw new MetaException("More @PhpDiscriminatorMap annotations with same group '{$discriminatorMap->group}'.");
         }
         $discriminatorClassMap[$groups[$discriminatorMap->group]] = array();
         $discriminatorMetaMap[$groups[$discriminatorMap->group]] = array();
         $currentClassMap =& $discriminatorClassMap[$groups[$discriminatorMap->group]];
         $currentMetaMap =& $discriminatorMetaMap[$groups[$discriminatorMap->group]];
         foreach ($discriminatorMap->map as $value => $className) {
             $currentClassMap[$value] = $className;
             $inputOutputClasses[$className] = true;
             $currentMetaMap[$value] = $spec->createMetaClassName(Type::fromString($className));
         }
     }
     // add groups property
     $groupsProperty = $class->addProperty("groups");
     $groupsProperty->setStatic(true)->setValue($groups)->setVisibility("private");
     $groupsProperty->addComment("Mapping from group name to group ID for fromArray() and toArray()")->addComment("")->addComment("@var string[]");
     // create input/output type hint
     $inputOutputTypeHint = array();
     $inputOutputClasses = array_keys($inputOutputClasses);
     sort($inputOutputClasses);
     foreach ($inputOutputClasses as $inputOutputClass) {
         $ns->addUse($inputOutputClass, null, $alias);
         $inputOutputTypeHint[] = $alias;
     }
     $inputOutputTypeHint = implode("|", $inputOutputTypeHint);
     foreach (array("Array", "Object") as $what) {
         // from*() method
         $from = $class->addMethod("from{$what}");
         $from->setStatic(true);
         $from->addParameter("input");
         $from->addParameter("group")->setOptional(true);
         $from->addParameter("object")->setOptional(true);
         $from->addComment("Creates \\{$type->getName()} object from " . strtolower($what))->addComment("")->addComment("@param " . strtolower($what) . " \$input")->addComment("@param string \$group")->addComment("@param {$inputOutputTypeHint} \$object")->addComment("")->addComment("@throws \\Exception")->addComment("")->addComment("@return {$inputOutputTypeHint}");
         if ($what === "Object") {
             $from->addBody("\$input = (array)\$input;\n");
         }
         // TODO: more groups - include/exclude
         $from->addBody("if (!isset(self::\$groups[\$group])) {")->addBody("\tthrow new \\InvalidArgumentException('Group \\'' . \$group . '\\' not supported for ' . " . var_export($type->getName(), true) . " . '.');")->addBody("} else {")->addBody("\t\$id = self::\$groups[\$group];")->addBody("}")->addBody("");
         if (!empty($discriminatorMetaMap)) {
             foreach ($discriminatorMetaMap as $groupId => $groupDiscriminatorMetaMap) {
                 if (isset($discriminatorOffsetMap[$groupId])) {
                     $groupDiscriminatorOffset = $discriminatorOffsetMap[$groupId];
                     foreach ($groupDiscriminatorMetaMap as $value => $metaClass) {
                         $ns->addUse($metaClass, null, $alias);
                         $from->addBody("if ((\$id & {$groupId}) > 0 && " . "isset(\$input[" . var_export($groupDiscriminatorOffset, true) . "]) && " . "\$input[" . var_export($groupDiscriminatorOffset, true) . "] === " . var_export($value, true) . ") {")->addBody("\treturn {$alias}::from{$what}(\$input, \$group, \$object);")->addBody("}")->addBody("");
                     }
                 } else {
                     foreach ($groupDiscriminatorMetaMap as $value => $metaClass) {
                         $ns->addUse($metaClass, null, $alias);
                         $from->addBody("if ((\$id & {$groupId}) > 0 && " . "isset(\$input[" . var_export($value, true) . "])) {")->addBody("\treturn {$alias}::from{$what}(\$input[" . var_export($value, true) . "], \$group, \$object);")->addBody("}")->addBody("");
                     }
                 }
             }
         }
         $from->addBody("if (\$object === null) {")->addBody("\t\$object = new {$typeAlias}();")->addBody("} elseif (!(\$object instanceof {$typeAlias})) {")->addBody("\tthrow new \\InvalidArgumentException('You have to pass object of class {$type->getName()}.');")->addBody("}")->addBody("");
         foreach ($type->getProperties() as $property) {
             foreach ($property->getAnnotations("Skrz\\Meta\\PHP\\PhpArrayOffset") as $arrayOffset) {
                 /** @var PhpArrayOffset $arrayOffset */
                 $groupId = $groups[$arrayOffset->group];
                 $arrayKey = var_export($arrayOffset->offset, true);
                 $baseArrayPath = $arrayPath = "\$input[{$arrayKey}]";
//.........这里部分代码省略.........