{@inheritdoc}

@see \Concrete\Core\Attribute\Category\CategoryInterface::getAttributeValues()

@param \Concrete\Core\Entity\Express\Entry $entry

@return \Concrete\Core\Entity\Attribute\Value\ExpressValue[]
421713
public function getAttributeValues($entry)
    {
        $r = $this->entityManager->getRepository('\Concrete\Core\Entity\Attribute\Value\ExpressValue');
        $values = $r->findBy([
            'entry' => $entry,
        ]);

        return $values;
    }
721086
public function getCastedValue($entry, $type)
    {
        switch ($type) {
            case IndexMapping::TYPE_BOOLEAN:
                if ($entry === "false") {
                    $entry = false;
                }
                $castedValue = (bool) $entry;
                break;

            case IndexMapping::TYPE_INTEGER:
                $castedValue = (int) $entry;
                break;

            case IndexMapping::TYPE_FLOAT:
                $castedValue = (float) $entry;
                break;

            case IndexMapping::TYPE_DATE:
                if ($entry instanceof \DateTime) {
                    $entry =  $entry->format("Y-m-d");
                }

                $castedValue = (string) $entry;
                break;

            case IndexMapping::TYPE_TIME:
                if ($entry instanceof \DateTime) {
                    $entry =  $entry->format("H:i:s");
                }

                $castedValue = (string) $entry;
                break;

            case IndexMapping::TYPE_DATETIME:
                if ($entry instanceof \DateTime) {
                    $entry =  $entry->format(\DateTime::ATOM);
                }

                $castedValue = (string) $entry;
                break;

            default:
            case IndexMapping::TYPE_STRING:
            case IndexMapping::TYPE_BIG_TEXT:
                $castedValue = (string) $entry;
        }

        return $castedValue;
    }
695040
protected function propertiesFromAttributes(): array
    {
        // Get all managed properties
        $propertyNames = $this->entityMap->getProperties();

        $propertyAttributes = array_only($this->attributes, $propertyNames);
        $attributesArray = array_except($this->attributes, $propertyNames);

        $attributesArrayName = $this->entityMap->getAttributesArrayName();

        if ($attributesArrayName) {
            $propertyAttributes[$attributesArrayName] = $attributesArray;
        }

        return $propertyAttributes;
    }
92347
public function getAttributesFromString($value)
    {
        if (empty($value) === true) {
            return [];
        }

        $repository = $this->config->load($value, $this->type);

        return $repository->getArray();
    }
139595
public function toLdap(array $entry)
    {
        $toLdap = [];

        foreach ($entry as $attribute => $value) {
            $toLdap[$this->schema->getAttributeToLdap($attribute)] = $value;
        }

        return $toLdap;
    }
135508
public function getAttributes()
    {
        $array = [];

        if ($this->getValueSet() === null) {
            return $array;
        }

        foreach ($this->getValueSet()->getValues() as $value) {
            $array[$value->getAttribute()->getName()] = $value;
        }

        return $array;
    }
495107
public function getValuesFor($attributes)
	{
		$ret = array();
		foreach ($attributes as $name) {
			if (array_key_exists($name, $this->_attributes)) {
				$ret[$name] = $this->_attributes[$name];
			}
		}
		return $ret;
	}
49871
protected function getValuesByAttribute(AttributeInterface $attribute)
    {
        if (null === $this->valuesByAttributes) {
            $this->valuesByAttributes = [];
        }

        if (!array_key_exists($attribute->getCode(), $this->valuesByAttributes)) {
            $this->valuesByAttributes[$attribute->getCode()] = [];
            foreach ($this->values as $value) {
                if ($value->getAttributeCode() === $attribute->getCode()) {
                    $this->addValueByAttribute($value);
                }
            }
        }

        return $this->valuesByAttributes[$attribute->getCode()];
    }
206387
public function toValue($type = null, $valueAttribute = null)
    {
        $value = ($valueAttribute)? (string)$this[$valueAttribute] : (string)$this;
        $type = ($type)?: (string)$this['type'];

        switch ($type) {
            case 'int':
                $value = (int)$value;
                break;

            case 'float':
                $value = (float)$value;
                break;

            case 'bool':
                $value = $this->_toBoolean($value);
                break;

            case 'double':
                $value = (double)$value;
                break;

            case 'null':
                $value = null;
                break;

            case 'array':
                $value = $this->toArray(true);
                break;
        }

        return $value;
    }
