/** * Delegates to @see {@link #getResourceHandler(Class)} */ @SuppressWarnings("unchecked") protected DelegatingResourceHandler<? extends T> getResourceHandler(T delegate) { if (!hasTypesDefined()) return this; if (delegate == null) return null; return getResourceHandler((Class<? extends T>) delegate.getClass()); }
/** * @param clazz * @return a subclass handler if any is suitable for the given class, or this resource itself if * no subclass handler works */ protected DelegatingResourceHandler<? extends T> getResourceHandler(Class<? extends T> clazz) { if (!hasTypesDefined()) return this; DelegatingResourceHandler<? extends T> handler = getSubclassHandler(clazz); if (handler != null) return handler; return this; }
/** * @param type user-friendly type name * @return a subclass handler if any is suitable for type, or this resource itself if it is * suitable */ protected DelegatingResourceHandler<? extends T> getResourceHandler(String type) { if (type == null || !hasTypesDefined()) return this; DelegatingSubclassHandler<T, ? extends T> handler = getSubclassHandler(type); if (handler != null) return handler; if (getResourceName().endsWith(type)) return this; throw new IllegalArgumentException("type=" + type + " is not handled by this resource (" + getClass() + ") or any subclass"); }
/** * @param type the user-friendly name of a registered subclass handler * @return the handler for the given user-friendly type name */ protected DelegatingSubclassHandler<T, ? extends T> getSubclassHandler(String type) { if (hasTypesDefined()) { if (subclassHandlers == null) { init(); } for (DelegatingSubclassHandler<T, ? extends T> handler : subclassHandlers) { if (type.equals(handler.getTypeName())) return handler; } } return null; }
/** * If this resource supports subclasses, then we add a type property to the input, and return it * * @param simple simplified representation which will be decorated with the user-friendly type * name * @param delegate the object that simple represents */ private void maybeDecorateWithType(SimpleObject simple, T delegate) { if (hasTypesDefined()) simple.add(RestConstants.PROPERTY_FOR_TYPE, getTypeName(delegate)); }
/** * @see org.openmrs.module.webservices.rest.web.resource.api.Converter#newInstance(java.lang.String) */ @Override public T newInstance(String type) { if (hasTypesDefined()) { if (type == null) throw new IllegalArgumentException(getClass().getSimpleName() + " requires a '" + RestConstants.PROPERTY_FOR_TYPE + "' property to create a new object"); DelegatingResourceHandler<? extends T> handler = getResourceHandler(type); return handler.newDelegate(); } else { return newDelegate(); } }
/** * @param subclass * @return the handler most appropriate for the given subclass, or null if none is suitable */ protected DelegatingSubclassHandler<T, ? extends T> getSubclassHandler(Class<? extends T> subclass) { if (subclassHandlers == null) { init(); } if (!hasTypesDefined()) return null; // look for an exact match for (DelegatingSubclassHandler<T, ? extends T> handler : subclassHandlers) { Class<? extends T> subclassHandled = handler.getSubclassHandled(); if (subclass.equals(subclassHandled)) return handler; } // TODO should we recurse to subclass's superclass, e.g. so DrugOrderHandler can handle HivDrugOrder if no handler is defined? // didn't find anything suitable return null; }
/** * If this resources supports subclasses, this method gets the user-friendly type name for the * given subclass * * @param subclass * @return */ protected String getTypeName(Class<? extends T> subclass) { if (hasTypesDefined()) { DelegatingSubclassHandler<T, ? extends T> handler = getSubclassHandler(subclass); if (handler != null) return handler.getTypeName(); if (newDelegate().getClass().equals(subclass)) { String resourceName = getResourceName(); int lastSlash = resourceName.lastIndexOf("/"); resourceName = resourceName.substring(lastSlash + 1); return resourceName; } } return null; }
.description(resourceName + " response") .schema(new RefProperty("#/definitions/FetchAll"))); if (((BaseDelegatingResource<?>) resourceHandler).hasTypesDefined()) { operation.parameter(subclassTypeParameter);
operation.setParameters(buildPagingParameters()); operation.parameter(v); if (((BaseDelegatingResource<?>) resourceHandler).hasTypesDefined()) { operation.parameter(subclassTypeParameter);