@Override public final String getType() { return ConfiguredObjectTypeRegistry.getType(_clazz); }
private void validateExchangeDeclareArguments(final Map<String, Object> attributes, final Model model) { final ConfiguredObjectTypeRegistry typeRegistry = model.getTypeRegistry(); final List<ConfiguredObjectAttribute<?, ?>> types = new ArrayList<>(typeRegistry.getAttributeTypes(Exchange.class).values()); typeRegistry.getTypeSpecialisations(Exchange.class).forEach(type -> types.addAll(typeRegistry.getTypeSpecificAttributes(type))); final Set<String> unsupported = attributes.keySet() .stream() .filter(name -> types.stream().noneMatch(a -> Objects.equals(name, a.getName()) && !a.isDerived())) .collect(Collectors.toSet()); if (!unsupported.isEmpty()) { throw new IllegalArgumentException(String.format( "Unsupported exchange declare arguments : %s", String.join(",", unsupported))); } }
public Collection<String> getValidChildTypes(Class<? extends ConfiguredObject> type, Class<? extends ConfiguredObject> childType) { return getValidChildTypes(type, getCategory(childType).getSimpleName()); }
public Collection<ManagedContextDefault> getTypeSpecificContextDependencies(Class<? extends ConfiguredObject> type) { final Collection<ManagedContextDefault> contextDependencies = getContextDependencies(type); contextDependencies.removeAll(getContextDependencies(getCategory(type))); return contextDependencies; } }
private Map<String, Map> processCategory(final Class<? extends ConfiguredObject> clazz, final Model model) { Map<String, Map> typeToDataMap = new TreeMap<>(); ConfiguredObjectTypeRegistry typeRegistry = model.getTypeRegistry(); for (Class<? extends ConfiguredObject> type : typeRegistry.getTypeSpecialisations(clazz)) { typeToDataMap.put(ConfiguredObjectTypeRegistry.getType(type), processType(type, model)); } return typeToDataMap; }
_parent = parent; _category = ConfiguredObjectTypeRegistry.getCategory(getClass()); Class<? extends ConfiguredObject> typeClass = model.getTypeRegistry().getTypeClass(getClass()); _typeClass = typeClass == null ? _category : typeClass; _attributeTypes = model.getTypeRegistry().getAttributeTypes(getClass()); _automatedFields = model.getTypeRegistry().getAutomatedFields(getClass()); _stateChangeMethods = model.getTypeRegistry().getStateChangeMethods(getClass()); _type = ConfiguredObjectTypeRegistry.getType(getClass()); _managesChildStorage = managesChildren(_category) || managesChildren(_typeClass); _bestFitInterface = calculateBestFitInterface();
private ConfiguredObject<?> createProxyForAuthorisation(final Class<? extends ConfiguredObject> category, final Map<String, Object> attributes, final ConfiguredObject<?> parent) { return (ConfiguredObject<?>) Proxy.newProxyInstance(getClass().getClassLoader(), new Class<?>[]{category}, new AuthorisationProxyInvocationHandler(attributes, getTypeRegistry().getAttributeTypes(category), category, parent)); }
private void writeAttributes(final PrintWriter writer, final Class<? extends ConfiguredObject> configuredClass, final Model model, final List<Class<? extends ConfiguredObject>> types) { writer.println("<a name=\"types\"><h2>Attributes</h2></a>"); writer.println("<h2>Common Attributes</h2>"); writeAttributesTable(writer, model.getTypeRegistry().getAttributeTypes(configuredClass).values()); for(Class<? extends ConfiguredObject> type : types) { String typeName = getTypeName(type, model); Collection<ConfiguredObjectAttribute<?, ?>> typeSpecificAttributes = model.getTypeRegistry().getTypeSpecificAttributes(type); if(!typeSpecificAttributes.isEmpty()) { writer.println("<h2><span class=\"type\">"+typeName+"</span> Specific Attributes</h2>"); writeAttributesTable(writer, typeSpecificAttributes); } } }
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; }
private void processAssociations(final ConfiguredObject<?> object) { _associatedOperations.computeIfAbsent(object.getTypeClass(), aClass -> new HashSet<>(_typeRegistry.getOperations(object.getTypeClass(), operation -> operation.isAssociateAsIfChildren() && returnsCollectionOfConfiguredObjects( operation)).values())); for(ConfiguredObjectOperation<?> operation : _associatedOperations.get(object.getTypeClass())) { @SuppressWarnings("unchecked") ConfiguredObjectOperation<ConfiguredObject<?>> configuredObjectOperation = (ConfiguredObjectOperation<ConfiguredObject<?>>) operation; @SuppressWarnings("unchecked") Collection<? extends ConfiguredObject<?>> associatedChildren = (Collection<? extends ConfiguredObject<?>>) configuredObjectOperation.perform(object, Collections.emptyMap()); if (associatedChildren != null && !associatedChildren.isEmpty()) { associatedChildren.forEach(this::processChild); } } }
public ConfiguredObjectFinder(final ConfiguredObject<?> root) { _root = root; _model = root.getModel(); final Class<? extends ConfiguredObject> managedCategory = root.getCategoryClass(); addManagedHierarchies(managedCategory, managedCategory); for (ConfiguredObjectOperation operation : _model.getTypeRegistry().getOperations(managedCategory).values()) { if (operation.isAssociateAsIfChildren() && returnsCollectionOfConfiguredObjects(operation)) { Class<? extends ConfiguredObject> associatedChildCategory = (getCollectionMemberType((ParameterizedType) operation.getGenericReturnType())); _associatedChildrenOperations.put(associatedChildCategory, operation); addManagedHierarchies(associatedChildCategory, associatedChildCategory); } } }
|| categoriesRestriction.contains(getCategory(configuredObjectClass))) process(configuredObjectClass); ManagedObject annotation = configuredObjectClass.getAnnotation(ManagedObject.class); if (annotation.category()) Class<? extends ConfiguredObject> category = getCategory(configuredObjectClass); if (category != null) if (ModelRoot.class.isAssignableFrom(categoryClass) || factoryExists(categoryClass, annotationType)) if (!"".equals(validChildren)) Method validChildTypesMethod = getValidChildTypesFunction(validChildren, type); if (validChildTypesMethod != null) validateContextDependencies();
@Override public final Class<? super X> getCategoryClass() { return (Class<? super X>) ConfiguredObjectTypeRegistry.getCategory(_clazz); }
.getTypeRegistry().getTypeSpecialisations(configuredClass)); _typeSpecialisations.putIfAbsent(configuredClass, types);
public Map<String, ConfiguredObjectOperation<?>> getOperations(final Class<? extends ConfiguredObject> clazz) { return getOperations(clazz, null); }
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 void writeStatistics(final PrintWriter writer, final Class<? extends ConfiguredObject> configuredClass, final Model model, final List<Class<? extends ConfiguredObject>> types) { writer.println("<a name=\"types\"><h2>Statistics</h2></a>"); writer.println("<h2>Common Statistics</h2>"); writeStatisticsTable(writer, model.getTypeRegistry().getStatistics(configuredClass)); for(Class<? extends ConfiguredObject> type : types) { String typeName = getTypeName(type, model); Collection<ConfiguredObjectStatistic<?, ?>> typeSpecificStatistics = model.getTypeRegistry().getTypeSpecificStatistics(type); if(!typeSpecificStatistics.isEmpty()) { writer.println("<h2><span class=\"type\">"+typeName+"</span> Specific Statistics</h2>"); writeStatisticsTable(writer, typeSpecificStatistics); } } }
private void writeContext(final PrintWriter writer, final Class<? extends ConfiguredObject> configuredClass, final Model model, final List<Class<? extends ConfiguredObject>> types) { writer.println("<a name=\"types\"><h2>Context Variables</h2></a>"); writer.println("<h2>Common Context Variables</h2>"); Collection<ManagedContextDefault> defaultContexts = model.getTypeRegistry().getContextDependencies(configuredClass); writeContextDefaults(writer, defaultContexts); for(Class<? extends ConfiguredObject> type : types) { String typeName = getTypeName(type, model); Collection<ManagedContextDefault> typeSpecificDefaults = model.getTypeRegistry().getTypeSpecificContextDependencies(type); if(!typeSpecificDefaults.isEmpty() && type != configuredClass) { writer.println("<h2><span class=\"type\">"+typeName+"</span> Specific Context Variables</h2>"); writeContextDefaults(writer, typeSpecificDefaults); } } }
public static boolean returnsCollectionOfConfiguredObjects(ConfiguredObjectOperation operation) { return Collection.class.isAssignableFrom(operation.getReturnType()) && operation.getGenericReturnType() instanceof ParameterizedType && ConfiguredObject.class.isAssignableFrom(getCollectionMemberType((ParameterizedType) operation.getGenericReturnType())); }
@Override public Set<String> getContextKeys(final boolean excludeSystem) { Map<String,String> inheritedContext = new HashMap<>(getTypeRegistry().getDefaultContext()); if(!excludeSystem) { inheritedContext.putAll(System.getenv()); inheritedContext.putAll((Map) System.getProperties()); } generateInheritedContext(getModel(), this, inheritedContext); return Collections.unmodifiableSet(inheritedContext.keySet()); }