AppserverIo\Lang\Reflection\ReflectionProperty

Complexity

Total Complexity

19

Size/Duplication

Total Lines	276
Duplicated Lines	10.14 %

Coupling/Cohesion

Components	3
Dependencies	4

Test Coverage

Coverage

94.44%

Importance

Changes

0

15 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	15	15	1
A	__getClass()	0	4	1
A	getClassName()	0	4	1
A	getPropertyName()	0	4	1
A	getAnnotationsToIgnore()	0	4	1
A	getAnnotationAliases()	0	4	1
A	addAnnotationAlias()	0	4	1
A	hasAnnotation()	0	5	1
A	getAnnotation()	13	13	2
A	serialize()	0	4	1
A	toPhpReflectionProperty()	0	4	1
A	fromPhpReflectionProperty()	0	10	1
A	getAnnotations()	0	11	2
A	unserialize()	0	6	2
A	fromReflectionClass()	0	15	2

<?php

/**
 * AppserverIo\Lang\Reflection\ReflectionProperty
 *
 * NOTICE OF LICENSE
 *
 * This source file is subject to the Open Software License (OSL 3.0)
 * that is available through the world-wide-web at this URL:
 * http://opensource.org/licenses/osl-3.0.php
 *
 * PHP version 5
 *
 * @author    Tim Wagner <tw@appserver.io>
 * @copyright 2015 TechDivision GmbH <info@appserver.io>
 * @license   http://opensource.org/licenses/osl-3.0.php Open Software License (OSL 3.0)
 * @link      https://github.com/appserver-io/lang
 * @link      http://www.appserver.io
 */

namespace AppserverIo\Lang\Reflection;

use AppserverIo\Lang\Object;

/**
 * A wrapper instance for a reflection property.
 *
 * @author    Tim Wagner <tw@appserver.io>
 * @copyright 2015 TechDivision GmbH <info@appserver.io>
 * @license   http://opensource.org/licenses/osl-3.0.php Open Software License (OSL 3.0)
 * @link      https://github.com/appserver-io/lang
 * @link      http://www.appserver.io
 */
class ReflectionProperty extends Object implements PropertyInterface, \Serializable
{

    /**
     * Default filter for loading reflection properties from a reflection class.
     *
     * @var integer
     */
    const ALL_MODIFIERS = -1;

    /**
     * The properties class name.
     *
     * @var string
     */
    protected $className;

    /**
     * The property name.
     *
     * @var string
     */
    protected $propertyName;

    /**
     * The method annotations.
     *
     * @var array
     */
    protected $annotations;

    /**
     * Array with annotations names we want to ignore when loaded.
     *
     * @var array
     */
    protected $annotationsToIgnore;

    /**
     * Array with annotation aliases used when create annotation instances.
     *
     * @var array
     */
    protected $annotationAliases;

    /**
     * Initializes the reflection property with the passed data.
     *
     * @param string $className           The properties class name
     * @param string $propertyName        The property name
     * @param array  $annotationsToIgnore An array with annotations names we want to ignore when loaded
     * @param array  $annotationAliases   An array with annotation aliases used when create annotation instances
     */
    public function __construct($className, $propertyName, array $annotationsToIgnore = array(), array $annotationAliases = array())

This method seems to be duplicated in your project.

    {
        // initialize property default values here, as declarative default values may break thread safety,
        // when utilizing static and non-static access on class methods within same thread context!
        $this->className = '';
        $this->propertyName = '';
        $this->annotations = null;

It seems like null of type null is incompatible with the declared type array of property $annotations.

        $this->annotationsToIgnore = array();
        $this->annotationAliases = array();

        $this->className = $className;
        $this->propertyName = $propertyName;
        $this->annotationsToIgnore = $annotationsToIgnore;
        $this->annotationAliases = $annotationAliases;
    }

    /**
     * This method returns the class name as
     * a string.
     *
     * @return string
     */
    public static function __getClass()
    {
        return __CLASS__;
    }

    /**
     * Returns the properties class name.
     *
     * @return string The class name
     * @see \AppserverIo\Lang\Reflection\PropertyInterface::getClassName()
     */
    public function getClassName()
    {
        return $this->className;
    }

    /**
     * Returns the property name.
     *
     * @return string The property name
     * @see \AppserverIo\Lang\Reflection\PropertyInterface::getPropertyName()
     */
    public function getPropertyName()
    {
        return $this->propertyName;
    }

    /**
     * Returns an array with annotation names we want to ignore when loaded.
     *
     * @return array The annotation names we want to ignore
     * @see \AppserverIo\Lang\Reflection\PropertyInterface::getAnnotationsToIgnore()
     */
    public function getAnnotationsToIgnore()
    {
        return $this->annotationsToIgnore;
    }

    /**
     * Returns an array with annotation aliases used when create annotation instances.
     *
     * @return array The annotation aliases used when create annotation instances
     * @see \AppserverIo\Lang\Reflection\PropertyInterface::getAnnotationAliases()
     */
    public function getAnnotationAliases()
    {
        return $this->annotationAliases;
    }

