Invoke and return the given property's getter-method

@param ReflectionProperty $property The property in question

@return mixed Property value
@throws UndefinedPropertyException If given property doesn't have a corresponding get
760768
protected function invokeGetter(ReflectionProperty $property)
    {
        $methodName = $this->generateGetterName($property->getName());
        if ($this->hasInternalMethod($methodName)) {
            return $this->$methodName();
        }

        throw new UndefinedPropertyException(sprintf(
            'No "%s"() method available for property "%s"', $methodName,
            $property->getName()
        ));
    }
1070873
public static function getProperty($object, string $propertyName)
    {
        $reflection = new \ReflectionObject($object);
        $property = $reflection->getProperty($propertyName);
        $property->setAccessible(true);

        return $property->getValue($object);
    }
1212310
public function getPropertyValue($property) {

        if (FALSE !== strstr($property, '.')) {
            $property = explode('.', $property);
        } else {
            $property = [$property];
        }

        if (count($property) == 1) {
            return $this
                ->getProperty($property[0])
                ->getValue($this->instance);
        }

        $classMapper = $this;
        foreach ($property as $item) {
            $value = $classMapper
                ->getProperty($item)
                ->getValue($classMapper->instance);

            if (is_object($value)) {
                $classMapper = $classMapper::createFromInstance($value);
            }
        }

        return $value;
    }
950660
public function get(string $property)
    {
        $properties = explode('.', $property);
        $value = $this->rawConfig;

        foreach ($properties as $property) {
            if (!array_key_exists($property, $value)) {
                return null;
            }

            $value = $value[$property];
        }

        return $value;
    }
771305
public function get($property)
    {
        if ('' === $property) {
            $property = '_empty_';
        }
        if (!$this->has($property)) {
            throw new Exception\UndefinedKeyException($property);
        }

        return $this->value->$property;
    }
1096028
public static function getPrivateProperty(\ReflectionClass $reflectionClass, $property)
    {
        if (!$reflectionClass->hasProperty($property) && $reflectionClass->getParentClass()) {
            return static::getPrivateProperty($reflectionClass->getParentClass(), $property);
        }

        return $reflectionClass->getProperty($property);
    }
40757
public static Object get(Object obj, String property) throws Throwable {
        return getGetterMethod(obj.getClass(), property).invoke(obj);
    }
564836
private static function &getProperty($object, string $property)
  {
    $value = &\Closure::bind(function & () use ($property) {
      return $this->$property;
    }, $object, $object)->__invoke();

    return $value;
  }
1204423
public function get($property = '')
    {
        $data = $this->getData();

        if (! $property) {
            return $data;
        }

        return array_get($data, $property, '');
    }
68656
private function getReflectionProperty($object, $property)
    {
        if (isset($this->properties[$key = $this->getCacheKey($object, $property)])) {
            return $this->properties[$key];
        }

        $reflection = new \ReflectionProperty($object, $property);
        $reflection->setAccessible(true);

        return $this->properties[$key] = $reflection;
    }
328599
public static function getProperty($object, string $property)
    {
        $getter = \Closure::bind(
            function ($object) use ($property) {
                return $object->{$property};
            },
            null,
            get_class($object)
        );

        return $getter($object);
    }
699028
public static function invokeGet($object, $property)
    {
        $method = CamelCaser::underScoresToCamelCase($property);
        if (method_exists($object, $method)) {
            return call_user_func_array(array($object, $method), array());
        }

        $method = CamelCaser::underScoresToCamelCase('get_'.$property);
        if (method_exists($object, $method)) {
            return call_user_func_array(array($object, $method), array());
        }

        $method = CamelCaser::underScoresToCamelCase('is_'.$property);
        if (method_exists($object, $method)) {
            return call_user_func_array(array($object, $method), array());
        }

        throw new RuntimeException(sprintf('Property "%s" does not has any getter method.', $property));
    }
772324
private function getPropertyValue($property)
    {
        $value  = null;
        $getter = 'get' . SimpleDataObjectConverter::snakeCaseToUpperCamelCase($property);

        if (method_exists($this, $getter)) {
            $value = $this->{$getter}();
        } elseif ($this->returnAdditionalSetting($property)) {
            $value = $this->returnAdditionalSetting($property);
        }

        return $value;
    }
480445
protected function getPropertyValue($property)
    {
        $getter = sprintf('get%s', $property);
        if (!method_exists($this->object, $getter)) {
            throw new NostoException(
                sprintf(
                    'Class %s does not have getter for property %s',
                    get_class($this->object),
                    $property
                )
            );
        }

        return $this->object->$getter();
    }
976570
private function getMutatorMethod(string $class, string $property): ?array
    {
        $ucProperty = ucfirst($property);
        $ucSingulars = (array) Inflector::singularize($ucProperty);

        foreach ($this->mutatorPrefixes as $prefix) {
            $names = [$ucProperty];
            if (\in_array($prefix, $this->arrayMutatorPrefixes)) {
                $names = array_merge($names, $ucSingulars);
            }

            foreach ($names as $name) {
                try {
                    $reflectionMethod = new \ReflectionMethod($class, $prefix.$name);
                    if ($reflectionMethod->isStatic()) {
                        continue;
                    }

                    // Parameter can be optional to allow things like: method(array $foo = null)
                    if ($reflectionMethod->getNumberOfParameters() >= 1) {
                        return [$reflectionMethod, $prefix];
                    }
                } catch (\ReflectionException $e) {
                    // Try the next prefix if the method doesn't exist
                }
            }
        }

        return null;
    }
1186695
public function getPropertyClass(\ReflectionProperty $property) : ?string
    {
        $types = $this->getPropertyTypes($property);

        if (count($types) === 1) {
            $type = $types[0];

            if ($type[0] === '\\') {
                return substr($type, 1);
            }
        }

        return null;
    }
62166
public Object getProperty(String property) {
        /** @todo we should check if we have the property with the metaClass instead of try/catch  */
        try {
            return super.getProperty(property);
        }
        catch (MissingPropertyException e) {
            return getVariable(property);
        }
    }