Returns a $app object property if it exists

@param      string      $property  The property name, or container name to
return

@return     mixed|null  Null if nothing was found
340973
public function getProperty(string $property)
  {
    if (\property_exists(__CLASS__, $property)) {
      return $this->$property;
    }

    return $this->container($property) ?? null;
  }
1128104
public function getOPT($property)
    {
        if (isset($this->OPT[$property])) {
            return $this->OPT[$property];
        }
        return null;
    }
320574
public static function get_property_null($property) {

        self::fill_properties_cache();

        if (!array_key_exists($property, self::$propertiescache)) {
            throw new coding_exception('Invalid property requested: ' . $property);
        }

        return self::$propertiescache[$property]['null'];
    }
1045940
public function get($property, $default = null)
    {
        if ($this->has($property)) {
            $method = 'get' . Str::studly($property);
            $return = $this->message->{$method}();

            return is_null($return) ? $default : $return;
        }

        return $default;
    }
369896
public function getOrderFor(string $property) : ?Order
    {
        /* @var $order Order */
        foreach ($this as $order) {
            if ($order->getProperty() == $property) {
                return $order;
            }
        }
        return null;
    }
615691
protected function invokeProperty($obj, $property = null)
    {
        if (null === $property) {
            return null;
        }

        if (!settype($property, 'string')) {
            return null;
        }

        $property = trim($property);
        if (0 === mb_strlen($property)) {
            return null;
        }

        if (!is_object($obj)) {
            return null;
        }

        $methods = [
            $this->createMethodName('get', $property),
            $this->createMethodName('is', $property),
            $property
        ];

        $r = new \ReflectionObject($obj);
        foreach ($methods as $method) {
            if ($r->hasMethod($method)) {
                $result = $r->getMethod($method)->invoke($obj);

                return $result;
            }
        }

        if ($r->hasProperty($property)) {
            $rProperty = $r->getProperty($property);
            if ($rProperty->isPublic()) {
                $result = $rProperty->getValue($obj);

                return $result;
            }
        }

        return null;
    }
564836
private static function &getProperty($object, string $property)
  {
    $value = &\Closure::bind(function & () use ($property) {
      return $this->$property;
    }, $object, $object)->__invoke();

    return $value;
  }
317299
public function getProperty(int $object, string $property)
    {
        $this->protocol->propertyAccessBegin($object, $property);
        $this->protocol->propertyAccessEnd();

        return $this->getResult();
    }
52722
public function get($property = null)
    {
        if ($property === null || $property == '') {
            return $this->config;
        }

        $tree = explode('.', $property);
        $node = $this->config;
        foreach ($tree as $workingNode) {
            if (!array_key_exists($workingNode, $node)) {
                $actualNode = null;
                foreach ($node as $testNodeKey => $testNode) {
                    if (\URLify::filter($testNodeKey) == $workingNode) {
                        $actualNode = $testNodeKey;
                    }
                }
                if ($actualNode === null) {
                    throw new \InvalidArgumentException('The property "'.$property
                        .'" was not found. Failed while getting node "'.$workingNode.'"');
                }
                $workingNode = $actualNode;
            }
            $node = $node[$workingNode];
        }

        return $node;
    }
65958
public function &__get($property)
    {
        $value = null;
        switch ($property) {
            case 'url':
                if (isset($this->settings['url']))
                    return $this->settings['url'];
                break;
            case 'frequency':
                if (isset($this->settings['frequency']))
                    return $this->settings['frequency'];
                break;
            case 'nextCheck':
                if (isset($this->settings['next_check']))
                    return $this->settings['next_check'];
                break;
            case 'request':
                return $this->request;
            case 'data':
                return $this->data;
            case 'isOffline':
                $value = isset($this->settings['offline']);
                break;
            case 'isOfflineValid':
                $value = $this->isOffline
                    && ($this->settings['offline'] === true
                        || time() < $this->settings['offline']
                    );
                break;
            case 'isValid':
                $value = false;
                if (isset($this->settings['frequency'])
                    && !empty($this->settings['frequency'])
                    && isset($this->data)
                    && !empty($this->data)
                    && is_numeric($this->data['activation_id'])
                ) {
                    $value = $this->data['expire'] === null || time() < $this->data['expire'];
                }
                break;
            case 'isEmpty':
                $value = empty($this->data);
                break;
            case 'version':
                if (isset($this->settings['version']))
                    return $this->settings['version'];
                break;
            case 'retries':
                if (isset($this->settings['retries']))
                    return $this->settings['retries'];
                break;
        }
        return $value;
    }
547282
public function getAlias($property)
    {
        $alias = null;

        if (isset($this->_alias[$property])) {
            $alias = $this->_alias[$property];
        }

        return $alias;
    }
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);
    }
237
public function __isset($property)
    {
        if ($propertyReflector = $this->liberatorPropertyReflector($property)) {
            return null !== $propertyReflector->getValue($this->popsValue());
        }

        return parent::__isset($property);
    }
605298
public function get($property)
    {
        $auth = $this->authenticationService;
        if ($auth->hasIdentity()) {
            if (false !== strpos($property, '.')) {
                $value = $auth->getUser();
                foreach (explode('.', $property) as $prop) {
                    $value = $value->$prop;
                }
                return $value;
            }
            return 'id' == $property ? $auth->getIdentity() : $auth->getUser()->{'get' . $property}();
        }
        return null;
    }
769952
public function getRelationMappedToProperty(string $property)
    {
        InvalidArgumentException::verify(is_string($property), 'property must be a string');
        $relations = $this->getRelationMappings();

        foreach ($relations as $mapping) {
            $accessor = $mapping->getAccessor();

            if ($accessor instanceof PropertyAccessor) {
                if ($accessor->getPropertyName() === $property) {

                    return $mapping->getRelation();
                }
            }
        }

        return null;
    }
51387
public function get($property)
    {
        // CodeIgniter property aliasing
        if ($property === 'load') {
            $property = 'loader';
        }

        if (services()->has($property)) {
            return services()->get($property);
        } elseif ($property === 'model') {
            return models('controller');
        } elseif ($property === 'services' || $property === 'libraries') {
            return services();
        } elseif (method_exists($this, $property)) {
            return call_user_func([&$this, $property]);
        }

        return parent::get($property);
    }
450353
protected function getFieldByProperty($property)
    {
        foreach ($this->getFields() as $key => $annotatedField) {
            if ($property === $key) {
                return $annotatedField;
            }
        }

        return null;
    }