Returns items.

@param PropertyInterface $property

@return array
543214
private function getItems(PropertyInterface $property)
    {
        $value = $this->getValue($property);
        if (!is_array($value['items']) || 0 === count($value['items'])) {
            return [];
        }

        return $value['items'];
    }
206275
public static function createFromProperty(PropertyInterface $property)
    {
        $argument = new self();
        $argument
            ->setName($property->getName())
            ->setType($property->getType());

        return $argument;
    }
872138
public function getPropertiesArray(NodeInterface $node)
    {
        $properties = [];
        foreach ($node->getNodeType()->getProperties() as $propertyName => $propertyConfiguration) {
            if ($propertyName[0] === '_' && $propertyName[1] === '_') {
                // skip fully-private properties
                continue;
            }

            $properties[$propertyName] = $this->getProperty($node, $propertyName);
        }

        return $properties;
    }
1169556
protected function convertCookieToArray(CookieInterface $cookie)
    {
        return [
            'name' => $cookie->getName(),
            'value' => $cookie->getValue(),
            'path' => $cookie->getPath(),
            'domain' => $cookie->getDomain(),
            'secure' => $cookie->isSecure(),
            'httponly' => $cookie->isHttpOnly(),
            'expires' => $cookie->getFormattedExpires()
        ];
    }
539565
protected function getWidgetClass(PropertyInterface $property)
    {
        if (isset(static::$widgetMapping[$property->getWidgetType()])) {
            return static::$widgetMapping[$property->getWidgetType()];
        }

        if (!isset($GLOBALS['BE_FFL'][$property->getWidgetType()])) {
            return null;
        }

        $className = $GLOBALS['BE_FFL'][$property->getWidgetType()];
        if (!\class_exists($className)) {
            return null;
        }

        return $className;
    }
1313600
public function get($property)
	{
		if(!array_key_exists($property, $this->list))
			throw new NotFoundException("Invalid property '".$property."'");
		
		return $this->list[$property];
	}
461652
public function propertyExists(EntityInterface $entity, $property)
    {
        $visibleProperties = $entity->visibleProperties();

        return in_array($property, $visibleProperties);
    }
1311883
public function getDefault($property, ValueInterface $default = null)
    {
        if (!$this->has($property)) {
            return $default;
        }

        return $this->value->$property;
    }
1097449
public function getItems()
    {
        if (!($this->items instanceof TypeInterface)) {
            $this->items = TypeCollection::getInstance()->getTypeByName($this->items);
        }

        return $this->items;
    }
1208627
private function getProvider(PropertyInterface $property)
    {
        $params = $property->getParams();

        $providerAlias = 'pages';
        if (array_key_exists('provider', $params)) {
            $providerAlias = $params['provider']->getValue();
        }

        return $this->dataProviderPool->get($providerAlias);
    }
154728
public function get($property, $default = null)
    {

        //if its an array of properties;
        if (is_array($property)) {
            $values = array();

            foreach ($property as $key => $prop) {
                if (isset($this->$prop)) {
                    $values[$prop] = $this->$prop;
                }
            }
            return (!empty($values)) ? $values : $default;
        }

        if (isset($this->$property)) {
            return $this->$property;
        }
        return $default;
    }
494361
public function collectionGroup($property)
    {
        $collections = [];
        foreach ($this->group($property) as $id => $elements) {
            $collection = $this->createFrom($elements);

            $collections[$id] = $collection;
        }

        return $collections;
    }
1146454
private function readPage($propertyName, NodeInterface $node)
    {
        $pagePropertyName = $propertyName . '-page';
        if (!$node->hasProperty($pagePropertyName)) {
            return;
        }

        try {
            $pageUuid = $node->getPropertyValue($pagePropertyName, PropertyType::STRING);
        } catch (ItemNotFoundException $exception) {
            return;
        }

        return [
            'uuid' => $pageUuid,
            'path' => $node->getPropertyValueWithDefault($pagePropertyName . '-path', ''),
            'webspace' => $node->getPropertyValueWithDefault($pagePropertyName . '-webspace', null),
        ];
    }
305621
public function get($property)
    {
        if (!array_key_exists($property, $this->data)) {
            throw new InvalidArgumentException(sprintf('Property %s does not exist', $property));
        }

        return $this->data[$property];
    }
1342375
public function getByPropertyValues($property, $values, $strict = false)
    {
        $results = [];
        foreach ($this as $item) {
            foreach ($values as $value) {
                if ($strict) {
                    if ($item->$property === $value) {
                        $results[] = $item;
                    }
                } else {
                    if ($item->$property == $value) {
                        $results[] = $item;
                    }
                }
            }
        }
        return new static($results);
    }
925817
public function getPropertyMapper($property)
    {
        if( !$this->propertyMapper ) {
            throw new NoPropertyMapperSet();
        }
        $refl = new ReflectionClass($this->propertyMapper);
        return $refl->newInstance($property);
    }
576019
protected function getPropertyValidators(core_kernel_classes_Property $property)
    {
        $validators = [];
        /** @var ValidatorInterface $validator */
        foreach (ValidationRuleRegistry::getRegistry()->getValidators($property) as $validator) {
            $validators[] = $validator->getName();
        }
        return $validators;
    }