Fetch attributes array.
This function is internally used to handle fetched state.
18360
protected function _fetchAttributes()
	{
		if (!$this->fetched) {
			$this->fetched = true;
			$result = $this->fetchAttributes();
			if (isset($result)) {
				$this->fetched = $result;
			}
		}
	}
1334199
def get_attrs(self):
        
        self.encoding = _ensure_encoding(getattr(self.attrs, 'encoding', None))
        self.errors = _ensure_decoded(getattr(self.attrs, 'errors', 'strict'))
        for n in self.attributes:
            setattr(self, n, _ensure_decoded(getattr(self.attrs, n, None)))
157661
def fetch(reload = false, query_params = {})
      return if expanded? && !reload
      response = client.get(url_with_query_params(url, query_params))
      set_attrs_from_response(response)
      @expanded = true
    end
382833
static function fetchByObjectId( $contentobjectID, $contentobjectAttributeId = null )
    {
        $cond = array( 'contentobject_id' => $contentobjectID );
        if ( $contentobjectAttributeId !== null )
        {
            $cond['contentobject_attribute_id'] = $contentobjectAttributeId;
        }
        $return = eZPersistentObject::fetchObjectList( self::definition(), null, $cond );
        return $return;
    }
504032
def extract_attributes(model)
      self.class.attributes.reduce({}) do |result, name|
        if model.respond_to?(name)
          result[name] = model.public_send(name)
        elsif model.respond_to?(:[]) && model.respond_to?(:key?) && model.key?(name)
          result[name] = model[name]
        end
        result
      end
    end
1196392
function(options) {
      var attrs = options.attributes;
      if (_.isFunction(attrs)) {
        attrs = attrs();
      }
      if (_.isArray(attrs)) {
        return attrs;
      }
    }
11041
function getAttrMap(attrs)
{
	var i;
	var map = {};
	var numAttrs = attrs.length;
	
	for (i=0; i<numAttrs; i++)
	{
		map[ attrs[i].name ] = attrs[i].value;
	}
	
	return map;
}
1218836
def attributes
      return @attributes if defined? @attributes
      data = read_file "replay.attributes.events"
      data.slice! 0, (game_version[:build] < 17326 ? 4 : 5)
      @attributes = []
      data.slice!(0, 4).unpack("V")[0].times do
        @attributes << Attribute.read(data.slice!(0, 13))
      end
      @attributes
    end
1369904
def attributes(self, params=None):
        
        if params is None:
            params = {}
        if not self.can_update():
            self._tcex.handle_error(910, [self.type])

        for a in self.tc_requests.attributes(
            self.api_type, self.api_sub_type, self.unique_id, owner=self.owner, params=params
        ):
            yield a
879868
def attribute(*args)
      if args.first.is_a?(Hash)
        args.first.each_pair do |key, name|
          @attributes.add(name: name, attr: key)
        end
      else
        options = args.extract_options!
        args.each do |name|
          key = options[:as] || name
          @attributes.add(name: name, attr: key)
        end
      end
    end
184352
public static void fetchAttributes(RequestAdapter requestAdapter, ProcessResult processResult) {
        if (processResult != null) {
            for (ContentResult contentResult : processResult) {
                for (ActionResult actionResult : contentResult) {
                    Object actionResultValue = actionResult.getResultValue();
                    if (actionResultValue instanceof ProcessResult) {
                        fetchAttributes(requestAdapter, (ProcessResult)actionResultValue);
                    } else {
                        String actionId = actionResult.getActionId();
                        if (actionId != null) {
                            requestAdapter.setAttribute(actionId, actionResultValue);
                        }
                    }
                }
            }
        }
    }
144082
def read_attribute(name)
      name = name.to_s
      value = @attributes[name]
      accessed(name, value)
    end
1030576
def fetch(key, type, default = nil)
			if (real_hash.has_key?(key))
				value = real_hash[key]

				# if type is not an array, but value is, flatten it.
				if (type != Array && !type.kind_of?(Array) && value.kind_of?(Array))
					value = value[0]
				end

				real = type.from_user_input(value)
				if (real != nil)
					return real
				end
			end
			return default
		end
906936
public function usesAttributesArray(): bool
    {
        if ($this->arrayName === null) {
            return false;
        }

        if ($this->attributes === null) {
            return false;
        }

        return true;
    }
36985
public function getAttributes() {
		$this->_fetchAttributes();
		$attributes = array();
		foreach ($this->attributes as $key => $val) {
			$attributes[$key] = $this->getAttribute($key);
		}
		return $attributes;
	}
126512
protected function handleDataAttributes()
    {
        $dataAttributes = [];

        $dataAttributesAssetHandler = $this->getDataAttributesAssetHandler();

        if ($this->formObject->hasForm()) {
            if (false === $this->formObject->hasFormResult()) {
                $form = $this->formObject->getForm();
                $formValidator = $this->getFormValidator($this->getFormObjectName());
                $formResult = $formValidator->validateGhost($form);
            } else {
                $formResult = $this->formObject->getFormResult();
            }

            $dataAttributes += $dataAttributesAssetHandler->getFieldsValuesDataAttributes($formResult);
        }

        if (true === $this->formObject->formWasSubmitted()) {
            $dataAttributes += [DataAttributesAssetHandler::getFieldSubmissionDone() => '1'];
            $dataAttributes += $dataAttributesAssetHandler->getFieldsValidDataAttributes();
            $dataAttributes += $dataAttributesAssetHandler->getFieldsMessagesDataAttributes();
        }

        $this->tag->addAttributes($dataAttributes);
    }
517984
public function attributesToArray()
    {
        $attributes = $this->getArrayableAttributes();
        $mutatedAttributes = $this->getMutatedAttributes();
        // We want to spin through all the mutated attributes for this model and call
        // the mutator for the attribute. We cache off every mutated attributes so
        // we don't have to constantly check on attributes that actually change.
        foreach ($mutatedAttributes as $key) {
            $key = self::caseFormat($key);
            if (!array_key_exists($key, $attributes)) {
                continue;
            }
            $attributes[$key] = $this->mutateAttributeForArray(
                $key, $attributes[$key]
            );
        }
        // Next we will handle any casts that have been setup for this model and cast
        // the values to their appropriate type. If the attribute has a mutator we
        // will not perform the cast on those attributes to avoid any confusion.
        foreach ($this->casts as $key => $value) {
            $key = self::caseFormat($key);
            if (!array_key_exists($key, $attributes) ||
                in_array($key, $mutatedAttributes)
            ) {
                continue;
            }
            $attributes[$key] = $this->castAttribute(
                $key, $attributes[$key]
            );
        }
        // Here we will grab all of the appended, calculated attributes to this model
        // as these attributes are not really in the attributes array, but are run
        // when we need to array or JSON the model for convenience to the coder.
        foreach ($this->getArrayableAppends() as $key) {
            $key = self::caseFormat($key);
            $attributes[$key] = $this->mutateAttributeForArray($key, null);
        }

        return static::$filterNullValues
            ? array_filter($attributes, function($value) {
                return !is_null($value);
            })
            : $attributes;
    }