Converts all non-final properties in {@link #getAllAttributes(Class)} to a set of the attribute names.

@param classToInspect the class to inspect
770458
public static Set<String> getAllAttributeNames(final Class<?> classToInspect) {
        Set<String> allFields = new HashSet<>();
        getAllAttributes(classToInspect, allFields, FIELD_TO_NAME, field -> true);
        return allFields;
    }
756353
@Override
    public String toImplementationClassName(final String className) {
        final String implementationClassName = interfaceToImplementationMap.get(className);
        if (implementationClassName != null) {
            return implementationClassName;
        }
        final int index = className.lastIndexOf('.');
        if (index < 0) {
            return getImplementationPackageName() + "." + className + implementationSuffix;
        }
        return className.substring(0, index) + "." + getImplementationPackageName() + "." + className.substring(index + 1)
                + implementationSuffix;
    }
1285227
private String getPropertyName(final String windowIdStr, final String fullAttributeName) {
        final String attributeName;
        if (this.nonNamespacedProperties.contains(fullAttributeName)) {
            attributeName = fullAttributeName;
        } else if (fullAttributeName.startsWith(windowIdStr)) {
            attributeName = fullAttributeName.substring(windowIdStr.length());
        } else {
            return null;
        }

        final String mappedPropertyName = this.attributeToPropertyMappings.get(attributeName);
        if (mappedPropertyName == null) {
            logger.warn(
                    "Attribute {} found that matches the portlet window ID but it is not listed in the propertyMappings or nonNamespacedProperties and will not be returned to the portlet",
                    attributeName);
            return null;
        }

        return mappedPropertyName;
    }
332329
function normalizeComponentAttributes(component, isAngleBracket, attrs) {
    var normalized = {};
    var attributeBindings = component.attributeBindings;
    var streamBasePath = component.isComponent ? '' : 'view.';
    var i, l;

    if (attrs.id && _emberHtmlbarsHooksGetValue.default(attrs.id)) {
      // Do not allow binding to the `id`
      normalized.id = _emberHtmlbarsHooksGetValue.default(attrs.id);
      component.elementId = normalized.id;
    } else {
      normalized.id = component.elementId;
    }

    if (attributeBindings) {
      for (i = 0, l = attributeBindings.length; i < l; i++) {
        var attr = attributeBindings[i];
        var colonIndex = attr.indexOf(':');

        var attrName, expression;
        if (colonIndex !== -1) {
          var attrProperty = attr.substring(0, colonIndex);
          attrName = attr.substring(colonIndex + 1);
          expression = ['get', '' + streamBasePath + attrProperty];
        } else if (attrs[attr]) {
          // TODO: For compatibility with 1.x, we probably need to `set`
          // the component's attribute here if it is a CP, but we also
          // probably want to suspend observers and allow the
          // willUpdateAttrs logic to trigger observers at the correct time.
          attrName = attr;
          expression = ['value', attrs[attr]];
        } else {
          attrName = attr;
          expression = ['get', '' + streamBasePath + attr];
        }

        _emberMetalDebug.assert('You cannot use class as an attributeBinding, use classNameBindings instead.', attrName !== 'class');

        normalized[attrName] = expression;
      }
    }

    if (isAngleBracket) {
      for (var prop in attrs) {
        var val = attrs[prop];
        if (!val) {
          continue;
        }

        if (typeof val === 'string' || val.isConcat) {
          normalized[prop] = ['value', val];
        }
      }
    }

    if (attrs.tagName) {
      component.tagName = attrs.tagName;
    }

    var normalizedClass = normalizeClass(component, attrs, streamBasePath);

    if (normalizedClass) {
      normalized.class = normalizedClass;
    }

    if (_emberMetalProperty_get.get(component, 'isVisible') === false) {
      var hiddenStyle = ['subexpr', '-html-safe', ['display: none;'], []];
      var existingStyle = normalized.style;

      if (existingStyle) {
        normalized.style = ['subexpr', 'concat', [existingStyle, ' ', hiddenStyle], []];
      } else {
        normalized.style = hiddenStyle;
      }
    }

    return normalized;
  }
952237
public void registerAnnotatedClasses(Class<?>... classesToInspect) {
		
		for (Class<?> nextClass : classesToInspect) {
			
			Class<?> loopClass = nextClass;
			while ((loopClass != Object.class) && (!inspectedClasses.contains(loopClass))) {
	
				attachForAnnotations(loopClass);
	
				loopClass = loopClass.getSuperclass();
			}		
		}
	}
255107
@Override
    public String getAttributeName() {
        if (delegate instanceof AttributeDefinitionSpecification) {
            return ((AttributeDefinitionSpecification) delegate).getAttributeName();
        }
        return delegate.getName();
    }
17092
public static String extractAsClassName(Element item, Class<? extends Annotation> annotationClass, AnnotationAttributeType attributeName) {
		final Elements elementUtils=BindDataSourceSubProcessor.elementUtils;
		final One<String> result = new One<String>();

		extractString(elementUtils, item, annotationClass, attributeName, new OnAttributeFoundListener() {

			@Override
			public void onFound(String value) {
				result.value0 = AnnotationUtility.extractAsArrayOfClassName(value).get(0);
			}
		});

		return result.value0;
	}
707175
public static DitaClass getInstance(final Attributes atts) {
        if (atts == null) {
            return null;
        }
        return getInstance(atts.getValue(ATTRIBUTE_NAME_CLASS));
    }
1302182
private Properties parseProperties(AbstractBlock part, String attributeName) {
        Properties properties = new Properties();
        Object attribute = part.getAttributes().get(attributeName);
        if (attribute == null) {
            return properties;
        }
        Scanner propertiesScanner = new Scanner(attribute.toString());
        propertiesScanner.useDelimiter(";");
        while (propertiesScanner.hasNext()) {
            String next = propertiesScanner.next().trim();
            if (next.length() > 0) {
                Scanner propertyScanner = new Scanner(next);
                propertyScanner.useDelimiter("=");
                String key = propertyScanner.next().trim();
                String value = propertyScanner.next().trim();
                properties.setProperty(key, value);
            }
        }
        return properties;
    }
314828
private Set<String> getExcludedAnnotationClassNames(Element element) {
    return getExcludedAnnotationTypes(element)
        .stream()
        .map(MoreTypes::asTypeElement)
        .map(typeElement -> typeElement.getQualifiedName().toString())
        .collect(toSet());
  }
1297262
public <T> T getAttribute(String attrName, Class<T> clazz) {
        Lock lock = lockForRead();
        try {
            return MapUtils.getValue(attributes, attrName, clazz);
        } finally {
            lock.unlock();
        }
    }
482450
public static Set<String> getAttributeNames(
            final Class<?> classToInspect, final Predicate<Field> filter) {
        Set<String> allFields = new HashSet<>();
        getAllAttributes(classToInspect, allFields, FIELD_TO_NAME, filter);
        return allFields;
    }
408609
function getPropertiesAndBindings( root, libs, com, indent ) {
  // Attributes can have post initialization, especially for data bindings.
  var postInit = {};
  var hasPostInit = false;
  var key,
      val,
      values;
  var bindings;
  var slots;
  for ( key in root.attribs ) {
    if ( key.charAt( 0 ) == '$' ) {
      // All the attributes that start with a '$' are used as args attributes.
      val = root.attribs[key];
      com.prop[key.substr( 1 )] = JSON.stringify( val );
    }
    else if ( key.substr( 0, 5 ) == 'intl:' ) {
      // Internationalization.
      val = root.attribs[key];
      com.prop[key.substr( 5 )] = "APP._(" + JSON.stringify( val ) + ")";
    }
    else if ( key.substr( 0, 5 ) == 'bind:' ) {
      // Syntaxe :
      // <bind> := <bind-item> <bind-next>*
      // <bind-next> := "," <bind-item>
      // <bind-item> := <widget-name> <attribute>? <value>?
      // <widget-name> := /[$a-zA-Z_-][$0-9a-zA-Z_-]+/
      // <attribute> := ":" <attrib-name>
      // <attrib-name> := /[$a-zA-Z_-][$0-9a-zA-Z_-]+/
      // <value> := "=" <data>
      // <data> := "true" | "false" | "null" | <number> | <string>
      //
      // @example
      // <wdg:checkbox bind:value="btn1:action" />
      // <wdg:checkbox bind:value="btn1:action, btn2, action=false" />
      if ( typeof postInit[key.substr( 5 )] === 'undefined' ) {
        postInit[key.substr( 5 )] = {};
      }
      postInit[key.substr( 5 )].B = parseBinding(root.attribs[key]);
      hasPostInit = true;
    }
    else if ( key.substr( 0, 5 ) == 'slot:' ) {
      // @example
      // <wdg:button slot:action="removeOrder" />
      // <wdg:button slot:action="removeOrder, changePage" />
      // <wdg:button slot:action="my-module:my-function" />
      values = root.attribs[key].split( "," );
      key = key.substr( 5 );
      if ( typeof postInit[key] === 'undefined' ) {
        postInit[key] = {};
      }
      slots = [ ];
      values.forEach( function( val ) {
        // Before the colon (:) there is the module name. After, there
        // is the function  name. If there is no colon,  `APP` is used
        // as module.
        val = val.split( ':' );
        if ( val.length < 2 ) {
          slots.push(val[0].trim( ));
        } else {
          slots.push(val.map( String.trim ));
          libs.require(val[0]);
        }
      });
      postInit[key].S = slots;
      hasPostInit = true;
    }
    else {
      com.attr[key] = root.attribs[key];
    }
  }

  if ( hasPostInit ) {
    libs.addPostInitJS( "        W.bind('" + com.attr.id + "'," + JSON.stringify( postInit ) + ");" );
  }
}
751608
public int getAttributeAsInt(AnnotationAttributeType attribute) {
		String temp = attributes.get(attribute.getValue());

		return Integer.parseInt(temp);
	}
989600
protected Map<String, Object> getAttributesForComponent(Component component) {

        Map<String, Object> result = Maps.newHashMap();
        if (component instanceof AbstractComponent) {
            AbstractComponent abstractComp = (AbstractComponent)component;
            if (abstractComp.getData() instanceof Map) {
                Map<?, ?> map = (Map<?, ?>)abstractComp.getData();
                for (Map.Entry<?, ?> entry : map.entrySet()) {
                    if (entry.getKey() instanceof String) {
                        result.put((String)(entry.getKey()), entry.getValue());
                    }
                }
            }
        }
        return result;
    }
264551
public final Set<Attribute> getAttributes(final Class<?> _class)
    {
        final Set<Attribute> ret = new HashSet<>();
        for (final Attribute attr : getAttributes().values()) {
            if (attr.getAttributeType().getClassRepr().isAssignableFrom(_class)) {
                ret.add(attr);
            }
        }
        return ret;
    }
458069
@Override
    void findReferencedClassNames(final Set<String> classNameListOut) {
        for (final TypeParameter typeParameter : typeParameters) {
            if (typeParameter != null) {
                typeParameter.findReferencedClassNames(classNameListOut);
            }
        }
        for (final TypeSignature typeSignature : parameterTypeSignatures) {
            if (typeSignature != null) {
                typeSignature.findReferencedClassNames(classNameListOut);
            }
        }
        resultType.findReferencedClassNames(classNameListOut);
        for (final ClassRefOrTypeVariableSignature typeSignature : throwsSignatures) {
            if (typeSignature != null) {
                typeSignature.findReferencedClassNames(classNameListOut);
            }
        }
    }