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"; }
/** * EntityPropertyMetadata constructor. * * @param string $propertyName * @param \GraphAware\Neo4j\OGM\Metadata\PropertyAnnotationMetadata $propertyAnnotationMetadata */ public function __construct($propertyName, \ReflectionProperty $reflectionProperty, PropertyAnnotationMetadata $propertyAnnotationMetadata) { $this->propertyName = $propertyName; $this->reflectionProperty = $reflectionProperty; $this->propertyAnnotationMetadata = $propertyAnnotationMetadata; $this->isAccessible = $reflectionProperty->isPublic(); }
public function __construct($class, $property) { $property = new ReflectionProperty($class, $property); list($description, $tags) = Kodoc::parse($property->getDocComment()); $this->description = $description; if ($modifiers = $property->getModifiers()) { $this->modifiers = '<small>' . implode(' ', Reflection::getModifierNames($modifiers)) . '</small> '; } if (isset($tags['var'])) { if (preg_match('/^(\\S*)(?:\\s*(.+?))?$/', $tags['var'][0], $matches)) { $this->type = $matches[1]; if (isset($matches[2])) { $this->description = Markdown($matches[2]); } } } $this->property = $property; // Show the value of static properties, but only if they are public or we are php 5.3 or higher and can force them to be accessible if ($property->isStatic() and ($property->isPublic() or version_compare(PHP_VERSION, '5.3', '>='))) { // Force the property to be accessible if (version_compare(PHP_VERSION, '5.3', '>=')) { $property->setAccessible(TRUE); } // Don't debug the entire object, just say what kind of object it is if (is_object($property->getValue($class))) { $this->value = '<pre>object ' . get_class($property->getValue($class)) . '()</pre>'; } else { $this->value = Kohana::debug($property->getValue($class)); } } }
/** * {@inheritDoc} */ public function getReference($name, $property = null) { if (isset($this->objectsCache[$name])) { try { $reference = $this->entityManager->merge($this->objectsCache[$name]); } catch (\Exception $e) { var_dump($e->getMessage()); var_dump($this->objectsCache[$name]); exit; } } else { if (isset($this->references[$name])) { $reference = $this->references[$name]; } else { throw new \UnexpectedValueException('Reference ' . $name . ' is not defined'); } } if ($property !== null) { if (property_exists($reference, $property)) { $prop = new \ReflectionProperty($reference, $property); if ($prop->isPublic()) { return $reference->{$property}; } } $getter = 'get' . ucfirst($property); if (method_exists($reference, $getter) && is_callable(array($reference, $getter))) { return $reference->{$getter}(); } throw new \UnexpectedValueException('Property ' . $property . ' is not defined for reference ' . $name); } return $reference; }
/** * @param string $sOffset */ public function offsetUnset($sOffset) { $oProperty = new \ReflectionProperty($this, $sOffset); if ($oProperty->isPublic()) { unset($this->{$sOffset}); } }
/** * Call to undefined method. * * @param string method name * @param array arguments * @return mixed * @throws \MemberAccessException */ public static function call($_this, $name, $args) { $class = get_class($_this); if ($name === '') { throw new MemberAccessException("Call to class '{$class}' method without name."); } // event functionality if (preg_match('#^on[A-Z]#', $name)) { $rp = new ReflectionProperty($class, $name); if ($rp->isPublic() && !$rp->isStatic()) { $list = $_this->{$name}; if (is_array($list) || $list instanceof Traversable) { foreach ($list as $handler) { /**/ fixCallback($handler); /**/ if (!is_callable($handler)) { $able = is_callable($handler, TRUE, $textual); throw new InvalidStateException("Event handler '{$textual}' is not " . ($able ? 'callable.' : 'valid PHP callback.')); } call_user_func_array($handler, $args); } } return NULL; } } // extension methods if ($cb = self::extensionMethod($class, $name)) { array_unshift($args, $_this); return call_user_func_array($cb, $args); } throw new MemberAccessException("Call to undefined method {$class}::{$name}()."); }
public function __call($name, $args) { $class = get_class($this); if ($name === '') { throw new MemberAccessException("Call to class '{$class}' method without name."); } if (preg_match('#^on[A-Z]#', $name)) { $rp = new ReflectionProperty($class, $name); if ($rp->isPublic() && !$rp->isStatic()) { $list = $this->{$name}; if (is_array($list) || $list instanceof Traversable) { foreach ($list as $handler) { if (is_object($handler)) { call_user_func_array(array($handler, '__invoke'), $args); } else { call_user_func_array($handler, $args); } } } return NULL; } } if ($cb = self::extensionMethod("{$class}::{$name}")) { array_unshift($args, $this); return call_user_func_array($cb, $args); } throw new MemberAccessException("Call to undefined method {$class}::{$name}()."); }
public function test_publicProperties() { $items = array('folder', 'name', 'info', 'handle', 'lock'); foreach ($items as $item) { $prop = new ReflectionProperty($this->myClass, $item); $this->assertTrue($prop->isPublic()); } }
/** * Returns true if this property has public as access level. * * @return bool */ public function isPublic() { if ($this->reflectionSource instanceof ReflectionProperty) { return $this->reflectionSource->isPublic(); } else { return parent::isPublic(); } }
public function test___publicProperties() { $items = array('vars', 'cleanVars', 'plugin_path'); foreach ($items as $item) { $prop = new ReflectionProperty($this->myClass, $item); $this->assertTrue($prop->isPublic()); } }
public function test___publicProperties() { $items = array('handler', 'active', 'path_basic', 'path_plugin', 'configPath', 'name', 'config', 'message'); foreach ($items as $item) { $prop = new ReflectionProperty($this->myclass, $item); $this->assertTrue($prop->isPublic()); } }
public function test___publicProperties() { $items = array('tempArr', 'themeSetData', 'imagesData', 'templatesData'); foreach ($items as $item) { $prop = new ReflectionProperty($this->myclass, $item); $this->assertTrue($prop->isPublic()); } }
public function test___publicProperties() { $items = array('db'); foreach ($items as $item) { $prop = new ReflectionProperty($this->myclass, $item); $this->assertTrue($prop->isPublic()); } }
public function test___publicProperties() { $items = array('ldap_provisioning', 'ldap_provisioning_upd', 'ldap_field_mapping', 'ldap_provisioning_group'); foreach ($items as $item) { $prop = new ReflectionProperty($this->object, $item); $this->assertTrue($prop->isPublic()); } }
private function getProperty($classOrObject, $property) { $property = new \ReflectionProperty(is_object($classOrObject) ? get_class($classOrObject) : $classOrObject, $property); if (!$property->isPublic()) { $property->setAccessible(true); } return $property->isStatic() ? $property->getValue($classOrObject) : $property->getValue(); }
public function test___publicProperties() { $items = array('table', 'keyName', 'className', 'table_link', 'identifierName', 'field_link', 'field_object', 'keyName_link'); foreach ($items as $item) { $prop = new ReflectionProperty($this->myClass, $item); $this->assertTrue($prop->isPublic()); } }
/** * Returns 'true' if the class property is public (it exists and its scope is 'public'). * * @param string $classNamespace The fully qualified name of the class * @param string $propertyName * * @return bool */ public function isPublic($classNamespace, $propertyName) { if (!property_exists($classNamespace, $propertyName)) { return false; } $propertyMetadata = new \ReflectionProperty($classNamespace, $propertyName); return $propertyMetadata->isPublic(); }
/** * {@inheritdoc} * @throws PropertyDefinitionNotFoundException */ public function analyze(DefinitionAnalyzer $analyzer, ClassDefinition $classDefinition, \ReflectionProperty $reflectionProperty) { $propertyName = $reflectionProperty->getName(); // Set property metadata if ($classDefinition->hasProperty($propertyName)) { $classDefinition->getProperty($propertyName)->setIsPublic($reflectionProperty->isPublic())->setModifiers($reflectionProperty->getModifiers()); } }
public function setAttributes(array $params) { foreach ($params as $key => $param) { if (property_exists($this, $key) and $reflectionProp = new \ReflectionProperty(get_class($this), $key) and $reflectionProp->isPublic()) { $this->{$key} = $param; } } return $this; }
/** * @param $argument * @return bool */ public function hasArgument($argument) { try { $reflectionProperty = new \ReflectionProperty($this, $argument); } catch (\ReflectionException $e) { return false; } return $reflectionProperty->isPublic(); }
public function __set($key, $value) { $property = new \ReflectionProperty($this->class, $key); if (!$property->isPublic()) { $property->setAccessible(true); } $property->isStatic() ? $property->setValue($value) : $property->setValue($this->object, $value); return $this; }
/** * 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; } }
/** * {@inheritdoc} */ public function setValue(&$object, $propertyPath, $value) { if ($this->isWritable($object, $propertyPath)) { $property = new \ReflectionProperty(get_class($object), $propertyPath); if (!$property->isPublic()) { $property->setAccessible(true); } $property->setValue($object, $value); } }
private function getPropertyFromObject($object, $property) { if (!is_object($object)) { throw new InvalidArgumentException('Object expected as first parameter.'); } $ref = new \ReflectionProperty($object, $property); if (!$ref->isPublic()) { $ref->setAccessible(true); } return $ref->getValue($object); }
/** * Generic class property resolver. * * @param \ReflectionProperty $property * @param ClassMetadata $classMetadata * * @return PropertyMetadata Resolved property metadata */ protected function resolvePropertyMetadata(\ReflectionProperty $property, ClassMetadata $classMetadata) : PropertyMetadata { // Create method metadata instance $propertyMetadata = $classMetadata->propertiesMetadata[$property->getName()] ?? new PropertyMetadata($classMetadata); $propertyMetadata->name = $property->getName(); $propertyMetadata->modifiers = $property->getModifiers(); $propertyMetadata->isPublic = $property->isPublic(); $propertyMetadata->typeHint = $this->getCommentTypeHint(is_string($property->getDocComment()) ? $property->getDocComment() : ''); // Store property metadata to class metadata return $classMetadata->propertiesMetadata[$propertyMetadata->name] = $propertyMetadata; }
/** * Offset to set * @link http://php.net/manual/en/arrayaccess.offsetset.php * @param mixed $offset * The offset to assign the value to. * @param mixed $value * The value to set. * @return void */ public function offsetSet($offset, $value) { if (property_exists(get_class($this), $offset)) { $property = new ReflectionProperty(get_class($this), $offset); if ($property->isPublic()) { $this->{$offset} = $value; } return; } $this->{$offset} = $value; }
/** * {@inheritdoc} */ public function getValue($object, $propertyPath) { if ($this->isReadable($object, $propertyPath)) { $property = new \ReflectionProperty(get_class($object), $propertyPath); if (!$property->isPublic()) { $property->setAccessible(true); } return $property->getValue($object); } return; }
public function attris() { $attris = array(); foreach ($this as $field => $value) { $property = new ReflectionProperty($this, $field); if ($property->isPublic()) { $attris[$field] = $value instanceof Types\Set ? $value->members() : $value; } } return $this->_data + $attris; }
public function __construct($properties = array()) { // define attributes foreach ($properties as $key => $val) { $attr = new \ReflectionProperty($this, $key); if ($attr->isPublic()) { $this->{$key} = $val; } else { throw new \Exception(t('The attribute "' . $key . '" is not public')); } } }
public function test___construct() { $class = $this->myclass; $instance = new $class(); $this->assertInstanceOf($class, $instance); $this->assertInstanceOf('Xoops\\Form\\TextArea', $instance); $items = array('isEnabled', 'configs', 'rootPath'); foreach ($items as $item) { $reflection = new ReflectionProperty($this->myclass, $item); $this->assertTrue($reflection->isPublic()); } }