Returns the form for the property, based on the mode

@param core_kernel_classes_Property $property
@param integer $index
@param boolean $isParentProp
@param array $propData
331816
protected function getPropertyForm($property, $index, $isParentProp, $propData)
    {
        $propFormClass = 'tao_actions_form_' . ucfirst(strtolower($this->propertyMode)) . 'Property';
        if (!class_exists($propFormClass)) {
            $propFormClass = 'tao_actions_form_SimpleProperty';
        }
        $propFormContainer = new $propFormClass($this->getClassInstance(), $property, array('index' => $index, 'isParentProperty' => $isParentProp ), $propData);
        return $propFormContainer->getForm();
    }
355435
public function has($property)
    {
        foreach ((array)$property as $prop) {
            $has = $this->_parentHas($prop);

            if ($has === false) {
                $has = $this->_lazyLoad($prop);
                if ($has === null) {
                    return false;
                }
            }
        }

        return true;
    }
1155974
protected function buildProperty(ClassProperty $property, $indent)
    {
        $visibility = 'public';

        if (false === $property->isPublic()) {
            $visibility = $property->isProtected() ? 'protected' : 'private';
        }

        if ($property->isStatic()) {
            $visibility = 'static '.$visibility;
        }

        $source = $visibility.' $'.$property->getName();
        $original = $property->getOriginal();

        if (isset($original['default'])) {
            $source .= ' = '.$this->wrapPHPValue([
                'default' => $original['default'],
            ]);
        }

        $docBlock = new DocBlock($property->getDocBlock(), $indent);

        return $docBlock."\n".$indent.$source.';';
    }
697169
function (property) {
      var view = _emberMetalProperty_get.get(this, 'parentView');

      while (view) {
        if (property in view) {
          return view;
        }
        view = _emberMetalProperty_get.get(view, 'parentView');
      }
    }
47846
private function renderForCheckbox(PropertyInterface $property, $value, &$isRendered)
    {
        $evaluation = $property->getExtra();

        if ((true === $isRendered) || $evaluation['multiple'] || !('checkbox' === $property->getWidgetType())) {
            return $value;
        }

        $isRendered = true;

        return !empty($value)
            ? $this->translate('MSC.yes', 'contao_default')
            : $this->translate('MSC.no', 'contao_default');
    }
841584
public function deleteClassProperty(\core_kernel_classes_Property $property)
    {
        $indexes = $property->getPropertyValues(new \core_kernel_classes_Property(OntologyIndex::PROPERTY_INDEX));

        //delete property and the existing values of this property
        if ($returnValue = $property->delete(true)) {
            //delete index linked to the property
            foreach ($indexes as $indexUri) {
                $index = new \core_kernel_classes_Resource($indexUri);
                $returnValue = $this->deletePropertyIndex($index);
            }
        }

        return $returnValue;
    }
106431
private function getParentEntityId($entity, $association, $routeType)
    {
        if (!$this->propertyAccessor->isReadable($entity, $association)) {
            $message = sprintf(
                'Property "%s::$%s" required to generate URL or path for route "%s" is not readable.',
                ClassUtils::getClass($entity),
                $association,
                $routeType
            );

            throw new RouteException($message);
        }

        $parentEntity = $this->propertyAccessor->getValue($entity, $association);

        try {
            return $this->identifierAccessor->getValue($parentEntity);
        } catch (MetadataException $ex) {
            throw new RouteException(
                sprintf('Unable to generate URL or path for route "%s": "%s".', $routeType, $ex->getMessage())
            );
        }
    }
1262762
public function getProperty($index, $default = null)
	{
		$properties = $this->get('custom_properties', []);

		if (isset($properties[$index]))
		{
			return $properties[$index];
		}

		if ($default instanceof \Closure)
		{
			return $default($this);
		}

		return $default;
	}
433738
public function setProperty(PhpProperty $property) {
		$property->setParent($this);
		$this->properties->set($property->getName(), $property);

		return $this;
	}
512943
public function parent(Int $index = 1) : stdClass
    {
        return $this->_layer($this->debug, $index, $index + 1);
    }
369217
public function hasPropertyValue(PropertyPath $propertyPath, $fromData) : bool
    {
        try {
            $this->getPropertyValue($propertyPath, $fromData);
        }catch (InvalidArgumentException $e) {
            return false;
        }

        return true;
    }
1229330
function(property) {
            if (this.hasOwnProperty(property) && !_.isUndefined(this[property])) {
                return this[property];
            }

            if (this.__proto && this.__proto.hasOwnProperty(property) && !_.isUndefined(this.__proto[property])) {
                return this.__proto[property];
            }

            var parent = this.__parent;

            while (parent) {
                if (parent.hasOwnProperty(property) && !_.isUndefined(parent[property])) {
                    return parent[property];
                }
                parent = parent.__parent;
            }
        }
12316
public function canSortBy($property)
    {
        $canSort = false;
        $singleton = $this->dataRecord->getDataSingleton();

        if ($singleton) {
            $properties = explode('.', $property);

            $relationClass = $singleton->getRelationClass($properties[0]);
            if ($relationClass) {
                if (count($properties) <= 2 && singleton($relationClass)->hasDatabaseField($properties[1])) {
                    $canSort = true;
                }
            } elseif ($singleton instanceof DataObject) {
                if ($singleton->hasDatabaseField($property)) {
                    $canSort = true;
                }
            }
        }

        return $canSort;
    }
466556
public function findParentsRecursively(string $parentProperty, string $table, Model $instance): array
    {
        $parents = [];

        if (!$instance->{$parentProperty} || null === ($parentInstance = $this->findModelInstanceByPk($table, $instance->{$parentProperty}))) {
            return $parents;
        }

        return array_merge($this->findParentsRecursively($parentProperty, $table, $parentInstance), [$parentInstance]);
    }
1055039
private function handleNotFound(?PropertyMetadata $parentPropertyMetadata, string $resourceClass, string $property): PropertyMetadata
    {
        if ($parentPropertyMetadata) {
            return $parentPropertyMetadata;
        }

        throw new PropertyNotFoundException(sprintf('Property "%s" of the resource class "%s" not found.', $property, $resourceClass));
    }
877794
public function hasPropertyMetadata($property, $index)
    {
        return isset($this->propertyMetadata[$property], $this->propertyMetadata[$property][$index]);
    }
665736
public static function setResponseDataRelationshipSelfLinks($propertyName, array &$mappings, array &$parent)
    {
        $data = [];
        $parentType = $parent[Serializer::CLASS_IDENTIFIER_KEY];

        if (\is_scalar($parentType) && !empty($mappings[$parentType])) {
            $copy = $parent;
            RecursiveFormatterHelper::formatScalarValues($copy);
            if (!empty($copy[Serializer::CLASS_IDENTIFIER_KEY])) {
                unset($copy[Serializer::CLASS_IDENTIFIER_KEY]);
            }

            $idProperties = array_keys($copy);
            foreach ($idProperties as &$property) {
                $property = sprintf('{%s}', $property);
            }
            $idValues = array_values($copy);

            if (!empty($mappings[$parentType]) && !empty($selfLink = $mappings[$parentType]->getRelationshipSelfUrl($propertyName))) {
                $url = self::buildUrl($mappings, $idProperties, $idValues, $selfLink, $parentType);

                if ($url !== $selfLink) {
                    $data[JsonApiTransformer::SELF_LINK][JsonApiTransformer::LINKS_HREF] = $url;
                }
            }
        }

        return $data;
    }