@Override public boolean apply(@Nullable Entity input) { if (input == null) return false; for (Class<?> cls : Reflections.getAllInterfaces(input.getClass())) { if (pattern.matcher(cls.getName()).matches()) { return true; } } return false; } }
@VisibleForTesting public <T extends Entity> T createEntityProxy(EntitySpec<T> spec, T entity) { Set<Class<?>> interfaces = Sets.newLinkedHashSet(); if (spec.getType().isInterface()) { interfaces.add(spec.getType()); } else { log.warn("EntitySpec declared in terms of concrete type "+spec.getType()+"; should be supplied in terms of interface"); interfaces.addAll(Reflections.getAllInterfaces(spec.getType())); } interfaces.addAll(spec.getAdditionalInterfaces()); return createEntityProxy(interfaces, entity); }
@Test public void testGetAllInterfaces() throws Exception { Assert.assertEquals(Reflections.getAllInterfaces(A.class), ImmutableList.of(I.class)); Assert.assertEquals(Reflections.getAllInterfaces(B.class), ImmutableList.of(L.class, I.class)); Assert.assertEquals(Reflections.getAllInterfaces(C.class), ImmutableList.of(M.class, K.class, I.class, J.class, L.class)); }
private static Maybe<Method> tryFindAccessibleEquivalent(Method method) { Class<?> clazz = method.getDeclaringClass(); for (Class<?> interf : Reflections.getAllInterfaces(clazz)) { Maybe<Method> altMethod = tryFindAccessibleMethod(interf, method.getName(), method.getParameterTypes()); if (altMethod.isPresent()) { return altMethod; } } Class<?> superClazz = clazz.getSuperclass(); while (superClazz != null) { Maybe<Method> altMethod = tryFindAccessibleMethod(superClazz, method.getName(), method.getParameterTypes()); if (altMethod.isPresent()) { return altMethod; } superClazz = superClazz.getSuperclass(); } return Maybe.absent(); }
private static Set<Object> makeTags(EntitySpec<?> spec, Set<Object> tags) { // Combine tags on item with an InterfacesTag. if (spec != null) { Class<?> type; if (spec.getImplementation() != null) { type = spec.getImplementation(); } else { type = spec.getType(); } if (type != null) { tags.add(new BrooklynTags.TraitsTag(Reflections.getAllInterfaces(type))); } } return tags; }
return EntitySpec.create(Application.class) .impl((Class<? extends Application>) clazz) .additionalInterfaces(Reflections.getAllInterfaces(clazz)); childSpec = EntitySpec.create(Entity.class) .impl((Class<? extends Application>) clazz) .additionalInterfaces(Reflections.getAllInterfaces(clazz));
private EntitySpec<?> resolveInternal(String localType, BrooklynClassLoadingContext loader) { Maybe<Class<? extends Entity>> javaTypeMaybe = tryLoadJavaType(localType, loader); if (javaTypeMaybe.isAbsent()) throw new IllegalStateException("Could not find "+localType, Maybe.getException(javaTypeMaybe)); Class<? extends Entity> javaType = javaTypeMaybe.get(); EntitySpec<? extends Entity> spec; if (javaType.isInterface()) { spec = EntitySpec.create(javaType); } else { // If this is a concrete class, particularly for an Application class, we want the proxy // to expose all interfaces it implements. Class<? extends Entity> interfaceclazz = (Application.class.isAssignableFrom(javaType)) ? Application.class : Entity.class; List<Class<?>> additionalInterfaceClazzes = Reflections.getAllInterfaces(javaType); @SuppressWarnings({ "rawtypes", "unchecked" }) EntitySpec<?> rawSpec = EntitySpec.create(interfaceclazz) .impl((Class) javaType) .additionalInterfaces(additionalInterfaceClazzes); spec = rawSpec; } spec.stackCatalogItemId(CatalogUtils.getCatalogItemIdFromLoader(loader)); return spec; }
entity = entityFactory.constructEntity(entityClazz, Reflections.getAllInterfaces(entityClazz), entityId);
private org.apache.brooklyn.api.entity.EntitySpec<? extends Entity> toCoreEntitySpec(org.apache.brooklyn.rest.domain.EntitySpec spec) { String type = spec.getType(); String name = spec.getName(); Map<String, String> config = (spec.getConfig() == null) ? Maps.<String,String>newLinkedHashMap() : Maps.newLinkedHashMap(spec.getConfig()); FindItemAndClass itemAndClass = new FindItemAndClass().inferFrom(type); final Class<? extends Entity> clazz = itemAndClass.clazz; org.apache.brooklyn.api.entity.EntitySpec<? extends Entity> result; if (clazz.isInterface()) { result = org.apache.brooklyn.api.entity.EntitySpec.create(clazz); } else { result = org.apache.brooklyn.api.entity.EntitySpec.create(Entity.class).impl(clazz).additionalInterfaces(Reflections.getAllInterfaces(clazz)); } result.catalogItemId(itemAndClass.catalogItemId); if (!Strings.isEmpty(name)) result.displayName(name); result.configure( convertFlagsToKeys(result.getType(), config) ); configureRenderingMetadata(spec, result); return result; }