Retrieve the attributes that are referenced in this filter setting.

@return array
511420
public function getReferencedAttributes()
    {
        $objMetaModel  = $this->getMetaModel();
        $objAttribute  = $objMetaModel->getAttributeById($this->get('attr_id'));
        $objAttribute2 = $objMetaModel->getAttributeById($this->get('attr_id2'));
        $arrResult     = [];

        if ($objAttribute) {
            $arrResult[] = $objAttribute->getColName();
        }

        if ($objAttribute2) {
            $arrResult[] = $objAttribute2->getColName();
        }

        return $arrResult;
    }
515309
public function getAttributes()
    {
        $attributes = array(
            'type' => $this->getInputType(),
            'name' => $this->getName(),
            'value' => $this->Value(),
            'class' => $this->extraClass(),
            'id' => $this->ID(),
            'disabled' => $this->isDisabled(),
            'readonly' => $this->isReadonly(),
            'autofocus' => $this->isAutofocus()
        );

        if ($this->Required()) {
            $attributes['required'] = 'required';
            $attributes['aria-required'] = 'true';
        }

        $attributes = array_merge($attributes, $this->attributes);

        $this->extend('updateAttributes', $attributes);

        return $attributes;
    }
796299
protected function getArrayableAttributes()
    {
        $attributes              = $this->attributes;
        $attributes['firstname'] = $attributes['first_name'];
        $attributes['lastname']  = $attributes['last_name'];

        return $this->getArrayableItems($attributes);
    }
280669
protected function attributes() {return
		($this->isNative() ? $this->attributesN() :
			['href' => $this->lHref(), 'title' => $this->s()->label()]
		)
		+ [
			'class' => df_cc_s(
				'df-sso-button', $this->cssClass(), $this->s()->type(), $this->cssClass2()
			)
			,'id' => df_uid(4, "{$this->cssClass()}-")
			,'rel' => 'nofollow'
		]
	;}
1165951
public function getAttributes()
    {
        $attributes = $this->attributes();
        $args = $this->args();

        $attributes = array_merge($this->attributes, [
            'args' => $args
        ], $attributes);

        $type = $this->type();
        if (isset($type)) {
            $attributes['type'] = $type;
        }

        $resolver = $this->getResolver();
        if (isset($resolver)) {
            $attributes['resolve'] = $resolver;
        }

        return $attributes;
    }
1085249
public function getRawAttributes()
    {
        $data = array();
        foreach ($this->attributes as $name => $attribute) {
            $data[$name] = $attribute->getValues();
        }
        return $data;
    }
1245691
protected function getAttributeFilter()
    {
        if ($this->attributeFilter) {
            return $this->attributeFilter;
        }

        return function ($key, $value) {
            if (in_array($key, $this->getNonScalarAttributes())) {
                return !is_scalar($value);
            }

            if (ends_with($key, '_id') && trim($value) === '') {
                return false;
            }

            return is_scalar($value) || $value instanceof DateTime;
        };
    }
1101406
def attributes(self):
        """"""
        if self._attributes is None:
            self._filters, self._attributes = self._fetch_configuration()
        return self._attributes
1054753
public function getMissingAttribs()
    {
        return array_combine(
            array_keys($this->missingAttribs),
            array_map(function ($ref) {
                return $ref['attrib'];
            }, array_values($this->missingAttribs))
        );
    }
1137663
final public function attributes () : array
	{
		$attributes = [];
		foreach (static::$databaseFields as $field):
			if (isset($this->$field))
				$attributes[$field] = $this->$field;
		endforeach;
		return $attributes;
	}
751313
public function getAttributes(): array
    {
        $attributes = [];
        if ($this->blockId) {
            $attributes['block'] = $this->blockId;
        }
        $attributes['node'] = $this->node;
        return $attributes;
    }
