docs: @SuppressWarnings("unchecked")
  	public synchronized <T> void install(Class<T> component) {
  		Preconditions.checkArgument(component != null, 
  				"Parameter 'component' must not be [" + component + "]");
  		
  		if (installed(component)) {
  			logger.debug("Installation ignored: Component [" + component + "] has already been installed");
  			return;
  		}
  		
  		int modifiers = component.getModifiers();
  		
  		if (component.isInterface() || Modifier.isAbstract(modifiers) || !Modifier.isPublic(modifiers)) {
  			logger.warn("Interface, abstract and non-public class cannot be installed: " 
  					+ "Component [" + component + "]");
  			return;
  		}
  		
  		try {
  			Descriptor<T> descriptor = new Descriptor<T>(component);
  			List<Class<?>> classes = Collections.emptyList();
  			
  			if (Provider.class.isAssignableFrom(component)) {
  				for (Type type : component.getGenericInterfaces()) {
  					if ((type instanceof ParameterizedType) && ((ParameterizedType) type).getRawType().equals(Provider.class)) {
  						Type t = ((ParameterizedType) type).getActualTypeArguments()[0];
  						Class<?> clazz = (Class<?>) ((t instanceof ParameterizedType) ? ((ParameterizedType) t).getRawType() : t);
  						classes = (List<Class<?>>) ClassUtils.getAllInterfaces(clazz);
  						classes.addAll(ClassUtils.getAllSuperclasses(clazz));
  						classes.add(clazz);
  					}
  				}
  				
  			} else {
  				classes = (List<Class<?>>) ClassUtils.getAllInterfaces(component);
  				classes.addAll(ClassUtils.getAllSuperclasses(component));
  				classes.add(component);
  			}
  			
  			classes.remove(Object.class);
  			ListMultimap<Class<?>, Descriptor<?>> components = ArrayListMultimap.create();
  			
  			for (Class<?> type : classes) {
  				components.put(type, descriptor);
  			}
  			
  			ListMultimap<Annotation, Descriptor<?>> pointcuts = ArrayListMultimap.create();
  			
  			if (descriptor.aspect()) {
  				for (Annotation pointcut : descriptor.pointcuts()) {
  					pointcuts.put(pointcut, descriptor);
  				}
  			}
  			
  			Annotation scope = descriptor.scope();
  			Class<? extends Annotation> s = (scope == null) ? Prototype.class : scope.annotationType();
  			
  			if (s.equals(Singleton.class) && ((Singleton) descriptor.scope()).eager()) {
  				component(descriptor);
  			}
  			
  			installed.add(component);
  			this.components.putAll(components);
  			this.pointcuts.putAll(pointcuts);
  			logger.info("Component has been installed: Provider descriptor [" + descriptor + "]");
  		} catch (Exception e) {
  			logger.warn("Component cannot be installed: Provider type [" + component + "]", e);
  			return;
  		}
  	}