/** * Convert {@code Object} value to a value of the specified class type. * * @param value {@code Object} value to convert. * @param type conversion type. * @param <T> converted value type. * @return value converted to the specified class type. */ public static <T> T convertValue(Object value, Class<T> type) { if (!type.isInstance(value)) { // TODO: Move string value readers from server to common and utilize them here final Constructor constructor = AccessController.doPrivileged(ReflectionHelper.getStringConstructorPA(type)); if (constructor != null) { try { return type.cast(constructor.newInstance(value)); } catch (Exception e) { // calling the constructor wasn't successful - ignore and try valueOf() } } final Method valueOf = AccessController.doPrivileged(ReflectionHelper.getValueOfStringMethodPA(type)); if (valueOf != null) { try { return type.cast(valueOf.invoke(null, value)); } catch (Exception e) { // calling valueOf wasn't successful } } // at this point we don't know what to return -> return null if (LOGGER.isLoggable(Level.WARNING)) { LOGGER.warning( LocalizationMessages.PROPERTIES_HELPER_GET_VALUE_NO_TRANSFORM( String.valueOf(value), value.getClass().getName(), type.getName())); } return null; } return type.cast(value); }
@Override public void enrich(final SearchContext searchContext, Object target) { Collection<Field> fields = ReflectionHelper.getFieldsWithAnnotation(target.getClass(), JavaScript.class); for (Field field : fields) { GrapheneContext grapheneContext = searchContext == null ? null : ((GrapheneProxyInstance) searchContext).getGrapheneContext(); if (grapheneContext == null) { grapheneContext = GrapheneContext.getContextFor(ReflectionHelper.getQualifier(field.getAnnotations())); } if (!field.isAccessible()) { field.setAccessible(true); } try { field.set(target, JSInterfaceFactory.create(grapheneContext, field.getType())); } catch (Exception e) { throw new IllegalStateException( "Can't inject value to the field '" + field.getName() + "' declared in class '" + field.getDeclaringClass().getName() + "'", e); } } }
private static Activity verifyActivity(Context context, SharedXWalkExceptionHandler handler) { assert context instanceof Activity; assert context.getApplicationContext() instanceof XWalkApplication; ReflectionHelper.allowCrossPackage(); ReflectionHelper.setExceptionHandler(handler); return (Activity) context; }
public static void setRenderDistance(World world, int distance) { try { ReflectionHelper.field("e") .in(ReflectionHelper.field("manager").in(((CraftWorld) world).getHandle()).get()) .set(distance); } catch (Exception ignored) { ignored.printStackTrace(); } }
/** * Controls minecraft's thunderstorm flag in world data. * * @param world Bukkit world object * @param flag whether to set it to thundering or not */ public static void setThunderNoEvent(World world, boolean flag) { try { WorldData data = ((CraftWorld) world).getHandle().worldData; ReflectionHelper.field("isThundering").in(data).set(flag); ReflectionHelper.field("thunderTicks").in(data).set(flag ? Integer.MAX_VALUE : 0); } catch (Exception ex) { world.setStorm(true); // Can still set the storm } }
/** See JERSEY-1598. */ @Test public void getParameterizedClassArgumentsTest() { ReflectionHelper.DeclaringClassInterfacePair dcip = ReflectionHelper.getClass(TestNoInterface.class, I.class); Class[] arguments = ReflectionHelper.getParameterizedClassArguments(dcip); Class aClass = arguments[0]; dcip = ReflectionHelper.getClass(TestInterface.class, I.class); arguments = ReflectionHelper.getParameterizedClassArguments(dcip); assertEquals(aClass, arguments[0]); }
@Test public void annotationTest_ReadAnnotation() throws Exception { System.out.println( "public static <T extends Annotation> T getMethodAnnotation(Class<?> clz, String methodName, Class<T> annotationClazz)"); XmlElement xmlElementAnnotation = ReflectionHelper.getMethodAnnotation(SimplePojo.class, "getValueB", XmlElement.class); assertNotNull(xmlElementAnnotation); System.out.println(" xmlElementAnnotation: " + xmlElementAnnotation); Test testAnnotation = ReflectionHelper.getMethodAnnotation( ReflectionHelperTest.class, "annotationTest_ReadAnnotation", Test.class); assertNotNull(testAnnotation); System.out.println(" testAnnotation: " + testAnnotation); }
/** * Test of 'public static <T> T newObject(String className, Class<?>[] paramTypes, Object... * parameters)' method, of class ReflectionHelper. */ @Test public void shouldCreateNewObjects() { System.out.println( "public static <T> T newClass(String className, Class<?>[] paramTypes, Object... parameters)"); String clazzName = "java.math.BigDecimal"; Class<?>[] parameterTypes = new Class<?>[] {int.class}; int expResult = 30; Object result = ReflectionHelper.newObject(clazzName, parameterTypes, 30); assertEquals(expResult, ((BigDecimal) result).intValue()); System.out.println(" result = " + result); System.out.println("public static <T> T newClass(String className)"); Object result2 = ReflectionHelper.newObject("java.util.Date"); assertNotNull(result2); System.out.println(" result = " + result2); }
public static void reflectXmlRootNode(Object model, Node node) throws IllegalArgumentException, IllegalAccessException, InstantiationException { // Check if the root node is an array Class<?> modelClass = model.getClass(); Field rootNodeField = null; try { rootNodeField = ReflectionHelper.getFieldInHierarchy(modelClass, node.name); } catch (NoSuchFieldException e) { } // The developer has declared a field to match the root node if (rootNodeField != null) { if (rootNodeField.getType() == List.class) { processListField(model, rootNodeField, node, null); } else { reflectXmlObject(model, node); } } else { // The developer has mapped the root node to the object itself reflectXmlObject(model, node); } }
private static void accessFieldAndProcess( Object model, Class<?> modelClass, Node node, Node parentNode) { try { Field field = ReflectionHelper.getFieldInHierarchy(modelClass, node.name); if (field.getType() == List.class) { processListField(model, field, node, parentNode); } else { processSingleField(model, field, node); } } catch (NoSuchFieldException e) { Log.w(XmlReflector.class.getName(), "Can not locate field named " + node.name); } catch (IllegalAccessException e) { Log.w(XmlReflector.class.getName(), "Can not access field named " + node.name); } catch (InstantiationException e) { Log.w( XmlReflector.class.getName(), "Can not create an instance of the type defined in the field named " + node.name); } }
public static void reflectJsonObject(Object model, JSONObject jsonObj) throws JSONException { Class<?> modelClass = model.getClass(); JSONArray names = jsonObj.names(); if (names != null) { for (int i = 0; i < names.length(); i++) { String name = names.getString(i); try { Field field = ReflectionHelper.getFieldInHierarchy(modelClass, name); if (field.getType() == List.class) { processListField(model, field, jsonObj.getJSONArray(name)); } else { processSingleField(model, field, jsonObj, name); } } catch (NoSuchFieldException e) { Log.w(JsonReflector.class.getName(), "Can not locate field named " + name); } catch (IllegalAccessException e) { Log.w(JsonReflector.class.getName(), "Can not access field named " + name); } catch (InstantiationException e) { Log.w( JsonReflector.class.getName(), "Can not create an instance of the type defined in the field named " + name); } } } }
@Test public void testFindFieldTransitive() throws Exception { List<SyntheticField> fields = new ArrayList<SyntheticField>(); SyntheticField f1 = new SimpleSyntheticField(PersonDomain.class.getDeclaredField("name")); SyntheticField f2 = new SimpleSyntheticField(PersonDomain.class.getDeclaredField("address")); fields.add(f1); fields.add(f2); SyntheticField f3 = new SimpleSyntheticField(AddressDomain.class.getDeclaredField("id")); when(reflectionHelper.getSyntheticFields(any(Class.class))) .thenReturn(Collections.singletonList(f3)); SyntheticField[] res; res = converterHelper.findField( fields, "id", new String[] {"address"}, PersonDomain.class, false); assertThat(res).hasSize(2); assertThat(res[0]).isEqualTo(f2); assertThat(res[1]).isEqualTo(f3); exception.expect(JTransfoException.class); exception.expectMessage( "Cannot find getter from [getBla, isBla, hasBla] on " + "class org.jtransfo.object.PersonDomain."); converterHelper.findField(fields, "id", new String[] {"bla"}, PersonDomain.class, false); }
@Override public void startElement(String uri, String localName, String qName, Attributes attributes) throws SAXException { if (qName.equals(CLASS_ELEMENT)) instance = ReflectionHelper.createInstance(attributes.getValue(0)); element = qName; }
@Test(expected = IllegalArgumentException.class) public void shouldThrowExceptionWhenCalledWithNullParameter_newObject_P3() { Object newObject = ReflectionHelper.newObject( "java.lang.Integer", new Class<?>[] {int.class}, (Object[]) null); fail("Integer " + newObject + " created!"); }
private void checkExisting( File targetFile, ClassLoader classLoader, Document doc, Set<String> entityClasses) { if (targetFile.exists()) { final Set<String> alreadyDefined = PersistenceXmlHelper.getClassesAlreadyDefined(doc); for (String className : alreadyDefined) { if (!ReflectionHelper.classExists(className, classLoader)) { getLog().warn("Class " + className + " defined in " + targetFile + " does not exist"); } } if (!alreadyDefined.containsAll(entityClasses)) { final Set<String> undefined = new TreeSet<>(); for (String className : entityClasses) { if (!alreadyDefined.contains(className)) { undefined.add(className); } } getLog() .warn( "The following classes was not defined in " + targetFile + " even " + "though they are available on the class path: " + Arrays.toString(undefined.toArray())); } // Don't add so we end up with duplicates entityClasses.removeAll(alreadyDefined); } }
@Test public void shouldCreateANewExceptionUsingAnEmptyConstructor() throws Exception { System.out.println( "public static <T extends Exception> T newException(Class<T> clazz, Object... parameters)"); IOException exception = ReflectionHelper.newException(IOException.class); assertThat("IOException is not null", exception, notNullValue()); assertThat("MessageText is not null", exception.getMessage(), nullValue()); System.out.println(exception); }
/** * Test of 'public static <T> Class<T> loadClass(String className)' method, of class * ReflectionHelper. */ @Test public void loadClass() { System.out.println("public static <T> Class<T> loadClass(String className)"); String classname = "java.util.Date"; Class expResult = Date.class; Class result = ReflectionHelper.loadClass(classname); assertEquals(expResult, result); System.out.println(" result = " + result); }
@Test public void shouldCreateANewExceptionUsingAStringParameter() throws Exception { System.out.println( "public static <T extends Exception> T newException(Class<T> clazz, Object... parameters)"); IOException exception = ReflectionHelper.newException(IOException.class, "AnyMessageForOurIOException"); assertThat("IOException is not null", exception, notNullValue()); assertThat("MessageText", exception.getMessage(), equalTo("AnyMessageForOurIOException")); System.out.println(exception); }
@Test public void testGetDeclaredTypeConverterAsName() throws Exception { MappedBy mappedBy = mock(MappedBy.class); when(mappedBy.typeConverterClass()).thenReturn(MappedBy.DefaultTypeConverter.class); when(mappedBy.typeConverter()).thenReturn(NoConversionTypeConverter.class.getName()); when(mappedBy.field()).thenReturn(MappedBy.DEFAULT_FIELD); when(reflectionHelper.newInstance(NoConversionTypeConverter.class.getName())) .thenReturn(new NoConversionTypeConverter()); TypeConverter res = converterHelper.getDeclaredTypeConverter(mappedBy); assertThat(res).isInstanceOf(NoConversionTypeConverter.class); }
/** * Test of 'public static Field getField(Class<?> clazz, String fieldname, Class<?> fieldtype)' * method, of class ReflectionHelper. */ @Test public void shouldGetAField() throws Exception { System.out.println( "public static Field getField(Class<?> clazz, String fieldname, Class<?> fieldtype)"); File cut = new File("pom.xml"); Field pathField = ReflectionHelper.getField(File.class, "path", String.class); assertThat(pathField, notNullValue()); assertThat(pathField.getName(), equalTo("path")); pathField.setAccessible(true); assertThat(pathField.get(cut), equalTo("pom.xml")); }
@Test public void testGetDeclaredTypeConverterIae() throws Exception { MappedBy mappedBy = mock(MappedBy.class); when(mappedBy.typeConverterClass()).thenReturn(MappedBy.DefaultTypeConverter.class); when(mappedBy.typeConverter()).thenReturn(NoConversionTypeConverter.class.getName()); when(mappedBy.field()).thenReturn(MappedBy.DEFAULT_FIELD); when(reflectionHelper.newInstance(NoConversionTypeConverter.class.getName())) .thenThrow(new IllegalAccessException()); exception.expect(JTransfoException.class); exception.expectMessage( "Declared TypeConverter class org.jtransfo.NoConversionTypeConverter cannot be accessed."); converterHelper.getDeclaredTypeConverter(mappedBy); }
@Test public void testGetDeclaredTypeConverter_withTypeConverter() throws Exception { MapOnly mapOnly = mock(MapOnly.class); when(reflectionHelper.newInstance( "org.jtransfo.internal.ConverterHelperTest$DefaultTypeConverter")) .thenReturn(new DefaultTypeConverter()); when(mapOnly.typeConverterClass()).thenReturn(DefaultTypeConverter.class); when(mapOnly.typeConverter()).thenReturn(MappedBy.DEFAULT_TYPE_CONVERTER); TypeConverter tc = mock(TypeConverter.class); TypeConverter res = converterHelper.getDeclaredTypeConverter(mapOnly, tc); assertThat(res).isInstanceOf(DefaultTypeConverter.class); }
private static void reflectXmlObject(Object model, Node node) { Class<?> modelClass = model.getClass(); // Treat attributes like fields if (node.attributes != null) { for (String key : node.attributes.keySet()) { String value = node.attributes.get(key); try { Field field = ReflectionHelper.getFieldInHierarchy(modelClass, key); Class<?> type = field.getType(); if (type == String.class) { field.set(model, value); } else if (type == boolean.class || type == Boolean.class) { field.set(model, Boolean.valueOf(value)); } else if (type == int.class || type == Integer.class) { field.set(model, Integer.valueOf(value)); } else if (type == double.class || type == Double.class) { field.set(model, Double.valueOf(value)); } } catch (NoSuchFieldException e) { Log.w(XmlReflector.class.getName(), "Can not locate field named " + key); } catch (IllegalAccessException e) { Log.w(XmlReflector.class.getName(), "Can not access field named " + key); } } } if (node.subnodes != null) { for (int i = 0; i < node.subnodes.size(); i++) { Node subnode = node.subnodes.get(i); accessFieldAndProcess(model, modelClass, subnode, node); } } else { // This node has no children (hope it has a wife). accessFieldAndProcess(model, modelClass, node, null); } }
@Test public void shouldExtractAllClasses() { // given String one = "a string"; Class two = Double.class; SimplePojo three = new SimplePojo(); Object[] anything = new Object[] {one, two, three}; // when Class[] extracted = ReflectionHelper.extractClasses(anything); // then assertEquals(extracted[0], String.class); assertEquals(extracted[1], Double.class); assertEquals(extracted[2], SimplePojo.class); }
/* ************************************************************************************************ * Overriden Methods ************************************************************************************************ */ @Override public void onReceive(Context context, Intent intent) { // Get all the registered and loop through and start them String[] serviceList = PropertyHelper.getBootServices(context); if (serviceList != null) { for (int i = 0; i < serviceList.length; i++) { // Fix to https://github.com/Red-Folder/bgs-core/issues/18 // Gets the class from string Class<?> serviceClass = ReflectionHelper.LoadClass(serviceList[i]); Intent serviceIntent = new Intent(context, serviceClass); context.startService(serviceIntent); } } }
@Test public void testGetDeclaredTypeConverterAsClass() throws Exception { MappedBy mappedBy = mock(MappedBy.class); when(mappedBy.typeConverterClass()).thenReturn(NoConversionTypeConverter.class); when(mappedBy.typeConverter()).thenReturn(MappedBy.DEFAULT_TYPE_CONVERTER); when(mappedBy.field()).thenReturn(MappedBy.DEFAULT_FIELD); when(reflectionHelper.newInstance(NoConversionTypeConverter.class.getName())) .thenReturn(new NoConversionTypeConverter()); TypeConverter res = converterHelper.getDeclaredTypeConverter(mappedBy); assertThat(res).isInstanceOf(NoConversionTypeConverter.class); TypeConverter res2 = converterHelper.getDeclaredTypeConverter(mappedBy); assertThat(res2 == res).isTrue(); // instance needs to be cached and reused }
/** * Deletes the reportCategoryBean satisfying a certain criteria together with the dependent * database entries * * @param crit * @throws TorqueException */ public static void doDelete(Criteria crit) throws TorqueException { List list = null; try { list = doSelect(crit); } catch (TorqueException e) { LOGGER.error( "Getting the list of TReportCategoryBean to be deleted failed with " + e.getMessage()); throw e; } if (list != null && !list.isEmpty()) { Iterator<TReportCategory> iter = list.iterator(); TReportCategory filterCategory = null; while (iter.hasNext()) { filterCategory = iter.next(); ReflectionHelper.delete(deletePeerClasses, deleteFields, filterCategory.getObjectID()); } } }
/** * Test of 'public static void setValue(Object instance, String setter, Object value)' method, of * class ReflectionHelper. */ @Test public void setValueAndGetValue() throws Exception { System.out.println("public static void setValue(Object instance, String setter, Object value)"); SimplePojo pojo = new SimplePojo(); assertNull(pojo.getValueA()); assertNull(pojo.getValueB()); ReflectionHelper.setValue(pojo, "setValueA", "Alpha"); assertEquals("Alpha", pojo.getValueA()); ReflectionHelper.setValue(pojo, "setValueB", "Beta"); assertEquals("Alpha", pojo.getValueA()); System.out.println(" result = setValue works fine! "); String got = ReflectionHelper.getValue(pojo, "getValueA"); assertEquals(got, pojo.getValueA()); System.out.println(" result = getValue works also fine! "); long start = System.currentTimeMillis(); for (int i = 1; i <= 100000; i++) { ReflectionHelper.setValue(pojo, "setValueA", "Alpha"); ReflectionHelper.setValue(pojo, "setValueB", "Beta"); ReflectionHelper.getValue(pojo, "getValueA"); ReflectionHelper.getValue(pojo, "getValueB"); } long end = System.currentTimeMillis(); System.out.println(" time: " + (end - start) + " ms "); System.out.println(" " + ReflectionHelper.getCacheInfo()); }
private static void reflectJsonArray(Object model, JSONArray jsonArray) throws JSONException { Class<?> modelClass = model.getClass(); try { Field listField = ReflectionHelper.getFieldInHierarchy(modelClass, "list"); processListField(model, listField, jsonArray); } catch (NoSuchFieldException e) { Log.w(JsonReflector.class.getName(), "Can not locate field named list"); } catch (IllegalArgumentException e) { Log.w(JsonReflector.class.getName(), "Can not put a List in the field named list"); } catch (IllegalAccessException e) { Log.w(JsonReflector.class.getName(), "Can not access field named list"); } catch (InstantiationException e) { Log.w( JsonReflector.class.getName(), "Can not create an instance of the type defined in the field named list"); } }
@Override public void init(GenericTask task, Map<String, String> properties) { Field[] fields = ReflectionHelper.getDeclaredFields(this.getClass(), null); for (Field field : fields) { if (!field.isAnnotationPresent(VersionProviderParam.class)) { continue; } VersionProviderParam param = field.getAnnotation(VersionProviderParam.class); if (!properties.containsKey(param.value())) { continue; } // make private and protected fields also accessible field.setAccessible(true); try { field.set(this, properties.get(param.value())); } catch (IllegalAccessException e) { throw new BuildException( "Failed to set build version provider param '" + param.value() + "'", e); } } }