public function defaultValue() { if ($this->property->isDefault()) { $defaultProperties = $this->property->getDeclaringClass()->getDefaultProperties(); return $defaultProperties[$this->property->getName()]; } return null; }
/** * Returns declaring class or trait. * @return \ReflectionClass */ public static function getDeclaringClass(\ReflectionProperty $prop) { foreach ($prop->getDeclaringClass()->getTraits() as $trait) { if ($trait->hasProperty($prop->getName())) { return self::getDeclaringClass($trait->getProperty($prop->getName())); } } return $prop->getDeclaringClass(); }
/** * Exports the PHP code * * @return string */ public function exportCode() { $default_properties = $this->_property->getDeclaringClass()->getDefaultProperties(); $modifiers = \Reflection::getModifierNames($this->_property->getModifiers()); $default_value = null; if (array_key_exists($this->_property->getName(), $default_properties)) { $default_value = $default_properties[$this->_property->getName()]; if (!is_numeric($default_value)) { $default_value = "'{$default_value}'"; } } return sprintf('%s $%s%s;', join(' ', $modifiers), $this->_property->getName(), !is_null($default_value) ? " = {$default_value}" : ''); }
/** * Parse the docblock of the property to get the class of the var annotation. * * @param \ReflectionProperty $property * * @throws AnnotationException Non exists class. * * @return null|ObjectDefinition */ public function getPropertyClass(\ReflectionProperty $property) { $propertyComment = $property->getDocComment(); if (!preg_match('/@var\\s+([^\\s\\(\\*\\/]+)/', $propertyComment, $matches)) { return; } $className = end($matches); if (!is_string($className) || in_array($className, static::$ignoredTypes)) { return; } $classWithNamespace = $className; if ($this->namespaceExists($classWithNamespace) === false) { $classWithNamespace = $this->namespace . '\\' . $className; } if (!$this->classExists($classWithNamespace)) { $declaringClass = $property->getDeclaringClass(); throw new AnnotationException(sprintf('The @var annotation on %s::%s contains a non existent class "%s"', $declaringClass->name, $property->getName(), $className)); } $createNewObject = function ($propertyComment, $className, $classWithNamespace) { $classParameters = $this->propertyClassParameters($propertyComment, $className); if (is_array($classParameters)) { $values = []; foreach ($classParameters as $value) { $values[] = static::parseValue($value); } $object = new ObjectDefinition($classWithNamespace, $className); $object->setConstructorInjection($values); return $object; } return new $classWithNamespace(); }; return $createNewObject($propertyComment, $className, $classWithNamespace); }
private function getDeclaringClassName($propertyName) { $reflection = new ReflectionProperty(get_class($this), $propertyName); $declaringClass = $reflection->getDeclaringClass(); $className = $declaringClass->getName(); return $className; }
private function getTypeOfProperty(\ReflectionProperty $prop) { if (preg_match('/^[\\s\\/*]*@var\\s+(\\S+)/m', $prop->getDocComment(), $matches)) { return $this->getFullNameOfType($matches[1], $prop->getDeclaringClass()); } return; }
/** * @param \ReflectionProperty $property * @return int */ public static function getPropertyLine(\ReflectionProperty $property) { $class = $property->getDeclaringClass(); $context = 'file'; $contextBrackets = 0; foreach (token_get_all(file_get_contents($class->getFileName())) as $token) { if ($token === '{') { $contextBrackets += 1; } elseif ($token === '}') { $contextBrackets -= 1; } if (!is_array($token)) { continue; } if ($token[0] === T_CLASS) { $context = 'class'; $contextBrackets = 0; } elseif ($context === 'class' && $contextBrackets === 1 && $token[0] === T_VARIABLE) { if ($token[1] === '$' . $property->getName()) { return $token[2]; } } } return NULL; }
/** * Get declaring class reflection object * * @return ClassReflection */ public function getDeclaringClass() { $phpReflection = parent::getDeclaringClass(); $zendReflection = new ClassReflection($phpReflection->getName()); unset($phpReflection); return $zendReflection; }
/** * @param \ReflectionProperty $property * * @return \ReflectionMethod|null */ public function getSetter(\ReflectionProperty $property) { $setter = sprintf(static::SETTER_FORMAT, ucfirst($property->getName())); $class = $property->getDeclaringClass(); if ($class->hasMethod($setter)) { return $class->getMethod($setter); } }
public function getXmlNamespace() { $namespace = $this->_parseAnnotation($this->property->getDocComment(), 'xmlNamespace'); if (!$namespace && $this->configuration) { $value = $this->getValue(); if (is_object($this->getValue())) { $classMeta = new ClassMetadata($this->getValue(), $this->configuration); $namespace = $classMeta->getXmlNamespace(); } elseif (is_array($value) && count($value) > 0) { $classMeta = new ClassMetadata($this->getValue()[0], $this->configuration); $namespace = $classMeta->getXmlNamespace(); } else { $classNamespace = $this->property->getDeclaringClass()->getNamespaceName(); $namespace = $this->configuration->getXmlNamespace($classNamespace); } } return $namespace; }
/** * Returns the declaring class. * * @return ezcReflectionClass */ public function getDeclaringClass() { if ($this->reflectionSource instanceof ReflectionProperty) { return new ezcReflectionClass($this->reflectionSource->getDeclaringClass()); } else { $class = parent::getDeclaringClass(); return new ezcReflectionClass($class->getName()); } }
/** * {@inheritDoc} */ public function setValue(\ReflectionProperty $property, $object, $value) { $propertyName = $property->getName(); $declaringClass = $property->getDeclaringClass(); $setterName = sprintf('set%s', ucfirst($propertyName)); if (!$declaringClass->hasMethod($setterName)) { throw new \RuntimeException('No setter found for "' . $propertyName . '"'); } $declaringClass->getMethod($setterName)->invoke($object, $value); }
/** * @param object|NULL * @return AccessBase $this */ public function asInstance($object) { if (is_object($object)) { if ($this->reflection instanceof ReflectionClass) { $class = $this->reflection->getName(); } else { $class = $this->reflection->getDeclaringClass()->getName(); } if (!$object instanceof $class) { throw new Exception('Must be instance of accessible class.'); } } else { if ($object !== NULL) { throw new Exception('Instance must be object or NULL.'); } } $this->instance = $object; return $this; }
public static function match(\ReflectionProperty $property, $matches = array()) { $comment = static::get($property->getDeclaringClass()->getName(), $property->getName()); foreach ($matches as $match) { if (preg_match("|{$match}|", $comment)) { return true; } } return false; }
/** * @return self */ public static function from(\ReflectionProperty $from) { $prop = new static($from->getName()); $defaults = $from->getDeclaringClass()->getDefaultProperties(); $prop->value = isset($defaults[$prop->name]) ? $defaults[$prop->name] : NULL; $prop->static = $from->isStatic(); $prop->visibility = $from->isPrivate() ? 'private' : ($from->isProtected() ? 'protected' : 'public'); $prop->comment = $from->getDocComment() ? preg_replace('#^\\s*\\* ?#m', '', trim($from->getDocComment(), "/* \r\n\t")) : NULL; return $prop; }
/** * Get declaring class reflection object * * @return Zend_Reflection_Class */ public function getDeclaringClass($reflectionClass = 'Zend_Reflection_Class') { $phpReflection = parent::getDeclaringClass(); $zendReflection = new $reflectionClass($phpReflection->getName()); if (!$zendReflection instanceof Zend_Reflection_Class) { throw new Zend_Reflection_Exception('Invalid reflection class provided; must extend Zend_Reflection_Class'); } unset($phpReflection); return $zendReflection; }
public function getPropertyAnnotations(\ReflectionProperty $prop) { $annotations = $this->getAnnotations($prop->getDocComment(), "property: {$prop->getDeclaringClass()->name}::{$prop->name}"); $varAnnotations = $annotations['vars']; return array_reduce(array_keys($varAnnotations), function (array &$tmp, $i) use($prop, $varAnnotations) { $a = $varAnnotations[$i]; $a->name = $prop->name; return $tmp + [$i => $a]; }, []); }
/** * {@inheritdoc} */ public function getPropertyValue(\ReflectionProperty $property) { $name = $property->getName(); $class = $property->getDeclaringClass(); $values = $class->getDefaultProperties(); // caution: this will return NULL for a property that has no default value declared! if (isset($values[$name])) { return $values[$name]; } throw UnresolvedValueException::unresolvedProperty($property); }
protected static function getPropertyType(\ReflectionProperty $property) { $comment = $property->getDocComment(); preg_match('/\\@var\\s+((\\w+)(\\[\\])*)/', $comment, $types); $type = $types[1]; // Class type if (!self::isPhpType($type)) { $type = self::qualifiedClass($property->getDeclaringClass(), $type); } return $type; }
function __construct(ReflectionProperty $property) { $this->name = $property->getName(); $this->is_public = $property->isPublic(); $this->is_private = $property->isPrivate(); $this->is_protected = $property->isProtected(); $this->is_static = $property->isStatic(); $this->declaring_class = API_Doc_Class::instance($property->getDeclaringClass()); list($comment, $meta) = $this->_docComment($property->getDocComment()); $this->_processDescription($comment); $this->_processMeta($meta); }
public function getPropertyAnnotations(\ReflectionProperty $property) { if (isset($this->loadedAnnotations[$key = $property->getDeclaringClass()->getName() . '$' . $property->getName()])) { return $this->loadedAnnotations[$key]; } if (null !== ($annots = $this->cache->getPropertyAnnotationsFromCache($property))) { return $this->loadedAnnotations[$key] = $annots; } $annots = $this->delegate->getPropertyAnnotations($property); $this->cache->putPropertyAnnotationsInCache($property, $annots); return $this->loadedAnnotations[$key] = $annots; }
public static function fromReflection(\ReflectionProperty $ref) { $property = new static(); $property->setName($ref->name)->setStatic($ref->isStatic())->setVisibility($ref->isPublic() ? self::VISIBILITY_PUBLIC : ($ref->isProtected() ? self::VISIBILITY_PROTECTED : self::VISIBILITY_PRIVATE)); if ($docComment = $ref->getDocComment()) { $property->setDocblock(ReflectionUtils::getUnindentedDocComment($docComment)); } $defaultProperties = $ref->getDeclaringClass()->getDefaultProperties(); if (isset($defaultProperties[$ref->name])) { $property->setDefaultValue($defaultProperties[$ref->name]); } return $property; }
public static function fromReflection(\ReflectionProperty $ref) { $property = new static($ref->name); $property->setStatic($ref->isStatic())->setVisibility($ref->isPublic() ? self::VISIBILITY_PUBLIC : ($ref->isProtected() ? self::VISIBILITY_PROTECTED : self::VISIBILITY_PRIVATE)); $docblock = new Docblock($ref); $property->setDocblock($docblock); $property->setDescription($docblock->getShortDescription()); $defaultProperties = $ref->getDeclaringClass()->getDefaultProperties(); if (isset($defaultProperties[$ref->name])) { $property->setDefaultValue($defaultProperties[$ref->name]); } return $property; }
public function getPropertyAnnotations(\ReflectionProperty $property) { $class = $property->getDeclaringClass(); $cacheKey = $class->getName() . '$' . $property->getName(); if (isset($this->loadedAnnotations[$cacheKey])) { return $this->loadedAnnotations[$cacheKey]; } if (false === ($annots = $this->fetchFromCache($cacheKey, $class))) { $annots = $this->delegate->getPropertyAnnotations($property); $this->saveToCache($cacheKey, $annots); } return $this->loadedAnnotations[$cacheKey] = $annots; }
public function __construct(\ReflectionProperty $reflector) { $this->name = $reflector->name; $comment = $reflector->getDocComment(); $this->export = preg_match('/@Export\\s/', $comment) > 0; $this->isReadOnly = preg_match('/@ReadOnly\\s/', $comment) > 0; $this->isIdentifier = preg_match('/@Id\\s/', $comment) > 0; $this->isPublic = $reflector->isPublic(); $this->isStatic = $reflector->isStatic(); $defaultProperties = $reflector->getDeclaringClass()->getDefaultProperties(); if (isset($defaultProperties[$this->name])) { $this->defaultValue = $defaultProperties[$this->name]; } }
public function __construct($class, $property) { $property = new ReflectionProperty($class, $property); list($description, $tags) = self::parse($property->getDocComment()); $this->data['title'] = $description[0]; $this->data['description'] = trim(implode("\n", $description)); if ($modifiers = $property->getModifiers()) { $this->data['modifiers'] = implode(' ', Reflection::getModifierNames($modifiers)); } else { $this->data['modifiers'] = 'public'; } if (isset($tags['var'])) { if (preg_match('/^(\\S*)(?:\\s*(.+?))?$/', $tags['var'][0], $matches)) { $this->data['type'] = $matches[1]; if (isset($matches[2])) { $this->data['description'] = array($matches[2]); } } } $this->data['name'] = $property->name; $this->data['class_name'] = $property->class; $this->data['is_static'] = $property->isStatic(); $this->data['is_public'] = $property->isPublic(); $class_rf = $property->getDeclaringClass(); if ($property->class != $class) { $this->data['is_php_class'] = $class_rf->getStartLine() ? 0 : 1; } else { $this->data['is_php_class'] = false; } $have_value = false; if ($property->isStatic()) { $v = $class_rf->getStaticProperties(); if (isset($v[$property->name])) { $value = $v[$property->name]; $have_value = true; } } else { if (!$property->isPrivate()) { if (!$class_rf->isFinal() && !$class_rf->isAbstract()) { $value = self::getValue($class, $property->name); $have_value = true; } } } if ($have_value) { $this->data['value'] = self::dump($value); $this->data['value_serialized'] = serialize($value); } }
/** * Creates a mapping from `ReflectionProperty`. * * @param ReflectionProperty $prop The reflection property * * @return Mapping */ private function mappingFromProp(\ReflectionProperty $prop) { $comment = $prop->getDocComment(); preg_match('/@var\\s+(.*)[\\s|\\n]/', $comment, $matches); if (!isset($matches[1])) { return; } $annotation = $matches[1]; $type = $annotation; if (ctype_upper($type[0]) && !class_exists($type)) { $ns = $prop->getDeclaringClass()->getNamespaceName(); $type = $ns . '\\' . $type; } return $this->of($type)->optional(); }
function reflectProperty($class, $property) { $propInfo = new ReflectionProperty($class, $property); echo "**********************************\n"; echo "Reflecting on property {$class}::{$property}\n\n"; echo "isDefault():\n"; var_dump($propInfo->isDefault()); echo "getModifiers():\n"; var_dump($propInfo->getModifiers()); echo "getDeclaringClass():\n"; var_dump($propInfo->getDeclaringClass()); echo "getDocComment():\n"; var_dump($propInfo->getDocComment()); echo "\n**********************************\n"; }
/** * {@inheritDoc} */ public function getPropertyAnnotations(\ReflectionProperty $property, $record_doc = false) { $cn = $property->getDeclaringClass()->getName(); $id = $property->getName(); if (isset($this->cache[$cn]['property'][$id])) { return $this->cache[$cn]['property'][$id]; } $this->cache[$cn]['property'][$id] = array(); $annots = $this->parser->parse($property->getDocComment(), 'property ' . $cn . '::$' . $id, $record_doc); foreach ($annots as $annot) { $key = $annot[0]; $annot = $annot[1]; $this->cache[$cn]['property'][$id][$key][] = $annot; } return $this->cache[$cn]['property'][$id]; }
/** * @param \ReflectionProperty $property * @param string $type * @return string */ private function getFullTypeName(\ReflectionProperty $property, $type) { $namespace = $property->getDeclaringClass()->getNamespaceName(); if (!$namespace) { return $type; } $namespaceSeparatorPosition = strpos($type, '\\'); if ($namespaceSeparatorPosition === 0) { return substr($type, 1); } else { if ($namespaceSeparatorPosition !== false) { $type = explode('\\', $type, 2)[1]; } } return "{$namespace}\\{$type}"; }