Get a bean property with name $propertyName.

@param string $propertyName The name of the bean property.
@return \qtism\common\beans\BeanProperty A BeanProperty object.
425415
public function getProperty($propertyName)
    {
        $className = $className = $this->getClass()->getName();

        if ($this->hasProperty($propertyName) === true) {

            try {
                return new BeanProperty($className, $propertyName);
            } catch (BeanException $e) {
                $msg = "The bean property with name '${propertyName}' in class '${className}' could not be retrieved.";
                throw new BeanException($msg, BeanException::NO_PROPERTY, $e);
            }
        } else {
            $msg = "No bean property with name '${propertyName}' in class '${className}'.";
            throw new BeanException($msg, BeanException::NO_PROPERTY);
        }
    }
1007278
public String findProperty( final String propertyName )
    {
        String value = null;
        if( m_properties != null )
        {
            value = m_properties.getProperty( propertyName );
        }
        return value;
    }
630971
public function getClassNameForPropertyName($propertyName)
    {
        $className = parent::getClassNameForPropertyName($propertyName);

        // In vCard 4, BINARY no longer exists, and we need URI instead.
        if ('Sabre\\VObject\\Property\\Binary' == $className && self::VCARD40 === $this->getDocumentType()) {
            return 'Sabre\\VObject\\Property\\Uri';
        }

        return $className;
    }
113728
public function getDefinition(string $key = null, string $propertyName = null)
    {
        return $this->getForm()->getDefinition($key, $propertyName);
    }
962696
public function getPropertyLinkedToColumn(string $columnName)
    {
        $columnName = array_search($columnName, $this->propertyColumnNameMap, true);

        return $columnName ? $columnName : null;
    }
79460
public function getProperty($source, $propertyName) {
        foreach ($this->getPropertyAccessors() as $accessor) {
            if ($accessor->supports($source, $propertyName)) {
                return $accessor->getProperty($source, $propertyName);
            }
        }

        return null;
    }
314836
public function __getSerialisablePropertyValue($propertyName)
    {
        try {
            return parent::__getSerialisablePropertyValue($propertyName);
        } catch (PropertyNotReadableException $e) {
            if ($this->__strictMode) {
                throw $e;
            } else {
                return null;
            }
        }
    }
567318
public function getByName($propertyName)
    {
        $foundList = new self();
        $list = $this->getIterator();
        foreach ($list as $property) {
            if ((is_array($propertyName) && in_array($property->getName(), $propertyName))
                || ($property->getName() === $propertyName)
            ) {
                $foundList->add($property);
            }
        }

        return $foundList;
    }
1312854
public function method(string $methodName): PropertyColumnDefiner
    {
        return new PropertyColumnDefiner($this, null, function (Column $column) use ($methodName) {
            $this->methodColumnMap[$methodName] = $column->getName();
            $this->addColumn($column);
        });
    }
287163
public function normalisePropertyName($propertyName) {
		
		if ((strlen ( $propertyName ) > 1) && ((ord ( $propertyName [1] ) >= ord ( "a" )) || is_numeric ( $propertyName [1] ))) {
			$propertyName = strtolower ( $propertyName [0] ) . substr ( $propertyName, 1 );
		}
		
		return $propertyName;
	}
1232308
public function __getSerialisablePropertyValue($propertyName) {
        $map = $this->__getSerialisablePropertyMap();
        if (array_key_exists($propertyName, $map)) {
            return $map [$propertyName];
        } elseif (array_key_exists(substr(strtoupper($propertyName), 0, 1) . substr($propertyName, 1), $map)) {
            return $map [substr(strtoupper($propertyName), 0, 1) . substr($propertyName, 1)];
        } else {
            throw new PropertyNotReadableException (get_class($this), $propertyName);
        }
    }
1045653
public function getProperty($propertyName)
    {
        if ('id' === $propertyName) {
            return $this->getID();
        }

        if (\array_key_exists($propertyName, $this->arrProperties)) {
            return $this->arrProperties[$propertyName];
        }

        return null;
    }
1317778
public function getterAvailable(string $propertyName): bool
    {
        $this->existsOrFail($propertyName);
        return $this->isExistingPropertyGetterAvailable($propertyName);
    }
518233
public static <Q> Object getPropertyValue(Q bean, String propertyName) {

        return ObjectUtils.getPropertyValue(bean, propertyName, Object.class);
    }
1007396
public function relation(string $propertyName) : RelationAliasDefiner
    {
        $this->verifyClassDefined(__METHOD__);
        $this->verifyMapperDefined(__METHOD__);

        if (!isset($this->relations[$propertyName])) {
            throw InvalidArgumentException::format(
                'Invalid property to load from parent %s: property must be mapped to a relation, \'%s\' given',
                $this->mapper->getObjectType(), $propertyName
            );
        }

        /** @var IToOneRelation $relation */
        $relation   = $this->relations[$propertyName];
        $definition = new self($this->orm);
        $definition->from($relation->getMapper());

        return new RelationAliasDefiner($definition, function ($alias, callable $relationReferenceLoader) use ($relation
        ) {
            if ($relation instanceof IToOneRelation) {
                $relation = $relation->withReference($relationReferenceLoader($relation));
            } elseif ($relation instanceof IToManyRelation) {
                $relation = $relation->withReference($relationReferenceLoader($relation));
            }

            if (is_string($alias)) {
                $relationDefiner = $this->readDefinition->relation($alias);
            } else {
                $relationDefiner = $this->readDefinition->accessorRelation(function () {
                }, $alias);
            }

            $relationDefiner->asCustom($relation);
            $this->loadRelationColumns($relation);
        });
    }
348678
public function propertyValues($propertyName)
    {
        return $this->map(function (EntityInterface $entity) use ($propertyName) {
            return $entity->getByProperty($propertyName);
        });
    }
1089461
public static function property(string $sPropertyName, ?string $sComponentName = '')
    {
        $mProperty = self::getService('properties', $sPropertyName, $sComponentName);

        if (is_callable($mProperty)) {
            return $mProperty();
        } else {
            return $mProperty;
        }
    }