void withTransitiveFrom(final Module module) { withAdditionalModules(asClasses(Module.Util.transitiveDependenciesOf(module))); withAdditionalModules(Module.Util.transitiveAdditionalModulesOf(module)); withAdditionalServices(Module.Util.transitiveAdditionalServicesOf(module)); withConfigurationPropertyResources(Module.Util.transitivePropertyResourcesOf(module)); withConfigurationProperties(Module.Util.transitiveIndividualConfigPropsOf(module)); }
/** * Convenience method that delegates to {@link DomainObjectContainer}. * * @see DomainObjectContainer#firstMatch(Class, String) */ protected <T> T firstMatch(final Class<T> ofType, final String title) { return getContainer().firstMatch(ofType, title); }
/** * Convenience method that delegates to {@link DomainObjectContainer}. * * @see DomainObjectContainer#uniqueMatch(Class, String) */ protected <T> T uniqueMatch(final Class<T> ofType, final String title) { return getContainer().uniqueMatch(ofType, title); }
/** * Convenience method that delegates to {@link DomainObjectContainer}. * * @see DomainObjectContainer#allMatches(Class, Filter) */ protected <T> List<T> allMatches(final Class<T> ofType, final Filter<? super T> filter) { return getContainer().allMatches(ofType, filter); }
/** * Convenience method that delegates to {@link DomainObjectContainer}. * * @see DomainObjectContainer#allInstances(Class) */ protected <T> List<T> allInstances(final Class<T> ofType) { return getContainer().allInstances(ofType); }
/** * Display the specified message to the user, in a non-intrusive fashion. */ protected void informUser(final String message) { getContainer().informUser(message); }
/** * Display the specified message as a warning to the user, in a more visible * fashion, but without requiring explicit acknowledgement. */ protected void warnUser(final String message) { getContainer().warnUser(message); }
/** * Convenience methods that delegates to {@link DomainObjectContainer}. * * @see DomainObjectContainer#isValid(Object) */ protected boolean isValid(final Object domainObject) { return getContainer().isValid(domainObject); }
/** * Convenience methods that delegates to {@link DomainObjectContainer}. * * @see DomainObjectContainer#validate(Object) */ protected String validate(final Object domainObject) { return getContainer().validate(domainObject); }
/** * Delete the provided object from the persistent object store. */ protected void remove(final Object persistentDomainObject) { getContainer().remove(persistentDomainObject); }
/** * Returns a new instance of the specified class that has the sane persisted * state as the specified object. * * <p> * This method isn't quite deprecated, but generally consider using * {@link #newTransientInstance(Class)} instead. */ protected <T> T newInstance(final Class<T> ofClass, final Object object) { return getContainer().newInstance(ofClass, object); } // }}
/** * Convenience method that delegates to {@link DomainObjectContainer}. * * @see DomainObjectContainer#allMatches(Class, String) */ protected <T> List<T> allMatches(final Class<T> ofType, final String title) { return getContainer().allMatches(ofType, title); }
/** * Convenience method that delegates to {@link DomainObjectContainer}. * * @see DomainObjectContainer#firstMatch(Class, Filter) */ protected <T> T firstMatch(final Class<T> ofType, final Filter<T> filter) { return getContainer().firstMatch(ofType, filter); }
/** * Convenience method that delegates to {@link DomainObjectContainer}. * * @see DomainObjectContainer#uniqueMatch(Class, Object) */ protected <T> T uniqueMatch(final Class<T> ofType, final T pattern) { return getContainer().uniqueMatch(ofType, pattern); }
/** * Convenience method that delegates to {@link DomainObjectContainer}. * * @see DomainObjectContainer#allMatches(Query) */ protected <T> List<T> allMatches(final Query<T> query) { return getContainer().allMatches(query); }
/** * Convenience method that delegates to {@link DomainObjectContainer}. * * @see DomainObjectContainer#firstMatch(Class, Object) */ protected <T> T firstMatch(final Class<T> ofType, final T pattern) { return getContainer().firstMatch(ofType, pattern); }
/** * Convenience method that delegates to {@link DomainObjectContainer}. * * @see DomainObjectContainer#uniqueMatch(Query) */ protected <T> T uniqueMatch(final Query<T> query) { return getContainer().uniqueMatch(query); }
/** * Convenience method that delegates to {@link DomainObjectContainer}. * * @see DomainObjectContainer#allMatches(Class, Object) */ protected <T> List<T> allMatches(final Class<T> ofType, final T pattern) { return getContainer().allMatches(ofType, pattern); }
/** * Convenience method that delegates to {@link DomainObjectContainer}. * * @see DomainObjectContainer#firstMatch(Query) */ protected <T> T firstMatch(final Query<T> query) { return getContainer().firstMatch(query); }
/** * Convenience method that delegates to {@link DomainObjectContainer}. * * @see DomainObjectContainer#uniqueMatch(Class, Filter) */ protected <T> T uniqueMatch(final Class<T> ofType, final Filter<T> filter) { return getContainer().uniqueMatch(ofType, filter); }