1270385
public function activeFilterAttributes()
    {
        $scenario = $this->getScenario();
        $scenarios = $this->filteringScenarios();

        $attributes = isset($scenarios[$scenario]) ? $scenarios[$scenario] : $scenarios[ActiveRecord::SCENARIO_DEFAULT];
        foreach ($attributes as $i => $attribute) {
            if ($attribute[0] === '!') {
                $attributes[$i] = substr($attribute, 1);
            }
        }

        return $attributes;
    }
297782
function    getJsFilterAttribute() {
        $filters = [];
        if ($this->deleted_at) {
            $filters[] = self::FILTER_SOFT_DELETE_YES;
        } else {
            $filters[] = self::FILTER_SOFT_DELETE_NO;
        }

        return $filters;
    }
1263610
public function getAttributes()
    {
        return [
            Attributes\IdAttribute::make(),
            Attributes\TextAttribute::make('name')
                ->setRequired(true),
            Attributes\LongTextAttribute::make('description'),
            Attributes\BelongsToAttribute::make('invoice_id')
                ->setRelationName('invoice')
                ->setRelationManager(InvoiceManager::class)
                ->setRequired(true),
            Attributes\BelongsToAttribute::make('invoice_container_id')
                ->setRelationName('invoice_container')
                ->setRelationManager(InvoiceContainerManager::class)
                ->setRequired(true),
            Attributes\BelongsToAttribute::make('tax_id')
                ->setRelationName('tax')
                ->setRelationManager(TaxManager::class)
                ->setRequired(true),
            AmethystAttributes\TaxonomyAttribute::make('unit_id', Config::get('amethyst.invoice.taxonomies.1.name'))
                ->setRelationName('unit')
                ->setRequired(true),
            Attributes\NumberAttribute::make('price')
                ->setRequired(true),
            Attributes\NumberAttribute::make('quantity')
                ->setRequired(true),
            Attributes\CreatedAtAttribute::make(),
            Attributes\UpdatedAtAttribute::make(),
            Attributes\DeletedAtAttribute::make(),
        ];
    }
1057987
public function getAttributes()
    {
        if ($this->hasSourceComponent()) {
            
            $attributes = $this->SourceComponent()->getAttributes();
            
            if ($this->StyleID) {
                $attributes['id'] = $this->StyleID;
            }
            
            if ($this->StyleClasses) {
                $attributes['class'] .= sprintf(' %s', $this->StyleClasses);
            }
            
            return $attributes;
            
        }
        
        return parent::getAttributes();
    }
530856
public function getAttributes()
    {
        $sActCat = $this->getId();

        $sKey = md5($sActCat . serialize(\OxidEsales\Eshop\Core\Registry::getSession()->getVariable('session_attrfilter')));
        if (!isset(self::$_aCatAttributes[$sKey])) {
            $oAttrList = oxNew(\OxidEsales\Eshop\Application\Model\AttributeList::class);
            $oAttrList->getCategoryAttributes($sActCat, $this->getLanguage());
            self::$_aCatAttributes[$sKey] = $oAttrList;
        }

        return self::$_aCatAttributes[$sKey];
    }
1000566
public function getAttributes()
    {
        $categorizableConfig = Config::get('amethyst.category.data.categorizable.attributes.categorizable.options');

        return [
            Attributes\IdAttribute::make(),
            Attributes\BelongsToAttribute::make('category_id')
                ->setRelationName('category')
                ->setRelationManager(CategoryManager::class)
                ->setRequired(true),
            Attributes\EnumAttribute::make('categorizable_type', array_keys($categorizableConfig))
                ->setRequired(true),
            Attributes\MorphToAttribute::make('categorizable_id')
                ->setRelationKey('categorizable_type')
                ->setRelationName('categorizable')
                ->setRelations($categorizableConfig)
                ->setRequired(true),
            Attributes\CreatedAtAttribute::make(),
            Attributes\UpdatedAtAttribute::make(),
            Attributes\DeletedAtAttribute::make(),
        ];
    }