It's a reflection method, which checks a availability and accessibility
of the properties of the child-class.
@param string $propName The property name.
@return boolean
548208
private function isPropAccessible($accessorName, $propName)
    {
        if (!isset($this->propCache[$propName])) {
            $this->addPropToCache($propName);
        }
        return $this->propCache[$propName]['accessors'][$accessorName];
    }
912179
public function isPropertyAnnotatedWith($className, $propertyName, $annotationClassName)
    {
        $className = $this->prepareClassReflectionForUsage($className);
        return isset($this->classReflectionData[$className][self::DATA_CLASS_PROPERTIES][$propertyName][self::DATA_PROPERTY_ANNOTATIONS][$annotationClassName]);
    }
204198
protected function isPropertyGettable($object, $propertyName)
    {
        $flag = false;

        if (ObjectAccess::isPropertyGettable($object, $propertyName)) {
            $flag = true;
            $getterMethodName = 'get' . ucfirst($propertyName);

            if (false === method_exists($object, $getterMethodName)
                && is_callable([$object, $getterMethodName])
            ) {
                try {
                    $object->$getterMethodName();
                } catch (\Exception $e) {
                    if ($e instanceof MethodNotFoundException
                        || false === $e instanceof SilentExceptionInterface
                    ) {
                        $flag = false;
                    }
                }
            }
        }

        return $flag;
    }
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;
    }
748641
private function isSearchable($propertyname) {
		foreach ($this->model->properties as $property) {
			if ( $property['name'] == $propertyname ) {
				if ( $property['searchable'] ) {
					return true;
				} else {
					return false;
				}
			}
		}
	}
1042919
public boolean isSet(String propName) {
        if (propName.equals("method")) {
            return isSetMethod();
        }
        if (propName.equals("object")) {
            return isSetObject();
        }
        if (propName.equals("attribute")) {
            return isSetAttribute();
        }
        return false;
    }
493224
final public function __isset($prop)
	{
		$this->magicPropConvert($prop);
		return is_array($this->{$this::MAGIC_PROPERTY})
			? array_key_exists($prop, $this->{$this::MAGIC_PROPERTY})
			: isset($this->{$this::MAGIC_PROPERTY}->$prop);
	}
934539
public function setterAvailable(string $propertyName): bool
    {
        $this->existsOrFail($propertyName);
        return $this->isExistingPropertySetterAvailable($propertyName);
    }
383338
protected function anyBranchHasProperty($methodName)
	{
		foreach ($this->branches as $branch)
		{
			foreach ($branch as $element)
			{
				if (ElementInspector::$methodName($element))
				{
					return true;
				}
			}
		}

		return false;
	}
315129
function getComputed ($propName, $default = null)
  {
    $v = $this->component->getComputedPropValue ($propName);
    return exists ($v) ? $v : $default;
  }
242538
protected function touchProperty($propertyName)
    {
        if (in_array('$' . $propertyName, $this->touchedProperties)) {
            return false;
        }
        $this->touchedProperties[] = '$' . $propertyName;
        return true;
    }
1236951
private function subtag_check ($tagName)
  {
    $propName = lcfirst ($tagName);
    if ($this->current instanceof Metadata) {
      switch ($this->current->type) {
        // All descendants of a metadata property are always metadata.
        case type::metadata:
          return true;
      }
      // Descendants of a content property are children, not properties.
      return false;
    }
    // If the current component defines an property with the same name as the tag being checked, and if that property
    // supports begin specified as a tag, the tag is a subtag.
    return $this->current->supportsProperties () && $this->current->props->defines ($propName, true);
  }
169401
public boolean isMandatory(String propName) {
        if (mandatoryProperties == null) {
            setMandatoryPropertyNames();
        }
        if (mandatoryProperties.contains(propName)) {
            return true;
        } else {
            return false;
        }
    }
809129
private function resolveProperty(Type $objType, $propName) {
        if ($objType->type === Type::TYPE_OBJECT) {
            $types = [];
            $ut = strtolower($objType->userType);
            if (!isset($this->state->classResolves[$ut])) {
                // unknown type
                return false;
            }
            foreach ($this->state->classResolves[$ut] as $class) {
                // Lookup property on class
                $property = $this->findProperty($class, $propName);
                if ($property) {
                    if ($property->type) {
                        $types[] = $property->type;
                    } else {
                        echo "Property found to be untyped: $propName\n";
                        // untyped property
                        return false;
                    }
                }
            }
            if ($types) {
                return $types;
            }
        }
        return false;
    }
449480
public Object get(String propName) {
        if (propName.equals("key")) {
            return getKey();
        }
        if (propName.equals("value")) {
            return getValue();
        }
        return null;
    }
327363
protected static function hasProperty(DOMElement $element, $propName)
	{
		$props = self::getProperties($element);

		return !empty($props[$propName]) && (!isset($props[$propName . '?']) || self::evaluate($props[$propName . '?'], $element));
	}
697136
public function __isset($prop)
    {
        if (property_exists($this, $prop) && $prop{0} != '_') {
            return true;
        }
        $method = 'get'.ucfirst(Helper::denormalize($prop));
        if (method_exists($this, $method)) {
            return true;
        }
        if (method_exists($this, 'callback')) {
            try {
                $this->callback($method, null);
                return true;
            } catch (Exception\UndefinedCallback $e) {
            }
        }
        return false;
    }