@VirtualProperty
@SerializedName("variantAttributes")

@return Attribute[]
549607
public function getVariantAttributes()
    {
        $variantAttributes = [];
        foreach ($this->entity->getVariantAttributes() as $attribute) {
            $variantAttributes[] = new Attribute(
                $attribute,
                $this->locale,
                $this->productLocaleManager->getFallbackLocale()
            );
        }

        return $variantAttributes;
    }
1153627
public function getAttributes()
    {
        if ($this->cachedAttributes != null) {
          return $this->cachedAttributes;
        }

        $entries = $this->_queryAssertion('/saml:AttributeStatement/saml:Attribute');
        $this->cachedAttributes = array();

        /** $entry DOMNode */
        foreach ($entries as $entry) {
            $attributeName = $entry->attributes->getNamedItem('Name')->nodeValue;

            // Keep only one value for each entry type
            foreach ($entry->childNodes as $childNode) {
                if (is_a($childNode, 'DOMElement') && preg_match('/AttributeValue/',$childNode->tagName)){
                    $attributeValue = $childNode->nodeValue;
                }
            }

            $this->cachedAttributes[$attributeName] = $attributeValue;
        }
        return $this->cachedAttributes;
    }
1308947
public function getProductAllAttributes($variation = null)
    {
        if (null === $variation) {
            $variations = $this->productVariations()->get();
        }

        $collection = Collection::make([]);

        if (null === $variations || $variations->count() <= 0) {
            return $collection;
        }

        foreach ($variations as $variation) {
            $variationModel = self::findorfail($variation->variation_id);

            foreach ($variationModel->productVarcharAttributes as $item) {
                $collection->push($item);
            }
            foreach ($variationModel->productBooleanAttributes as $item) {
                $collection->push($item);
            }

            foreach ($variationModel->productTextAttributes as $item) {
                $collection->push($item);
            }
            foreach ($variationModel->productDecimalAttributes as $item) {
                $collection->push($item);
            }
            foreach ($variationModel->productDecimalAttributes as $item) {
                $collection->push($item);
            }
            foreach ($variationModel->productIntegerAttributes as $item) {
                $collection->push($item);
            }

            foreach ($variationModel->productDatetimeAttributes as $item) {
                $collection->push($item);
            }
        }

        return $collection;
    }
200083
protected function getAttributes()
    {
        $components = [];
        foreach ($this->arrayable as $attribute) {
            $components[] = $this->$attribute;
        }

        return $components;
    }
362970
public function getAttributes()
    {
        $emulated = [
            'params' => $this->params,
            'webroot' => $this->webroot,
            'base' => $this->base,
            'here' => $this->here
        ];

        return $this->attributes + $emulated;
    }
1149452
public function getAttributes(): array
    {
        $attributes = [];
        if ($this->confirm && $this->publicKey) {
            $attributes['confirm'] = $this->confirm;
            $attributes['public_key'] = $this->publicKey;
        }
        return $attributes;
    }
1325596
protected function variantExtensions()
    {
        $extensions = $this->config->variantExtensions();

        $variants = $this->variantsAttribute();

        if ( ! empty($variants)) {

            foreach ($this->variants() as $variant) {

                $extension = Arr::get($variants, "{$variant}.ext");

                if ($extension) {
                    $extensions[ $variant ] = $extension;
                    continue;
                }
            }
        }

        return $extensions;
    }
1051864
protected function getManagedProperties(): array
    {
        $properties = $this->entityMap->getProperties();

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

        return $attributesName == null ? $properties : array_merge($properties, [$attributesName]);
    }
863085
public function getVariantSelections()
    {
        $article = $this->getProduct();
        $variantSelectionListId = \OxidEsales\Eshop\Core\Registry::getConfig()->getRequestParameter("varselid");
        if (($articleParent = $this->_getParentProduct($article->oxarticles__oxparentid->value))) {
            return $articleParent->getVariantSelections($variantSelectionListId, $article->getId());
        }

        return $article->getVariantSelections($variantSelectionListId);
    }
834212
public function getMappedSecondAttributes()
    {
        $attributes = [];

        /* Only the first array in data will be examined, and map its attributes to db attributes,
           the attributes that are not present, will not be included
        */
        if (is_array($this->data[0])) {
            foreach ($this->data[0] as $attribute => $attributeValue) {
                if (array_key_exists($attribute, $this->mappingFirstEntityToSecondEntityAttributes)) {
                    $attributes[$this->mappingFirstEntityToSecondEntityAttributes[$attribute]] = $attributeValue;
                }
            }
        }

        return $attributes;
    }
545729
public function getPopoverAttributes():array
    {
        if ($this->popover !== null) {
            Component::getJquery()->enablePopovers();
            $attrs = $this->popoverOptions;
            $attrs['data-toggle'] = 'popover';
            $attrs['title'] = $this->popover['title'];
            $attrs['data-content'] = $this->popover['data-content'];
            return $attrs;
        }
        return [];
    }
1205941
public function attributes()
    {
        $getters = $this->getters;
        array_walk(
            $getters,
            static function ($methodName) {
                return lcfirst(substr($methodName, 3));
            }
        );

        return array_keys($this->properties + $getters);
    }
1062267
public function virtuals($attribute = null)
    {
        $fields = [];
        foreach ($this->_columns as $name => $field) {
            if (empty($field['virtual'])) {
                continue;
            }
            $fields[] = $name;
        }
        return $fields;
    }
89423
public Object[] _getAttrValues() {
		java.util.Collection<Object> attrValueCollection = attrs.values();
		return attrValueCollection.toArray(new Object[attrValueCollection.size()]);
	}
934312
public function getAttributes()
    {

        // initialize the array with the attributes
        $attributes = array();

        // prepare the pattern to filter the attributes
        $pattern = sprintf('%s-*', $this->getSerial());

        // prepare the array with the attributes
        foreach ($this as $key => $value) {
            if (fnmatch($pattern, $key)) {
                $attributes[$key] = $value;
            }
        }

        // return the attributes
        return $attributes;
    }
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;
    }
837488
protected function variantFilenames()
    {
        $names = [];

        foreach ($this->variants() as $variant) {
            $names[ $variant ] = $this->variantFilename($variant);
        }

        return $names;
    }