PHP PropertyGenerator::setName方法代码示例

 /**
  * @param type $name
  * @param type $type
  * @param type $docString
  * @return PhpProperty
  */
 public function addProperty($name, $type, $docString)
 {
     $property = new PropertyGenerator();
     $docblock = new DocBlockGenerator();
     $property->setName($name);
     $property->setVisibility(PropertyGenerator::VISIBILITY_PROTECTED);
     $docblock->setShortDescription($docString);
     $docblock->setTag(new Tag(array('name' => 'var', 'description' => $type)));
     $property->setDocblock($docblock);
     $this->addPropertyFromGenerator($property);
     return $property;
 }

 public function generate()
 {
     $classGenerator = $this->getClassGenerator();
     $description = $this->getDescription();
     $classGenerator->setName($description->getName());
     $basePathProperty = new CodeGenerator\PropertyGenerator();
     $basePathProperty->setName('basePath');
     $basePathProperty->setDefaultValue($description->getBasePath());
     $classGenerator->addPropertyFromGenerator($basePathProperty);
     foreach ($description->getApis() as $api) {
         foreach ($api->getOperations() as $operation) {
             $function = $this->generateFunction($api, $operation);
             if ($function instanceof CodeGenerator\MethodGenerator) {
                 $classGenerator->addMethodFromGenerator($function);
             }
         }
     }
 }

 protected function generateProperty($type, $name)
 {
     $property = new CodeGenerator\PropertyGenerator();
     $property->setName(lcfirst($name));
     $property->setVisibility($property::VISIBILITY_PROTECTED);
     return $property;
 }

 /**
  * @return ClassGenerator[]
  */
 private function getTypesCode()
 {
     $generator = $this;
     return array_map(function (Structure\TypeStructure $type) use($generator) {
         $code = new ClassGenerator($type->getClassName());
         $code->setNamespaceName($generator->getFullNamespace($type->getClassName(), true));
         foreach ($type->getMembers() as $member) {
             $tag = new Tag();
             $tag->setName('var');
             if ($member->isPrimitive()) {
                 $tag->setDescription($member->getType());
             } else {
                 $tag->setDescription("\\" . $generator->getFullNamespace($member->getType()));
             }
             $docBlock = new DocBlockGenerator(null, null, [$tag]);
             $property = new PropertyGenerator();
             $property->setName($member->getName());
             $property->setDocBlock($docBlock);
             $code->addPropertyFromGenerator($property);
         }
         return $code;
     }, $this->service->getTypes()->getArrayCopy());
 }

 /**
  * @param $className
  */
 protected function addMessageTemplates($className)
 {
     // generate property
     $property = new PropertyGenerator();
     $property->setName('messageTemplates');
     $property->setDefaultValue(['invalid' . $className => 'Value "%value%" is not valid']);
     $property->setVisibility(PropertyGenerator::FLAG_PROTECTED);
     // check for api docs
     if ($this->config['flagAddDocBlocks']) {
         $property->setDocBlock(new DocBlockGenerator('Validation failure message template definitions', '', [new GenericTag('var', 'array')]));
     }
     // add property
     $this->addPropertyFromGenerator($property);
 }

 /**
  * @group ZF-7361
  */
 public function testHasProperty()
 {
     $property = new PropertyGenerator();
     $property->setName('propertyOne');
     $classGenerator = new ClassGenerator();
     $classGenerator->setProperty($property);
     $this->assertTrue($classGenerator->hasProperty('propertyOne'));
 }

 /**
  * Create a property instance
  * @param  string                      $name - property name
  * @return Generator\PropertyGenerator $property
  */
 private function createProperty($name)
 {
     $property = new Generator\PropertyGenerator();
     $property->setName($name);
     $property->setVisibility(Generator\AbstractMemberGenerator::FLAG_PUBLIC);
     return $property;
 }

 /**
  * {@inheritdoc}
  */
 public function createDTO(Type $type)
 {
     $class = $this->createClassFromType($type);
     $parentType = $type->getParent();
     // set the parent class
     if ($parentType) {
         $parentType = $parentType->getBase();
         if ($parentType->getSchema()->getTargetNamespace() !== SchemaReader::XSD_NS) {
             $class->setExtendedClass($parentType->getName());
         }
     }
     // check if the type is abstract
     $class->setAbstract($type->isAbstract());
     // create the constructor
     $constructor = new MethodGenerator('__construct');
     $constructorDoc = new DocBlockGenerator();
     $constructorBody = '';
     $constructor->setDocBlock($constructorDoc);
     $class->addMethodFromGenerator($constructor);
     /* @var \Goetas\XML\XSDReader\Schema\Type\ComplexType $type */
     foreach ($type->getElements() as $element) {
         /* @var \Goetas\XML\XSDReader\Schema\Element\Element $element */
         $docElementType = $this->namespaceInflector->inflectDocBlockQualifiedName($element->getType());
         $elementName = $element->getName();
         // create a param and a param tag used in constructor and setter docs
         $param = new ParameterGenerator($elementName, $this->namespaceInflector->inflectName($element->getType()));
         $paramTag = new ParamTag($elementName, $docElementType);
         // if the param type is not a PHP primitive type and its namespace is different that the class namespace
         if ($type->getSchema()->getTargetNamespace() === SchemaReader::XSD_NS and $class->getNamespaceName() !== $this->namespaceInflector->inflectNamespace($element->getType())) {
             $class->addUse($this->namespaceInflector->inflectQualifiedName($element->getType()));
         }
         // set the parameter nullability
         if ($element->isNil() or $this->config->isNullConstructorArguments()) {
             $param->setDefaultValue(new ValueGenerator(null, ValueGenerator::TYPE_NULL));
         }
         /*
          * PROPERTY CREATION
          */
         $docDescription = new Html2Text($type->getDoc());
         $doc = new DocBlockGenerator();
         $doc->setShortDescription($docDescription->getText());
         $doc->setTag(new GenericTag('var', $docElementType));
         $property = new PropertyGenerator();
         $property->setDocBlock($doc);
         $property->setName(filter_var($elementName, FILTER_CALLBACK, array('options' => array($this, 'sanitizeVariableName'))));
         $property->setVisibility($this->config->isAccessors() ? AbstractMemberGenerator::VISIBILITY_PROTECTED : AbstractMemberGenerator::VISIBILITY_PUBLIC);
         $class->addPropertyFromGenerator($property);
         /*
          * IMPORTS
          */
         if ($element->getType()->getSchema()->getTargetNamespace() !== SchemaReader::XSD_NS and $this->namespaceInflector->inflectNamespace($element->getType()) !== $class->getNamespaceName()) {
             $class->addUse($this->namespaceInflector->inflectQualifiedName($element->getType()));
         }
         /*
          * CONSTRUCTOR PARAM CREATION
          */
         $constructorDoc->setTag($paramTag);
         $constructorBody .= "\$this->{$elementName} = \${$elementName};" . AbstractGenerator::LINE_FEED;
         $constructor->setParameter($param);
         /*
          * ACCESSORS CREATION
          */
         if ($this->config->isAccessors()) {
             // create the setter
             $setterDoc = new DocBlockGenerator();
             $setterDoc->setTag($paramTag);
             $setter = new MethodGenerator('set' . ucfirst($elementName));
             $setter->setParameter($param);
             $setter->setDocBlock($setterDoc);
             $setter->setBody("\$this->{$elementName} = \${$elementName};");
             $class->addMethodFromGenerator($setter);
             // create the getter
             $getterDoc = new DocBlockGenerator();
             $getterDoc->setTag(new ReturnTag($docElementType));
             $getter = new MethodGenerator('get' . ucfirst($elementName));
             $getter->setDocBlock($getterDoc);
             $getter->setBody("return \$this->{$elementName};");
             $class->addMethodFromGenerator($getter);
         }
     }
     // finalize the constructor body
     $constructor->setBody($constructorBody);
     $this->serializeClass($class);
     // register the class in the classmap
     $this->classmap[$class->getName()] = $class->getNamespaceName() . '\\' . $class->getName();
     return $class->getName();
 }

 private function generateProxiesMapProp()
 {
     $map = new PropertyGenerator();
     $map->setName('proxiesMap');
     $map->setVisibility(PropertyGenerator::VISIBILITY_PROTECTED);
     $map->setDefaultValue($this->buildProxiesMap(), 'array');
     return $map;
 }