Tell the availability of the the getter function for an existing property.

@param string $propertyName
@return bool
513929
private function isExistingPropertySetterAvailable(string $propertyName): bool
    {
        assert($this->propertyExists($propertyName));
        if ($this->isExistingPropertyVirtual($propertyName)) {
            return !is_null($this->virtualSetters[$propertyName]);
        } else {
            return $this->realSetAvailable[$propertyName];
        }
    }
143289
public function getPropertyType($propertyName)
    {
        if (!isset($this->fullConfiguration['properties']) || !isset($this->fullConfiguration['properties'][$propertyName]) || !isset($this->fullConfiguration['properties'][$propertyName]['type'])) {
            return 'string';
        }
        return $this->fullConfiguration['properties'][$propertyName]['type'];
    }
1264912
public function getProperty($propertyName)
    {
        foreach ($this->getLegends() as $legend) {
            if ($legend->hasProperty($propertyName)) {
                return $legend->getProperty($propertyName);
            }
        }

        throw new DcGeneralRuntimeException(
            \sprintf(
                'The palette %s does not contain a property named %s',
                $this->getName(),
                $propertyName
            )
        );
    }
242538
protected function touchProperty($propertyName)
    {
        if (in_array('$' . $propertyName, $this->touchedProperties)) {
            return false;
        }
        $this->touchedProperties[] = '$' . $propertyName;
        return true;
    }
1070873
public static function getProperty($object, string $propertyName)
    {
        $reflection = new \ReflectionObject($object);
        $property = $reflection->getProperty($propertyName);
        $property->setAccessible(true);

        return $property->getValue($object);
    }
407977
public function hasProperty( $propertyName ) {
			
			if ( self::isProperty( $propertyName ) ) {
			
				return array_key_exists( $propertyName, $this->properties );
			
			} else {
			
				return false;
			
			}
		}
955334
public static function hasUpdateRelation($className, $propertyName = null)
    {
        $relations = AnnotationManager::getPropertiesAnnotations($className, RelationBase::class);

        if(empty($relations))
        {
            return false;
        }

        if(null === $propertyName)
        {
            foreach($relations as $name => $annotations)
            {
                $annotation = $annotations[0];
                $autoUpdate = AnnotationManager::getPropertyAnnotations($className, $name, AutoUpdate::class)[0] ?? null;
                $autoSave = AnnotationManager::getPropertyAnnotations($className, $name, AutoSave::class)[0] ?? null;
        
                if($autoUpdate)
                {
                    if(!$autoUpdate->status)
                    {
                        continue;
                    }
                }
                else if(!$autoSave || !$autoSave->status)
                {
                    continue;
                }
            }
        }
        else
        {
            $autoUpdate = AnnotationManager::getPropertyAnnotations($className, $propertyName, AutoUpdate::class)[0] ?? null;
            $autoSave = AnnotationManager::getPropertyAnnotations($className, $propertyName, AutoSave::class)[0] ?? null;
    
            if($autoUpdate)
            {
                if(!$autoUpdate->status)
                {
                    return false;
                }
            }
            else if(!$autoSave || !$autoSave->status)
            {
                return false;
            }
            return true;
        }
        return false;
    }
748641
private function isSearchable($propertyname) {
		foreach ($this->model->properties as $property) {
			if ( $property['name'] == $propertyname ) {
				if ( $property['searchable'] ) {
					return true;
				} else {
					return false;
				}
			}
		}
	}
393471
public function removeByName($propertyName)
    {
        $removedList = new self();
        $list = $this->getIterator();
        foreach ($list as $index => $property) {
            if ((is_array($propertyName) && in_array($property->getName(), $propertyName))
                || ($property->getName() === $propertyName)
            ) {
                $removedList->add(clone $property);
                $this->remove($index);
            }
        }

        return $removedList;
    }
417662
public function hasProperty($propertyName)
    {
        if (is_object($this->contentObjectProxy)) {
            return ObjectAccess::isPropertyGettable($this->contentObjectProxy->getObject(), $propertyName);
        }
        return array_key_exists($propertyName, $this->properties);
    }
231297
private function isPropertyAccessible($propertyName)
    {
        $result = false;
        $className = get_class($this);
        $reflectionService = ReflectionService::get();

        if ($reflectionService->isClassPropertyAccessible($className, $propertyName)) {
            $property = $reflectionService->getClassAccessibleProperty($className, $propertyName);
            $result = false === $property->isTaggedWith('disableMagicMethods');
        }

        return $result;
    }
1011102
public function get( $propertyName ) {
			
			if ( self::isProperty( $propertyName ) ) {
				
				return array_key_exists( $propertyName, $this->properties )
					? $this->properties[ $propertyName ]
					: null;

			} else {
			
				throw new \browserfs\Exception('Invalid argument: $propertyName: value cannot be a key!' );
			
			}
		}
345281
public function getRelationshipSelfUrl(string $propertyName)
    {
        return (!empty($this->relationshipSelfUrl[$propertyName]['self']))
            ? $this->relationshipSelfUrl[$propertyName]['self']
            : '';
    }
79460
public function getProperty($source, $propertyName) {
        foreach ($this->getPropertyAccessors() as $accessor) {
            if ($accessor->supports($source, $propertyName)) {
                return $accessor->getProperty($source, $propertyName);
            }
        }

        return null;
    }
1145485
public function indexByProperty($propertyName)
    {
        $results = [];
        foreach ($this->toArray() as $item) {
            $key = mp\getValue($item, $propertyName);
            if ($key) {
                $results[$key] = $item;
            }
        }
        return $results;
    }
1322024
public static function isPropertySettable($object, string $propertyName): bool
    {
        if (!is_object($object)) {
            throw new \InvalidArgumentException('$object must be an object, ' . gettype($object) . ' given.', 1259828920);
        }

        $className = TypeHandling::getTypeForValue($object);
        if (($object instanceof \stdClass && array_key_exists($propertyName, get_object_vars($object))) || array_key_exists($propertyName, get_class_vars($className))) {
            return true;
        }
        return is_callable([$object, self::buildSetterMethodName($propertyName)]);
    }
44195
private function isRestoreProperty($propertyName, $contentPrefix, $systemPrefix)
    {
        // return all localized and non-translatable properties
        // non-translatable properties can be recognized by their missing namespace, therfore the check for the colon
        if (0 === strpos($propertyName, $contentPrefix)
            || 0 === strpos($propertyName, $systemPrefix)
            || false === strpos($propertyName, ':')
        ) {
            return true;
        }

        return false;
    }