@param string $property

@return mixed

@throws \InvalidArgumentException
430672
public function get($property)
    {
        if (!$this->has($property)) {
            throw new \InvalidArgumentException(sprintf('Unknown property "%s"', $property));
        }

        $schema = $this->resolve();
        return pointer($schema)->get($property);
    }
1086889
public function getProperties(string $class){
        if(!class_exists($class)){
            throw new \InvalidArgumentException();
        }

        if(!array_key_exists($class, $this->props)){
            $this->props[$class]    = $this->getClass($class)->getProperties();
        }

        return $this->props[$class];
    }
1170459
public function getDataProperty($property)
    {
        return isset($this->data[$property]) ? $this->data[$property] : 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'];
    }
590625
public static function getValue($object, $propertyName)
    {
        $metadata = self::$entityManager->getClassMetadata(get_class($object));

        if (!$metadata->hasField($propertyName)) {
            throw new \InvalidArgumentException(
                'The class "' . get_class($object) . '" does not have the property "' . $propertyName . '"'
            );
        }

        return $metadata->getFieldValue($object, $propertyName);
    }
1352222
public function enum(string $property): EnumPropertyColumnDefiner
    {
        $this->verifyProperty(__METHOD__, $property);
        $type       = $this->class->getPropertyType($property);
        $isNullable = $type->isNullable();
        $enumType   = $type->nonNullable();

        if (!($enumType instanceof ObjectType)) {
            throw InvalidArgumentException::format(
                'Invalid enum property \'%s\': must map to an object type, %s given',
                $property, $type->asTypeString()
            );
        }

        $class = $enumType->getClass();

        return $this->relation($property)->asEmbedded()->enum($class, $isNullable);
    }
978097
protected function valPropStructure($property)
    {
        // If the property object is invalid
        if (!is_object($property) || !$this->valPropProperties($property)) {
            throw new InvalidArgumentException(
                InvalidArgumentException::INVALID_PROPERTY_STR,
                InvalidArgumentException::INVALID_PROPERTY
            );
        }
    }
389401
public function readProperties($object)
    {
        if (!is_object($object)) {
            throw new InvalidArgumentException(1, 'object');
        }

        $reflector = new \ReflectionObject($object);
        $result    = array();

        // Iterate over the properties of the object.
        foreach ($reflector->getProperties() as $property) {
            $property->setAccessible(true);
            $result[$property->getName()] = $property->getValue($object);
        }

        return $result;
    }
1314283
public function mapTo($property)
    {
        if (!$this->mappingTo) {
            $this->mappingTo = array_flip($this->mapping);
        }

        return isset($this->mappingTo[$property]) ? $this->mappingTo[$property] : $property;
    }
142633
final protected static function get_property_error_message($property) {
        $properties = static::properties_definition();
        if (!isset($properties[$property]['message'])) {
            return new lang_string('invaliddata', 'error');
        }
        return $properties[$property]['message'];
    }
633937
public function &__get($property)
    {
        if (isset($this->{'_'.$property})) {
            if ($property == 'filepath' && empty($this->_filepath)) {
                $this->_filepath = self::$_locators[$this->_type]->findPath($this);
            }

            if ($property == 'classname' && empty($this->_classname)) {
                $this->_classname = self::$_locators[$this->_type]->findClass($this);
            }

            return $this->{'_'.$property};
        }
    }
889838
public function &__get($property)
    {
        $return = null;

        // check if the property is present in the content object
        if (isset($this->object->{ $property })) {
            $return = $this->object->{ $property };
        }

        return $return;
    }
1269215
protected function fetchCssProperty($property)
    {
        $name = '(?P<name>[\w\-]*)';
        $args = '(?:\((?P<args>[^\)]+)\))';
        $regexp = '/(?:' . $name . $args . '?)?/is';

        if (preg_match($regexp, $property, $segments)) {
            $result = [];

            $result[ 'name' ] = $segments[ 'name' ];
            $result[ 'args' ] = isset($segments[ 'args' ]) ? explode('|', $segments[ 'args' ]) : [];

            return $result;
        }

        throw new RuntimeException('Invalid selector');
    }
547282
public function getAlias($property)
    {
        $alias = null;

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

        return $alias;
    }
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;
    }
67840
public function getAuthKeyByVar($property)
    {
        if (!($key = array_search($property, $this->authKeyMap))) {
            $msg = 'Invalid Auth property requested: ' . $property;
            throw new ApiException($msg);
        }

        return $key;
    }
392171
public static function property($property = null)
	{
		$property = strtolower($property);
		return array_key_exists($property, static::$properties) ? static::$properties[$property] : null;
	}