@Override public final Class<? super X> getCategoryClass() { return (Class<? super X>) ConfiguredObjectTypeRegistry.getCategory(_clazz); }
@Override public final <C extends ConfiguredObject> C getChildByName(final Class<C> clazz, final String name) { Class<? extends ConfiguredObject> categoryClass = ConfiguredObjectTypeRegistry.getCategory(clazz); return (C) _childrenByName.get(categoryClass).get(name); }
@Override public final <C extends ConfiguredObject> C getChildById(final Class<C> clazz, final UUID id) { return (C) _childrenById.get(ConfiguredObjectTypeRegistry.getCategory(clazz)).get(id); }
public Class<? extends ConfiguredObject>[] getHierarchy(final Class<? extends ConfiguredObject> category) { List<Class<? extends ConfiguredObject>> hierarchy = _hierarchies.get(ConfiguredObjectTypeRegistry.getCategory(category)); return hierarchy == null ? null : hierarchy.toArray(new Class[hierarchy.size()]); }
public Collection<Class<? extends ConfiguredObject>> getTypeSpecialisations(Class<? extends ConfiguredObject> clazz) { Class<? extends ConfiguredObject> categoryClass = getCategory(clazz); if (categoryClass == null) { throw new IllegalArgumentException("Cannot locate ManagedObject information for " + clazz.getName()); } Set<Class<? extends ConfiguredObject>> classes = _knownTypes.get(categoryClass); if (classes == null) { classes = (Set<Class<? extends ConfiguredObject>>) ((Set) Collections.singleton(clazz)); } return Collections.unmodifiableCollection(classes); }
public Collection<String> getValidChildTypes(Class<? extends ConfiguredObject> type, Class<? extends ConfiguredObject> childType) { return getValidChildTypes(type, getCategory(childType).getSimpleName()); }
private static Class<? extends ConfiguredObject> calculateCategory(final Class<?> clazz) { ManagedObject annotation = clazz.getAnnotation(ManagedObject.class); if (annotation != null && annotation.category()) { return (Class<? extends ConfiguredObject>) clazz; } for (Class<?> iface : clazz.getInterfaces()) { Class<? extends ConfiguredObject> cat = getCategory(iface); if (cat != null) { return cat; } } if (clazz.getSuperclass() != null) { return getCategory(clazz.getSuperclass()); } return null; }
public Collection<ManagedContextDefault> getTypeSpecificContextDependencies(Class<? extends ConfiguredObject> type) { final Collection<ManagedContextDefault> contextDependencies = getContextDependencies(type); contextDependencies.removeAll(getContextDependencies(getCategory(type))); return contextDependencies; } }
public static String getType(final Class<? extends ConfiguredObject> clazz) { String type = getActualType(clazz); if ("".equals(type)) { Class<? extends ConfiguredObject> category = getCategory(clazz); if (category == null) { throw new IllegalArgumentException("No category for " + clazz.getSimpleName()); } ManagedObject annotation = category.getAnnotation(ManagedObject.class); if (annotation == null) { throw new NullPointerException("No definition found for category " + category.getSimpleName()); } if (!"".equals(annotation.defaultType())) { type = annotation.defaultType(); } else { type = category.getSimpleName(); } } return type; }
private Map<String, Collection<String>> getValidChildTypes(final Class<? extends ConfiguredObject> type, final Model model) { Map<String, Collection<String>> validChildTypes = new HashMap<>(); for (Class<? extends ConfiguredObject> childType : model.getChildTypes(ConfiguredObjectTypeRegistry.getCategory( type))) { Collection<String> validValues = model.getTypeRegistry().getValidChildTypes(type, childType); if (validValues != null) { validChildTypes.put(childType.getSimpleName(), validValues); } } return validChildTypes; }
public Class<? extends ConfiguredObject> getTypeClass(final Class<? extends ConfiguredObject> clazz) { String typeName = getType(clazz); Class<? extends ConfiguredObject> typeClass = null; if (typeName != null) { Class<? extends ConfiguredObject> category = getCategory(clazz); Set<Class<? extends ConfiguredObject>> types = _knownTypes.get(category); if (types != null) { for (Class<? extends ConfiguredObject> type : types) { ManagedObject annotation = type.getAnnotation(ManagedObject.class); if (typeName.equals(annotation.type())) { typeClass = type; break; } } } if (typeClass == null) { if (typeName.equals(category.getSimpleName())) { typeClass = category; } } } return typeClass; }
<X extends ConfiguredObject<X>> Collection<X> getReachableObjects(final ConfiguredObject<?> object, final Class<X> clazz) { Class<? extends ConfiguredObject> category = ConfiguredObjectTypeRegistry.getCategory(object.getClass()); Class<? extends ConfiguredObject> ancestorClass = getAncestorClassWithGivenDescendant(category, clazz); if(ancestorClass != null) { ConfiguredObject ancestor = getAncestor(ancestorClass, category, object); if(ancestor != null) { return getAllDescendants(ancestor, ancestorClass, clazz); } } return null; }
|| categoriesRestriction.contains(getCategory(configuredObjectClass))) Class<? extends ConfiguredObject> category = getCategory(configuredObjectClass); if (category != null)
_parent = parent; _category = ConfiguredObjectTypeRegistry.getCategory(getClass()); Class<? extends ConfiguredObject> typeClass = model.getTypeRegistry().getTypeClass(getClass()); _typeClass = typeClass == null ? _category : typeClass;