15834
public function getValuesParsedAttribute()
    {
        if ($this->attributes['data'] == '')
            return null;

        $data = unserialize($this->attributes['data']);

        if (!isset($data['values']))
            return null;
        else {
            $values = preg_split("/\\r\\n|\\r|\\n/", $data['values']);
            $ret = [];

            foreach ($values as $item) {
                if (strpos($item, '=>')) {
                    $item = str_replace(' => ', '=>', $item);
                    list($key, $value) = explode('=>', $item);

                    $ret[$key] = $value;
                } else {
                    $ret[$item] = $item;
                }
            }

            return $ret;
        }
    }
349927
public function getKeyValuePair() {
        $result = array();

        foreach ($this->items as $key => $entry) {
            $result[$key] = $entry->value;
        }

        return $result;
    }
780855
public function getAttributes()
    {
        return [
            Attributes\IdAttribute::make(),
            Attributes\TextAttribute::make('number')
                ->setUnique(true),
            Attributes\BelongsToAttribute::make('sender_id')
                ->setRelationName('sender')
                ->setRelationManager(LegalEntityManager::class)
                ->setRequired(true),
            Attributes\BelongsToAttribute::make('recipient_id')
                ->setRelationName('recipient')
                ->setRelationManager(LegalEntityManager::class)
                ->setRequired(true),
            AmethystAttributes\TaxonomyAttribute::make('type_id', Config::get('amethyst.invoice.taxonomies.0.name'))
                ->setRelationName('type'),
            AmethystAttributes\CountryAttribute::make('country')
                ->setRequired(true),
            AmethystAttributes\Invoice\CurrencyAttribute::make('currency')
                ->setRequired(true),
            AmethystAttributes\Invoice\LocaleAttribute::make('locale')
                ->setRequired(true),
            Attributes\BelongsToAttribute::make('tax_id')
                ->setRelationName('tax')
                ->setRelationManager(TaxManager::class),
            Attributes\DateTimeAttribute::make('issued_at'),
            Attributes\DateTimeAttribute::make('expires_at'),
            Attributes\CreatedAtAttribute::make(),
            Attributes\UpdatedAtAttribute::make(),
            Attributes\DeletedAtAttribute::make(),
        ];
    }
240092
public function fromProtoBuf($entries)
    {
        $values = [];

        foreach ($entries as $entry) {
            $field = $entry->getField();
            $name  = $field->getName();
            $value = $this->convertMapEntry($entry);

            $values[$name] = $value;
        }

        return $values;
    }
576898
private function convertArrayToEntityValue(array $value)
    {
        $excludes = $this->pluck(Entity::EXCLUDE_FROM_INDEXES, $value, false) ?: [];

        $properties = [];
        foreach ($value as $key => $val) {
            $properties[$key] = $this->valueObject(
                $val,
                in_array($key, $excludes)
            );
        }

        if (!$properties) {
            $properties = (object) $properties;
        }

        return [
            'entityValue' => [
                'properties' => $properties
            ]
        ];
    }
908736
private function getIncreasedValueEntry($id)
    {
        $value = intval($this->get($id));
        $value++;
        if ($this->isTtlMode()) {
            $value = [
                static::ENTRY_VALUE      => $value,
                static::ENTRY_EXPIRATION => null,
            ];
        }
        return $value;
    }
1126453
public function apply(Value $value): array
    {
        if ($value->isNull() || empty($value->value())) {
            return $this->filtered(new AcceptHeader());
        }

        try {
            return $this->filtered(AcceptHeader::parse($value->value()));
        } catch (\InvalidArgumentException $iae) {
            return $this->filtered(new AcceptHeader());
        }
    }
616099
protected function parseHeaders(array $entry)
    {
        $headers = array();

        if (!is_array($entry['msgstr'])) {
            return $headers;
        }

        foreach ($entry['msgstr'] as $headerRaw) {
            $parts = explode(':', $headerRaw);
            if (count($parts) < 2) {
                continue;
            }

            $parts[1] = ltrim($parts[1]);
            $values = array_slice($parts, 1);
            $headerValue = rtrim(implode(':', $values));

            $headers[$parts[0]] = $headerValue;
        }

        return $headers;
    }