/**
*
* @param \AgNetSolutions\Common\Metadata\PropertyAnnotation $annotation
* @param \ReflectionProperty $reflection
*/
public function __construct(PropertyAnnotation $annotation, \ReflectionProperty $reflection)
{
$this->reflection = $reflection;
$this->annotation = $annotation;
if ($this->reflection->isPrivate() || $this->reflection->isProtected()) {
$this->reflection->setAccessible(true);
}
}
function reflectProperty($class, $property)
{
$propInfo = new ReflectionProperty($class, $property);
echo "**********************************\n";
echo "Reflecting on property {$class}::{$property}\n\n";
echo "__toString():\n";
var_dump($propInfo->__toString());
echo "export():\n";
var_dump(ReflectionProperty::export($class, $property, true));
echo "export():\n";
var_dump(ReflectionProperty::export($class, $property, false));
echo "getName():\n";
var_dump($propInfo->getName());
echo "isPublic():\n";
var_dump($propInfo->isPublic());
echo "isPrivate():\n";
var_dump($propInfo->isPrivate());
echo "isProtected():\n";
var_dump($propInfo->isProtected());
echo "isStatic():\n";
var_dump($propInfo->isStatic());
$instance = new $class();
if ($propInfo->isPublic()) {
echo "getValue():\n";
var_dump($propInfo->getValue($instance));
$propInfo->setValue($instance, "NewValue");
echo "getValue() after a setValue():\n";
var_dump($propInfo->getValue($instance));
}
echo "\n**********************************\n";
}
private function parseAttribute($class, $attribute)
{
$attr = new ReflectionProperty($class, $attribute);
$annotations = array('validate' => $attr->isProtected(), 'mandatory' => true);
$comment = $attr->getDocComment();
if (!$comment) {
return $annotations;
}
if (!preg_match_all('/\\s*\\* @(\\w+) ([^\\n\\r]*)/', $comment, $matches)) {
return $annotations;
}
foreach ($matches[1] as $index => $match) {
$value = $matches[2][$index];
switch ($value) {
case 'false':
$value = false;
break;
case 'true':
$value = true;
break;
}
$annotations[$match] = $value;
}
return $annotations;
}
public function testCanSetScopeGlue()
{
$this->parser->scopeGlue('~');
$scopeGlue = new ReflectionProperty($this->parser, 'scopeGlue');
$this->assertTrue($scopeGlue->isProtected());
$scopeGlue->setAccessible(true);
$this->assertEquals('~', $scopeGlue->getValue($this->parser));
}
/**
* Returns true if this property has protected as access level.
*
* @return bool
*/
public function isProtected()
{
if ($this->reflectionSource instanceof ReflectionProperty) {
return $this->reflectionSource->isProtected();
} else {
return parent::isProtected();
}
}
public function __call($method, $args)
{
if (property_exists($this, $method) && is_callable($this->{$method})) {
$check = new \ReflectionProperty($this, $method);
if ($check->isProtected()) {
return call_user_func_array($this->{$method}, $args);
}
}
}
/**
* Get output style for the given property's visibility.
*
* @param \ReflectionProperty $property
*
* @return string
*/
private function getVisibilityStyle(\ReflectionProperty $property)
{
if ($property->isPublic()) {
return self::IS_PUBLIC;
} elseif ($property->isProtected()) {
return self::IS_PROTECTED;
} else {
return self::IS_PRIVATE;
}
}
/**
* @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;
}
public function testPublicize_with_protected_static_property()
{
$className = __FUNCTION__ . md5(uniqid());
eval(sprintf('class %s { protected static $foo = "foo_value"; }', $className));
$reflectionProperty = new ReflectionProperty($className, 'foo');
$this->assertTrue($reflectionProperty->isStatic());
$this->assertTrue($reflectionProperty->isProtected());
$this->assertSame($reflectionProperty, $reflectionProperty->publicize());
$this->assertSame('foo_value', $reflectionProperty->getValue($className));
}
/**
* @param object $object
* @param string $property
* @param mixed $value
*/
protected function setPrivatePropertyValue($object, $property, $value)
{
$reflectionProperty = new \ReflectionProperty($object, $property);
if ($reflectionProperty->isPrivate() || $reflectionProperty->isProtected()) {
$reflectionProperty->setAccessible(true);
$reflectionProperty->setValue($object, $value);
$reflectionProperty->setAccessible(false);
} else {
$object->{$property} = $value;
}
}
/**
* Backwards compatibility method to get 'topic0attop' attribute value.
*
* @return boolean Value of topic0attop.
*/
private function get_topic0attop()
{
if (property_exists($this, 'topic0attop')) {
$reflectionproperty = new ReflectionProperty($this, 'topic0attop');
if ($reflectionproperty->isProtected()) {
return $this->topic0attop;
}
}
// Grid format fix #24 not implemented. Assume section 0 is at the top.
return 1;
}
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 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 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;
}
/**
* @param ReflectionProperty
* @return object get => callable(object|NULL $instance), set => callable(object|NULL $instance, mixed $value)
*/
public function accessProperty(ReflectionProperty $property)
{
if (PHP_VERSION_ID >= 50300 or $property->isPublic()) {
if (PHP_VERSION_ID >= 50300) {
$property->setAccessible(true);
}
return (object) array('get' => $this->callback('$instance', '
if ($instance)
{
return $property->getValue($instance);
}
return $property->getValue();
', array('property' => $property)), 'set' => $this->callback('$instance, $value', '
if ($instance)
{
$property->setValue($instance, $value);
}
else
{
$property->setValue($value);
}
', array('property' => $property)));
} else {
if ($property->isProtected()) {
return (object) array('get' => $this->callback('$instance', '
if ($instance AND $property->isStatic()) $instance = NULL;
return call_user_func(array($helperClassName, "__AccessAccessor_php52__get"), $instance, $propertyName);
', array('property' => $property, 'helperClassName' => $this->getHelperClass($property->getDeclaringClass()), 'propertyName' => $property->getName())), 'set' => $this->callback('$instance, $value', '
if ($instance AND $property->isStatic()) $instance = NULL;
return call_user_func(array($helperClassName, "__AccessAccessor_php52__set"), $instance, $propertyName, $value);
', array('property' => $property, 'helperClassName' => $this->getHelperClass($property->getDeclaringClass()), 'propertyName' => $property->getName())));
} else {
if ($property->isPrivate()) {
if ($property->isStatic()) {
throw new Exception('AccessProperty needs PHP 5.3.0 or newer to access static private property.');
}
return (object) array('get' => $this->callback('$instance', '
if ($instance)
{
$array = (array) $instance;
return $array["\\0{$className}\\0{$propertyName}"];
}
throw new Exception("AccessProperty needs PHP 5.3.0 or newer to access static private property.");
', array('helperClassName' => $this->getHelperClass($property->getDeclaringClass()), 'className' => $property->getDeclaringClass()->getName(), 'propertyName' => $property->getName())), 'set' => $this->callback('$instance, $value', '
throw new Exception("AccessProperty needs PHP 5.3.0 or newer to write to private property.");
'));
}
}
}
}
public static function getPropertyIdentifier(\ReflectionProperty $reflectionProperty, $className)
{
$key = null;
if ($reflectionProperty->isPrivate()) {
$key = '\\0' . $className . '\\0' . $reflectionProperty->getName();
} elseif ($reflectionProperty->isProtected()) {
$key = '' . "" . '*' . "" . $reflectionProperty->getName();
} elseif ($reflectionProperty->isPublic()) {
$key = $reflectionProperty->getName();
}
if (null === $key) {
throw new \InvalidArgumentException('Unable to detect property visibility');
}
return $key;
}
/**
* Constructor
*
* @param string $declaringAspectClassName Name of the aspect containing the declaration for this introduction
* @param string $propertyName Name of the property to introduce
* @param \TYPO3\Flow\Aop\Pointcut\Pointcut $pointcut The pointcut for this introduction
*/
public function __construct($declaringAspectClassName, $propertyName, \TYPO3\Flow\Aop\Pointcut\Pointcut $pointcut)
{
$this->declaringAspectClassName = $declaringAspectClassName;
$this->propertyName = $propertyName;
$this->pointcut = $pointcut;
$propertyReflection = new \ReflectionProperty($declaringAspectClassName, $propertyName);
if ($propertyReflection->isPrivate()) {
$this->propertyVisibility = 'private';
} elseif ($propertyReflection->isProtected()) {
$this->propertyVisibility = 'protected';
} else {
$this->propertyVisibility = 'public';
}
$this->propertyDocComment = preg_replace('/@(TYPO3\\\\Flow\\\\Annotations|Flow)\\\\Introduce.+$/mi', 'introduced by ' . $declaringAspectClassName, $propertyReflection->getDocComment());
}
/**
* Get public and protected properties of current class
*
* @return array
*/
protected function getReflectedProperties()
{
if (is_null($this->_ReflectedPropertiesCache)) {
$this->_ReflectedPropertiesCache = array();
$refectionClass = new ReflectionClass($this);
$propertiesArray = $refectionClass->getProperties();
if (is_array($propertiesArray) and count($propertiesArray) > 0) {
while (list(, $property) = each($propertiesArray)) {
$refectionProperty = new ReflectionProperty($property->class, $property->name);
if ($refectionProperty->isPublic() || $refectionProperty->isProtected()) {
$this->_ReflectedPropertiesCache[] = $property->name;
}
}
}
}
return $this->_ReflectedPropertiesCache;
}
private function emulate($action, $property, $value = null)
{
// requested property converted to method (test => getTest())
$method = $action . ucfirst($property);
if (method_exists($this, $method)) {
return $this->{$method}($value);
}
if (property_exists($this, $property)) {
$ref = new \ReflectionProperty($this, $property);
if ($ref->isProtected() || $ref->isPrivate()) {
return;
// prevent private and protected ivars from getting out.
}
}
// catchall method that gets and sets undeclared variables.
return $this->synthesize($action, $property, $value);
}
protected function getNonpublicProperty($object, $property_name)
{
if (version_compare(PHP_VERSION, '5.3.0') >= 0) {
$ref = new ReflectionProperty(get_class($object), $property_name);
$ref->setAccessible(true);
return $ref->getValue($object);
} else {
$arr = (array) $object;
$key = $property_name;
$ref = new ReflectionProperty(get_class($object), $property_name);
if ($ref->isProtected()) {
$key = "*" . $key;
} elseif ($ref->isPrivate()) {
$key = "" . get_class($object) . "" . $key;
}
return $arr[$key];
}
}
/**
* @param \ReflectionProperty $property
* @return Property
*/
public function property(\ReflectionProperty $property)
{
$phpyProperty = new Property($property->getName());
$phpyProperty->setStatic($property->isStatic());
$refClass = $property->getDeclaringClass();
$defClassValues = $refClass->getDefaultProperties();
if (isset($defClassValues[$property->getName()])) {
$phpyProperty->setDefaultValue($defClassValues[$property->getName()]);
}
if ($property->isPublic()) {
$phpyProperty->setVisibility('public');
} elseif ($property->isProtected()) {
$phpyProperty->setVisibility('protected');
} else {
$phpyProperty->setVisibility('private');
}
return $phpyProperty;
}
/**
* Constructor
*
* @param string $declaringAspectClassName Name of the aspect containing the declaration for this introduction
* @param string $propertyName Name of the property to introduce
* @param Pointcut $pointcut The pointcut for this introduction
*/
public function __construct($declaringAspectClassName, $propertyName, Pointcut $pointcut)
{
$this->declaringAspectClassName = $declaringAspectClassName;
$this->propertyName = $propertyName;
$this->pointcut = $pointcut;
$propertyReflection = new \ReflectionProperty($declaringAspectClassName, $propertyName);
$classReflection = new \ReflectionClass($declaringAspectClassName);
$defaultProperties = $classReflection->getDefaultProperties();
$this->initialValue = $defaultProperties[$propertyName];
if ($propertyReflection->isPrivate()) {
$this->propertyVisibility = 'private';
} elseif ($propertyReflection->isProtected()) {
$this->propertyVisibility = 'protected';
} else {
$this->propertyVisibility = 'public';
}
$this->propertyDocComment = preg_replace('/@(Neos\\\\Flow\\\\Annotations|Flow)\\\\Introduce.+$/mi', 'introduced by ' . $declaringAspectClassName, $propertyReflection->getDocComment());
}
protected function buildFieldSignature(\ReflectionProperty $prop) : string
{
if ($prop->isProtected()) {
$code = 'protected ';
} elseif ($prop->isPrivate()) {
$code = 'private ';
} else {
$code = 'public ';
}
if ($prop->isStatic()) {
$code .= 'static ';
}
$code .= '$' . $prop->name;
$defaults = $prop->getDeclaringClass()->getDefaultProperties();
if (array_key_exists($prop->name, $defaults)) {
$code .= ' = ' . $this->buildLiteralCode($defaults[$prop->name]);
}
return $code;
}
/**
* Magic Get metódus
*
* @param string $name
* @return mixed
*/
public function __get($name)
{
if ($name == 'id' && defined(get_class($this) . '::id_property')) {
return $this->{$this->id_property};
}
if ($name == 'code' && defined(get_class($this) . '::code_property')) {
return $this->{$this->code_property};
}
// Checking the property is exists?
if (property_exists($this, $name)) {
$property = new \ReflectionProperty($this, $name);
if ($property->isProtected() || $property->isPublic()) {
return $this->{$name};
} else {
throw new InvalidArgumentException(get_class($this) . " class '" . $name . "' property not accessable!");
}
} else {
throw new InvalidArgumentException(get_class($this) . " class does not have '" . $name . "' property!");
}
}
/**
* @param \ReflectionMethod|\ReflectionProperty $element
* @return bool
*/
private function filter($element, $static, $public_only)
{
if (!$element instanceof \ReflectionMethod && !$element instanceof \ReflectionProperty) {
throw new \InvalidArgumentException('Parameter must be a member of ReflectionMethod or ReflectionProperty class');
}
if ($static !== null && ($element->isStatic() xor $static)) {
return false;
}
if ($element->isPublic()) {
return true;
}
if ($public_only) {
return false;
}
if ($element->isProtected()) {
return true;
}
// $element is then private
return $element->getDeclaringClass()->getName() === $this->getName();
}
/**
* takes a reflection property and returns a nicely formatted key of the property name
*
* @param ReflectionProperty
* @return string
*/
protected function _getPropertyKey(ReflectionProperty $property)
{
$static = $property->isStatic() ? ' static' : '';
if ($property->isPublic()) {
return 'public' . $static . ' ' . $property->getName();
}
if ($property->isProtected()) {
return 'protected' . $static . ' ' . $property->getName();
}
if ($property->isPrivate()) {
return 'private' . $static . ' ' . $property->getName();
}
}
function _pprintr_object_ReflectionProperty(ReflectionProperty $property, $var, $indent, $indentStep)
{
$modifiers = array();
$property->setAccessible(true);
if (defined('PPRINTR_INCLUDE_PROTECTED') && PPRINTR_INCLUDE_PROTECTED) {
$property->isPublic() && ($modifiers[] = "[92mpublic[0m");
$property->isProtected() && ($modifiers[] = "[91mprotected[0m");
$property->isPrivate() && ($modifiers[] = "[91mprivate[0m");
}
$property->isStatic() && ($modifiers[] = "static");
$modifiers = implode(' ', $modifiers);
$name = $property->getName();
$value = pprintr($property->getValue($var), $indent + $indentStep, $indentStep);
$str = "[0m[1m{$name}[0m => {$value}";
if ($modifiers != []) {
$str = "[0m{$modifiers}[1m {$str}";
}
return $str;
}
/**
* Property access level label.
*
* @param \ReflectionProperty $property
* @return string
*/
private function getAccess(\ReflectionProperty $property)
{
if ($property->isPrivate()) {
return 'private';
} elseif ($property->isProtected()) {
return 'protected';
}
return 'public';
}
public function __construct()
{
$property = new ReflectionProperty(get_class($this), '_values');
var_dump($property->isProtected());
}
/**
* @param string $class
* @param string $property
*
* @return string
*/
public static function reflectClassProperty($class, $property, $output = true)
{
$data = '';
$reflectionClass = new \ReflectionClass($class);
$reflectionProperty = new \ReflectionProperty($class, $property);
$defaultPropertyValues = $reflectionClass->getDefaultProperties();
$comment = $reflectionProperty->getDocComment();
if (!empty($comment)) {
$data .= "\n";
$data .= "\t";
$data .= $comment;
}
$data .= "\n";
$data .= "\t";
$data .= $reflectionProperty->isPublic() ? 'public ' : '';
$data .= $reflectionProperty->isPrivate() ? 'private ' : '';
$data .= $reflectionProperty->isProtected() ? 'protected ' : '';
$data .= $reflectionProperty->isStatic() ? 'static ' : '';
$data .= '$' . $reflectionProperty->name;
if (isset($defaultPropertyValues[$property])) {
$data .= ' = ' . self::getDebugInformation($defaultPropertyValues[$property]);
}
$data .= ';';
if ($output) {
self::output($data);
}
return $data;
}
