Returns a list of AttributeValues from the file itself,
 including all defaults set by SEM. AttributeValues are defined
 in comments in the file.
199582
def parse_attribute_values
      values = []
      each_property do |name, value|
        values << AttributeValue.new(name, value)
      end

      DEFAULTS.each do |default|
        if values.find { |v| v.attribute.name == default.attribute.name }.nil?
          values << default
        end
      end

      values
    end
956889
def extract_values(self, possible_solution, use_defaults=False):
        
        defaults = self._vardefaults if use_defaults else {}
        values = list(self._template)
        for i, var in enumerate(self._vars):
            values[i] = possible_solution.get(var, defaults.get(var, NilObject()))
        return values
533182
def value(self):
        
        r = {}
        attributes = [attr for attr in dir(self)
                      if not attr.startswith('__') and \
                      not attr.startswith('_')]
        for a in attributes:
            if a != "value":
                val = getattr(self, a)
                if val is not None:
                    r[a] = val
        return r
615814
private function getAttributeValues($attribute, $attributeValues)
    {
        $values = [];
        foreach ($attributeValues as $attributeValue) {
            if ($attribute['id'] == $attributeValue['attributeId']) {
                $values[] = $attributeValue;
            }
        }

        return $values;
    }
507407
def _get_values(profile=None):
    '''
    
    '''
    profile = profile or {}
    serializers = salt.loader.serializers(__opts__)

    ret = {}
    for fname in profile.get('files', []):
        try:
            with salt.utils.files.flopen(fname) as yamlfile:
                contents = serializers.yaml.deserialize(yamlfile)
                ret = salt.utils.dictupdate.merge(
                    ret, contents, **profile.get('merge', {}))
        except IOError:
            log.error("File '%s' not found ", fname)
        except TypeError as exc:
            log.error("Error deserializing sdb file '%s': %s", fname, exc)
    return ret
193516
def values_list(self, *args, **kwargs):
        
        flat = kwargs.pop('flat', False)
        assert flat is True
        assert len(args) == 1
        assert args[0] == self.model._meta.pk.name
        return self.pks
307795
public Iterable<Attribute> getOwnAttributes() {
    return stream(getOwnAllAttributes()).filter(attr -> attr.getParent() == null).collect(toList());
  }
763132
def _GetAttributes(self):
    
    if self._attributes is None:
      self._attributes = []

      for tsk_attribute in self._tsk_file:
        if getattr(tsk_attribute, 'info', None) is None:
          continue

        # At the moment there is no way to expose the attribute data
        # from pytsk3.
        attribute_object = TSKAttribute(tsk_attribute)
        self._attributes.append(attribute_object)

    return self._attributes
1234951
def _get_value_specs(cls, cls_in, attribute_name):
        

        if cls_in in {dict, list}:
            return ValueSpecs(None, ValueTypes(None, None))
        else:
            return cls._fetch_attribute_specs_from_doc(cls_in, attribute_name)
755985
public String getAttribute(String attributeName, String defaultValue)
	{
        String result = defaultValue;
        if (m_attributeList!=null)
        {
            result = (String)m_attributeList.get(attributeName);
            if (result==null)
            {
                result = defaultValue;
            }
        }
        return result;
	}
742430
def get_each_choice(self, cls=None, **kwargs):
        
        defaults = {attr: kwargs[attr][0] for attr in kwargs}
        for set_of_values in izip_longest(*kwargs.values()):
            case = cls() if cls else self._CasesClass()
            for attr, value in izip(kwargs.keys(), set_of_values):
                if value is None:
                    value = defaults[attr]
                setattr(case, attr, value)
            yield case
1285602
def GetAttributes(self):
    
    for attribute_name, attribute_value in iter(self.__dict__.items()):
      # Not using startswith to improve performance.
      if attribute_name[0] == '_' or attribute_value is None:
        continue

      yield attribute_name, attribute_value
573701
def serializable_attributes(self):
        

        if hasattr(self, 'blacklist_attributes'):
            return [attr for attr in self.attributes if attr not in
                    self.blacklist_attributes]
        else:
            return self.attributes
199991
def values(self):
        
        return [getattr(self, c.name, None) for c in self.__table__._columns]
280398
public List<FieldValue> getFieldValues() {
        long offset = fileOffset + getInstanceFieldValuesOffset();
        List<Field> fields = dumpClass.getAllInstanceFields();
        List<FieldValue> values = new ArrayList<FieldValue>(fields.size());
        Iterator<Field> fit = fields.iterator();

        while (fit.hasNext()) {
            HprofField field = (HprofField) fit.next();

            if (field.getValueType() == HprofHeap.OBJECT) {
                values.add(new HprofInstanceObjectValue(this, field, offset));
            } else {
                values.add(new HprofInstanceValue(this, field, offset));
            }

            offset += field.getValueSize();
        }

        return values;
    }
1250504
def getAttributeValueData(self, index):
        
        offset = self._get_attribute_offset(index)
        return self.m_attributes[offset + const.ATTRIBUTE_IX_VALUE_DATA]
1311711
def resolve_params(obj, params, default=missing):
    
    param_values = {}
    for name, attr_tpl in iteritems(params):
        attr_name = tpl(str(attr_tpl))
        if attr_name:
            attribute_value = get_value(obj, attr_name, default=default)
            if attribute_value is not missing:
                param_values[name] = attribute_value
            else:
                raise AttributeError(
                    '{attr_name!r} is not a valid '
                    'attribute of {obj!r}'.format(attr_name=attr_name, obj=obj),
                )
        else:
            param_values[name] = attr_tpl
    return param_values