/** Finds and invokes a suitable constructor, supporting varargs and primitives, boxing and looking at compatible supertypes in the constructor's signature */ public static <T> Maybe<T> invokeConstructorFromArgs(Class<? extends T> clazz, Object...argsArray) { return invokeConstructorFromArgs(clazz, argsArray, false); }
/** @deprecated since 0.11.0, use {@link org.apache.brooklyn.util.core.ClassLoaderUtils} in a combination with {@link #invokeConstructorFromArgs(Class, Object...)} instead */ public static Maybe<Object> invokeConstructorFromArgs(ClassLoader classLoader, String className, Object...argsArray) { return invokeConstructorFromArgs(classLoader, null, className, argsArray); }
/** @deprecated since 0.10.0 use {@link #invokeConstructorFromArgs(Class, Object...)} or one of the variants */ @Deprecated public static <T> Optional<T> invokeConstructorWithArgs(Class<? extends T> clazz, Object...argsArray) { return Reflections.<T>invokeConstructorFromArgs(clazz, argsArray).toOptional(); } /** @deprecated since 0.10.0 use {@link #invokeConstructorFromArgs(Class, Object...)} or one of the variants */ @Deprecated
/** As {@link #invokeConstructorFromArgs(Class, Object...)} but allowing more configurable input; * in particular setAccessible allows private constructors to be used (not the default) */ public static <T> Maybe<T> invokeConstructorFromArgs(ClassLoader classLoader, Class<T> clazz, Object[] argsArray, boolean setAccessible) { Reflections reflections = new Reflections(classLoader); return invokeConstructorFromArgs(reflections, clazz, argsArray, setAccessible); }
/** As {@link #invokeConstructorFromArgs(Class, Object...)} but will use private constructors (with setAccessible = true) */ public static <T> Maybe<T> invokeConstructorFromArgsIncludingPrivate(Class<? extends T> clazz, Object ...argsArray) { return Reflections.invokeConstructorFromArgs(new Reflections(clazz.getClassLoader()), clazz, argsArray, true); } /** As {@link #invokeConstructorFromArgs(Class, Object...)} but allowing more configurable input;
/** @deprecated since 0.10.0 use {@link #invokeConstructorFromArgs(Class, Object...)} or one of the variants */ @Deprecated public static <T> Optional<T> invokeConstructorWithArgs(Class<? extends T> clazz, Object[] argsArray, boolean setAccessible) { return Reflections.<T>invokeConstructorFromArgs(clazz, argsArray, setAccessible).toOptional(); } /** @deprecated since 0.10.0 use {@link #invokeConstructorFromArgs(Class, Object...)} or one of the variants */ @Deprecated
/** As {@link #invokeConstructorFromArgs(Class, Object...)} but allowing more configurable input; * in particular setAccessible allows private constructors to be used (not the default) */ public static <T> Maybe<T> invokeConstructorFromArgs(Class<? extends T> clazz, Object[] argsArray, boolean setAccessible) { Reflections reflections = new Reflections(clazz.getClassLoader()); return invokeConstructorFromArgs(reflections, clazz, argsArray, setAccessible); }
/** @deprecated since 0.10.0 use {@link #invokeConstructorFromArgs(Class, Object...)} or one of the variants */ @Deprecated public static <T> Optional<T> invokeConstructorWithArgs(Reflections reflections, Class<? extends T> clazz, Object[] argsArray, boolean setAccessible) { return Reflections.<T>invokeConstructorFromArgs(reflections, clazz, argsArray, setAccessible).toOptional(); }
/** @deprecated since 0.10.0 use {@link #invokeConstructorFromArgs(Class, Object...)} or one of the variants */ @Deprecated public static <T> Optional<T> invokeConstructorWithArgs(ClassLoader classLoader, Class<T> clazz, Object[] argsArray, boolean setAccessible) { return invokeConstructorFromArgs(classLoader, clazz, argsArray, setAccessible).toOptional(); } /** @deprecated since 0.10.0 use {@link #invokeConstructorFromArgs(Class, Object...)} or one of the variants */ @Deprecated
@Override public ZoneFailureDetector apply(final String input) { ClassLoader classLoader = ZoneFailureDetector.class.getClassLoader(); Maybe<ZoneFailureDetector> detector = Reflections.invokeConstructorFromArgs(classLoader, ZoneFailureDetector.class, input); if (detector.isPresent()) { return detector.get(); } else { throw new IllegalStateException("Failed to create ZoneFailureDetector "+input); } } });
@Override public NodePlacementStrategy apply(final String input) { ClassLoader classLoader = NodePlacementStrategy.class.getClassLoader(); Maybe<NodePlacementStrategy> strategy = Reflections.invokeConstructorFromArgs(classLoader, NodePlacementStrategy.class, input); if (strategy.isPresent()) { return strategy.get(); } else { throw new IllegalStateException("Failed to create NodePlacementStrategy "+input); } } });
@Override public T get() { String msg = message==null ? null : message.get(); Maybe<T> result = Maybe.absent(); if (result.isAbsent() && msg==null && cause==null) result = Reflections.invokeConstructorFromArgs(type); if (result.isAbsent() && cause==null) result = Reflections.invokeConstructorFromArgs(type, msg); if (result.isAbsent() && msg==null) result = Reflections.invokeConstructorFromArgs(type, cause); if (result.isAbsent()) result = Reflections.invokeConstructorFromArgs(type, msg, cause); if (result.isAbsent()) { throw new IllegalStateException("Cannot create desired "+type+" (missing constructor)", new IllegalStateException(message==null ? null : message.get(), cause)); } return result.get(); }
/** @deprecated since 0.11.0, use {@link org.apache.brooklyn.util.core.ClassLoaderUtils} in a combination with {@link #invokeConstructorFromArgs(Class, Object...)} instead */ public static <T> Maybe<T> invokeConstructorFromArgsUntyped(ClassLoader classLoader, String className, Object...argsArray) { Reflections reflections = new Reflections(classLoader); @SuppressWarnings("unchecked") Class<T> clazz = (Class<T>)reflections.loadClass(className); return invokeConstructorFromArgs(reflections, clazz, argsArray, false); }
/** @deprecated since 0.11.0, use {@link org.apache.brooklyn.util.core.ClassLoaderUtils} in a combination with {@link #invokeConstructorFromArgs(Class, Object...)} instead */ public Object loadInstance(String classname, Object...argValues) throws ReflectionNotFoundException, ReflectionAccessException { Class<?> clazz = loadClass(classname); Maybe<?> v = null; try { v = invokeConstructorFromArgs(clazz, argValues); if (v.isPresent()) return v.get(); } catch (Exception e) { throw new IllegalStateException("Error invoking constructor for "+clazz+Arrays.toString(argValues) + ": " + Exceptions.collapseText(e)); } throw new IllegalStateException("No suitable constructor for "+clazz+Arrays.toString(argValues)); } /** @deprecated since 0.11.0, use {@link org.apache.brooklyn.util.core.ClassLoaderUtils} in a combination with {@link #invokeConstructorFromArgs(Class, Object...)} instead */
/** @deprecated since 0.11.0, use {@link org.apache.brooklyn.util.core.ClassLoaderUtils} in a combination with {@link #invokeConstructorFromArgs(Class, Object...)} instead */ @SuppressWarnings("unchecked") public static <T> Maybe<T> invokeConstructorFromArgs(ClassLoader classLoader, Class<T> optionalSupertype, String className, Object...argsArray) { Reflections reflections = new Reflections(classLoader); Class<?> clazz = reflections.loadClass(className); if (optionalSupertype!=null && !optionalSupertype.isAssignableFrom(clazz)) { return Maybe.absent("The type requested '"+className+"' is not assignable to "+optionalSupertype); } return invokeConstructorFromArgs(reflections, (Class<T>)clazz, argsArray, false); }
private static Object instantiate(Class<?> clazz, List<Object[]> constructorArgOptions) { try { for (Object[] constructorArgOption : constructorArgOptions) { Maybe<?> result = Reflections.invokeConstructorFromArgs(clazz, constructorArgOption); if (result.isPresent()) return result.get(); } } catch (Exception e) { throw Exceptions.propagate(e); } throw new IllegalStateException("No matching constructor to instantiate "+clazz); } }
@Test public void testConstruction() throws Exception { Assert.assertEquals(Reflections.invokeConstructorFromArgs(CI1.class, new Object[] {"hello", 3}).get().constructorArgs, ImmutableList.of("hello", 3)); Assert.assertEquals(Reflections.invokeConstructorFromArgs(CI1.class, new Object[] {"hello", 3, 4, 5}).get().constructorArgs, ImmutableList.of("hello", 3, 4, 5)); Assert.assertFalse(Reflections.invokeConstructorFromArgs(CI1.class, new Object[] {"wrong", "args"}).isPresent()); }
@Test public void testConstructLangObject() { // special test for this because the lang object might have classloader null Assert.assertTrue(Reflections.invokeConstructorFromArgs(java.util.Date.class).get() instanceof java.util.Date); }
protected <T> T constructOldStyle(Class<T> clazz, Map<String,?> flags) throws InstantiationException, IllegalAccessException, InvocationTargetException { FactoryConstructionTracker.setConstructing(); Maybe<T> v; try { v = Reflections.invokeConstructorFromArgs(clazz, new Object[] {MutableMap.copyOf(flags)}, true); } finally { FactoryConstructionTracker.reset(); } if (v.isPresent()) { return v.get(); } else { throw new IllegalStateException("No valid constructor defined for "+clazz+" (expected no-arg or single java.util.Map argument)"); } } }
private Object newOsgiSimpleObject(String val) throws Exception { Class<?> osgiObjectClazz = getBundle(mgmt(), OSGI_BUNDLE_SYMBOLIC_NAME).loadClass(OSGI_OBJECT_TYPE); return Reflections.invokeConstructorFromArgs(osgiObjectClazz, val).get(); }