    /**
     * Registers the annotation alias for the passed class name.
     *
     * @param string $annotationName      The alias
     * @param string $annotationClassName The resolving class name
     *
     * @return void
     * @see \AppserverIo\Lang\Reflection\PropertyInterface::addAnnotationAlias()
     */
    public function addAnnotationAlias($annotationName, $annotationClassName)
    {
        $this->annotationAliases[$annotationName] = $annotationClassName;
    }

    /**
     * Returns the method annotations.
     *
     * @return array The method annotations
     * @see \AppserverIo\Lang\Reflection\PropertyInterface::getAnnotations()
     */
    public function getAnnotations()
    {

        // check if the annotations has been loaded
        if (isset($this->annotations) === false) {
            $this->annotations = ReflectionAnnotation::fromReflectionProperty($this);
        }

        // return the annotations
        return $this->annotations;
    }

    /**
     * Queries whether the reflection method has an annotation with the passed name or not.
     *
     * @param string $annotationName The annotation we want to query
     *
     * @return boolean TRUE if the reflection method has the annotation, else FALSE
     * @see \AppserverIo\Lang\Reflection\PropertyInterface::hasAnnotation()
     */
    public function hasAnnotation($annotationName)
    {
        $annotations = $this->getAnnotations();
        return isset($annotations[$annotationName]);
    }

    /**
     * Returns the annotation instance with the passed name.
     *
     * @param string $annotationName The name of the requested annotation instance
     *
     * @return \AppserverIo\Lang\Reflection\AnnotationInterface|null The requested annotation instance
     * @throws \AppserverIo\Lang\Reflection\ReflectionException Is thrown if the requested annotation is not available
     * @see \AppserverIo\Lang\Reflection\PropertyInterface::hasAnnotation()
     */
    public function getAnnotation($annotationName)

This method seems to be duplicated in your project.

    {

        // first check if the method is available
        $annotations = $this->getAnnotations();
        if (isset($annotations[$annotationName])) {
            // if yes, return it
            return $annotations[$annotationName];
        }

        // if not, throw an exception
        throw new ReflectionException(sprintf('The requested reflection annotation %s is not available', $annotationName));
    }

    /**
     * Serializes the timeout method and returns a string representation.
     *
     * @return string The serialized string representation of the instance
     * @see \Serializable::serialize()
     */
    public function serialize()
    {
        return serialize(get_object_vars($this));
    }

    /**
     * Restores the instance with the serialized data of the passed string.
     *
     * @param string $data The serialized property representation
     *
     * @return void
     * @see \Serializable::unserialize()
     */
    public function unserialize($data)
    {
        foreach (unserialize($data) as $propertyName => $propertyValue) {
            $this->$propertyName = $propertyValue;
        }
    }

    /**
     * Returns a PHP reflection property representation of this instance.
     *
     * @return \ReflectionProperty The PHP reflection property instance
     * @see \AppserverIo\Lang\Reflection\PropertyInterface::toPhpReflectionProperty()
     */
    public function toPhpReflectionProperty()
    {
        return new \ReflectionProperty($this->getClassName(), $this->getPropertyName());
    }

    /**
     * Returns an array of reflection property instances from the passed reflection class.
     *
     * @param \AppserverIo\Lang\Reflection\ReflectionClass $reflectionClass     The reflection class to return the properties for
     * @param integer                                      $filter              The filter used for loading the properties
     * @param array                                        $annotationsToIgnore An array with annotations names we want to ignore when loaded
     * @param array                                        $annotationAliases   An array with annotation aliases used when create annotation instances
     *
     * @return array An array with ReflectionProperty instances
     */
    public static function fromReflectionClass(ReflectionClass $reflectionClass, $filter = 0, array $annotationsToIgnore = array(), array $annotationAliases = array())
    {

        // initialize the array for the reflection properties
        $reflectionProperties = array();

        // load the reflection properties and initialize the array with the reflection properties
        $phpReflectionClass = $reflectionClass->toPhpReflectionClass();
        foreach ($phpReflectionClass->getProperties($filter) as $phpReflectionProperty) {
            $reflectionProperties[$phpReflectionProperty->getName()] = ReflectionProperty::fromPhpReflectionProperty($phpReflectionProperty, $annotationsToIgnore, $annotationAliases);
        }

        // return the array with the initialized reflection properties
        return $reflectionProperties;
    }

    /**
     * Creates a new reflection property instance from the passed PHP reflection property.
     *
     * @param \ReflectionProperty $reflectionProperty  The reflection property to load the data from
     * @param array               $annotationsToIgnore An array with annotations names we want to ignore when loaded
     * @param array               $annotationAliases   An array with annotation aliases used when create annotation instances
     *
     * @return \AppserverIo\Lang\Reflection\ReflectionProperty The instance
     */
    public static function fromPhpReflectionProperty(\ReflectionProperty $reflectionProperty, array $annotationsToIgnore = array(), array $annotationAliases = array())
    {

        // load class and method name from the reflection class
        $className = $reflectionProperty->getDeclaringClass()->getName();
        $propertyName = $reflectionProperty->getName();

        // initialize and return the timeout method instance
        return new ReflectionProperty($className, $propertyName, $annotationsToIgnore, $annotationAliases);
    }
}