Return an array containing the names of all currently defined configuration
attributes. If there are no such attributes, a zero length array is
returned.
510862
@SuppressWarnings("unchecked")
    public String[] getAttributeNames() {

        List<String> names = new ArrayList<String>();
        Enumeration<String> keys = attributes.keys();
        while (keys.hasMoreElements()) {
            names.add((String) keys.nextElement());
        }
        String results[] = new String[names.size()];
        for (int i = 0; i < results.length; i++) {
            results[i] = (String) names.get(i);
        }
        return (results);

    }
476355
def attributes(self):
        
        return dict([(name, getattr(self, name)) for (name, _) in self.format.values() if name is not None and not name.startswith('_')])
249879
def get_attributes(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
1076187
function() {
        var attrNames;
        attrNames = 1 <= arguments.length ? __slice.call(arguments, 0) : [];
        return attrNames.each(function(attrName) {
          return self[attrName] = function() {
            return I[attrName];
          };
        });
      }
195932
public java.util.List<String> getConfigurationSetAttributeNames() {
        if (configurationSetAttributeNames == null) {
            configurationSetAttributeNames = new com.amazonaws.internal.SdkInternalList<String>();
        }
        return configurationSetAttributeNames;
    }
1196392
function(options) {
      var attrs = options.attributes;
      if (_.isFunction(attrs)) {
        attrs = attrs();
      }
      if (_.isArray(attrs)) {
        return attrs;
      }
    }
596899
def get_attributes(self):
        
        attributes = []
        for i in reversed(xrange(len(self.layers))):
            obj = self.layers[i]
            stack_attributes = [attribute for attribute in obj.__dict__.keys()
                                if not attribute.startswith('__') and
                                not attribute.endswith('__')]
            attributes = attributes + stack_attributes
        return list(set(attributes))
312045
function() {
        var attrNames;
        attrNames = 1 <= arguments.length ? __slice.call(arguments, 0) : [];
        return attrNames.each(function(attrName) {
          return self[attrName] = function(newValue) {
            if (newValue != null) {
              I[attrName] = newValue;
              return self;
            } else {
              return I[attrName];
            }
          };
        });
      }
319334
def _repr_attributes(self):
        """"""
        if self._repr_attributes_override is None:
            # Default to init arguments
            attrs = getfullargspec(self.__init__).args[1:]
            mapping = self._repr_attributes_mapping
            if mapping:
                attrs = [mapping[a] if a in mapping else a for a in attrs]
            return attrs

        return self._repr_attributes_override
348742
def getAttributeNames(self):
        '''
        '''
        return map(lambda e: self.getAttributeName(e.name), self.tcListElements)
179336
def _get_attrs(self, names):
        
        assert isinstance(names, str)
        names = names.replace(",", " ").split(" ")
        res = []
        for n in names:
            if n == "":
                continue
            if n not in self.__dict__:
                raise KeyError("Unknown name for Container attribute: '{}'".format(n))
            res.append(getattr(self, n))
        return res
1024693
def attributes(self):
        

        overridden_attrs = self._attributes
        sortmap = {"neutral": 1, "positive": 2,
                   "negative": 3}

        sortedattrs = list(overridden_attrs.values())
        sortedattrs.sort(key=operator.itemgetter("defindex"))
        sortedattrs.sort(key=lambda t: sortmap.get(t.get("effect_type",
                                                         "neutral"), 99))
        return [item_attribute(theattr) for theattr in sortedattrs]
1250869
def get_complex_attrs(self):
        ''''''
        return [getattr(self, attr_name) for attr_name in self._attributes if
                isinstance(getattr(self, attr_name), ComplexSchemaItem)]
182951
def attributes(self):
        
        attrs = self._schema["attributes"]
        return [item_attribute(attr) for attr in sorted(attrs.values(),
                key=operator.itemgetter("defindex"))]
884546
function getAllAttributes() {
  return _.reduce(
    this.getInheritanceChain(),
    (acc, cls) => _.reduce(cls.attributes, (acc2, v, k) => {acc2[k] = v; return acc2}, acc),
    {})
}
901966
public static Iterable<String> getAttributeNames(Iterable<Attribute> attrs) {
    return () -> stream(attrs).map(Attribute::getName).iterator();
  }
5231
public String[] toStringArray() {
        String key;
        String attrs[] = new String[hashAttributes.size() * 2];
        String[] keys = hashAttributes.keySet().toArray(new String[0]);
        for (int x = 0; x < keys.length; x++) {
            attrs[(x * 2)] = keys[x];
            attrs[(x * 2) + 1] = "" + hashAttributes.get(keys[x]);
        }
        return attrs;
    }