public List<Model.Property> listProperties() { List<Model.Property> properties = new ArrayList<Model.Property>(); Set<Field> fields = new LinkedHashSet<Field>(); Class<?> tclazz = clazz; while (!tclazz.equals(Object.class)) { Collections.addAll(fields, tclazz.getDeclaredFields()); tclazz = tclazz.getSuperclass(); } for (Field f : fields) { int mod = f.getModifiers(); if (Modifier.isTransient(mod) || Modifier.isStatic(mod)) { continue; } if (f.isAnnotationPresent(Transient.class)) { continue; } if (f.isAnnotationPresent(NoBinding.class)) { NoBinding a = f.getAnnotation(NoBinding.class); List<String> values = Arrays.asList(a.value()); if (values.contains("*")) { continue; } } Model.Property mp = buildProperty(f); if (mp != null) { properties.add(mp); } } return properties; }
// TODO: https://issues.jboss.org/browse/JBPM-4296 private static Long findProcessInstanceId(Object command) { if (command instanceof AuditCommand) { return null; } try { Field[] fields = command.getClass().getDeclaredFields(); for (Field field : fields) { field.setAccessible(true); if (field.isAnnotationPresent(XmlAttribute.class)) { String attributeName = field.getAnnotation(XmlAttribute.class).name(); if ("process-instance-id".equalsIgnoreCase(attributeName)) { return (Long) field.get(command); } } else if (field.isAnnotationPresent(XmlElement.class)) { String elementName = field.getAnnotation(XmlElement.class).name(); if ("process-instance-id".equalsIgnoreCase(elementName)) { return (Long) field.get(command); } } else if (field.getName().equals("processInstanceId")) { return (Long) field.get(command); } } } catch (Exception e) { logger.debug( "Unable to find process instance id on command {} due to {}", command, e.getMessage()); } return null; }
public static Serializable getIdentifier(final Object obj) { if (obj instanceof BaseDO<?>) { return getIdentifier((BaseDO<?>) obj); } for (final Field field : obj.getClass().getDeclaredFields()) { if (field.isAnnotationPresent(Id.class) == true && field.isAnnotationPresent(GeneratedValue.class) == true) { final boolean isAccessible = field.isAccessible(); try { field.setAccessible(true); final Object idObject = field.get(obj); field.setAccessible(isAccessible); if (idObject != null && Serializable.class.isAssignableFrom(idObject.getClass()) == true) { return (Serializable) idObject; } } catch (final IllegalArgumentException e) { e.printStackTrace(); } catch (final IllegalAccessException e) { e.printStackTrace(); } } } return null; }
Field[] keyFields() { Class c = clazz; try { List<Field> fields = new ArrayList<Field>(); while (!c.equals(Object.class)) { for (Field field : c.getDeclaredFields()) { // TODO: add cashe field->isAnnotationPresent if (InternalCache.isEnableAnnotationPresent()) { if (InternalCache.isAnnotationPresent(Id.class, field) || InternalCache.isAnnotationPresent(EmbeddedId.class, field)) { field.setAccessible(true); fields.add(field); } } else { if (field.isAnnotationPresent(Id.class) || field.isAnnotationPresent(EmbeddedId.class)) { field.setAccessible(true); fields.add(field); } } } c = c.getSuperclass(); } final Field[] f = fields.toArray(new Field[fields.size()]); if (f.length == 0) { throw new UnexpectedException("Cannot get the object @Id for an object of type " + clazz); } return f; } catch (Exception e) { throw new UnexpectedException( "Error while determining the object @Id for an object of type " + clazz); } }
public void injectResources(Object serviceInstance) { if (resources == null && entityManagers == null && typedResources == null) { return; } List<Member> members = ReflectionUtils.findMembers(serviceInstance.getClass()); for (Member member : members) { if (member instanceof Field) { Field field = (Field) member; if (field.isAnnotationPresent(Resource.class)) { Resource resource = field.getAnnotation(Resource.class); if (!injectNamedResource(serviceInstance, field, resource)) { injectTypedResource(serviceInstance, field); } } if (hasPersistenceContextInClassPath) { try { if (field.isAnnotationPresent(PersistenceContext.class)) { PersistenceContext resource = field.getAnnotation(PersistenceContext.class); injectEntityManager(serviceInstance, field, resource); } } catch (NoClassDefFoundError e) { hasPersistenceContextInClassPath = false; } } } } }
/** * TODO: not yet commented. * * @return */ public Set<Attribute> getAttributes() { Set<Attribute> result = new HashSet<Attribute>(); /* * Search on this entity, climbing up the class hierarchy. */ Class<?> self = this.getClass(); while (!Object.class.equals(self)) { for (Field f : self.getClass().getDeclaredFields()) { if (f.isAnnotationPresent(Attribute.class)) { result.add(f.getAnnotation(Attribute.class)); } // if } // for self = self.getSuperclass(); } // while /* * Search on all mixins. */ for (Object o : this.getMixins()) { for (Field f : o.getClass().getDeclaredFields()) { if (f.isAnnotationPresent(Attribute.class)) { result.add(f.getAnnotation(Attribute.class)); } // if } // for } // for return result; }
/** * 解析字段定义<br> * <功能详细描述> * * @param type * @param pd * @return [参数说明] * @return JPAEntityColumnDef [返回类型说明] * @exception throws [异常类型] [异常说明] * @see [类、类#方法、类#成员] */ private static JPAEntityColumnDef doAnalyzeCoumnDef( String tableName, Class<?> type, PropertyDescriptor pd) { JPAEntityColumnDef colDef = null; String columnComment = ""; String propertyName = pd.getName(); String columnName = propertyName; Class<?> javaType = pd.getPropertyType(); int size = 0; int scale = 0; boolean required = false; // 获取字段 Field field = FieldUtils.getField(type, propertyName, true); if (field != null) { if (field.isAnnotationPresent(Transient.class)) { // 如果含有忽略的字段则跳过该字段 return null; } if (field.isAnnotationPresent(OneToMany.class)) { // 如果含有忽略的字段则跳过该字段 return null; } if (field.isAnnotationPresent(Column.class)) { Column columnAnno = field.getAnnotation(Column.class); columnName = columnAnno.name(); required = !columnAnno.nullable(); size = Math.max(columnAnno.length(), columnAnno.precision()); scale = columnAnno.scale(); } } // 获取读方法 Method readMethod = pd.getReadMethod(); if (readMethod != null) { if (readMethod.isAnnotationPresent(Transient.class)) { // 如果含有忽略的字段则跳过该字段 return null; } if (readMethod.isAnnotationPresent(OneToMany.class)) { // 如果含有忽略的字段则跳过该字段 return null; } if (readMethod.isAnnotationPresent(Column.class)) { Column columnAnno = readMethod.getAnnotation(Column.class); columnName = columnAnno.name(); required = !columnAnno.nullable(); size = Math.max(columnAnno.length(), columnAnno.precision()); scale = columnAnno.scale(); } } JdbcTypeEnum jdbcType = JPAEntityTypeRegistry.getJdbcType(javaType); // 获取对应的jdbcType colDef = new JPAEntityColumnDef(columnName, javaType, jdbcType, size, scale, required); colDef.setComment(columnComment); return colDef; }
@SuppressWarnings("unchecked") public final void process(Class<?> clazz, EntityMetadata metadata) { metadata.setIndexName(clazz.getSimpleName()); Index idx = (Index) clazz.getAnnotation(Index.class); List columnsToBeIndexed = new ArrayList(); if (null != idx) { boolean isIndexable = idx.index(); metadata.setIndexable(isIndexable); String indexName = idx.name(); if ((indexName != null) && (!(indexName.isEmpty()))) { metadata.setIndexName(indexName); } else { metadata.setIndexName(clazz.getSimpleName()); } if ((idx.columns() != null) && (idx.columns().length != 0)) { columnsToBeIndexed = Arrays.asList(idx.columns()); } if (!(isIndexable)) { log.debug( new StringBuilder() .append("@Entity ") .append(clazz.getName()) .append(" will not be indexed for ") .append((columnsToBeIndexed.isEmpty()) ? "all columns" : columnsToBeIndexed) .toString()); return; } } log.debug( new StringBuilder() .append("Processing @Entity ") .append(clazz.getName()) .append(" for Indexes.") .toString()); for (Field f : clazz.getDeclaredFields()) { if (f.isAnnotationPresent(Id.class)) { String alias = f.getName(); alias = getIndexName(f, alias); // metadata.addIndexProperty(new PropertyIndex(f, alias)); } else { if (!(f.isAnnotationPresent(Column.class))) continue; String alias = f.getName(); alias = getIndexName(f, alias); if ((!(columnsToBeIndexed.isEmpty())) && (!(columnsToBeIndexed.contains(alias)))) continue; // metadata.addIndexProperty(new PropertyIndex(f, alias)); } } }
private void parseProperty(AnnotationInfo ai, Class c, Field field) { // TODO add support for OneToOne if (!field.isAnnotationPresent(Transient.class) && (field.isAnnotationPresent(ManyToMany.class) || field.isAnnotationPresent(OneToMany.class) || field.isAnnotationPresent(ManyToOne.class) || field.isAnnotationPresent(Id.class))) { ai.addField(field); } }
@GwtIncompatible("reflection") public void testGetField() { Field foo = Enums.getField(AnEnum.FOO); assertEquals("FOO", foo.getName()); assertTrue(foo.isAnnotationPresent(ExampleAnnotation.class)); Field bar = Enums.getField(AnEnum.BAR); assertEquals("BAR", bar.getName()); assertFalse(bar.isAnnotationPresent(ExampleAnnotation.class)); }
static boolean detectJOhmCollection(final Field field) { boolean isJOhmCollection = false; if (field.isAnnotationPresent(CollectionList.class) || field.isAnnotationPresent(CollectionSet.class) || field.isAnnotationPresent(CollectionSortedSet.class) || field.isAnnotationPresent(CollectionMap.class)) { isJOhmCollection = true; } return isJOhmCollection; }
@SuppressWarnings("unchecked") static void initCollections(final Object model, final Nest<?> nest) { if (model == null || nest == null) { return; } for (Field field : model.getClass().getDeclaredFields()) { field.setAccessible(true); try { if (field.isAnnotationPresent(CollectionList.class)) { Validator.checkValidCollection(field); List<Object> list = (List<Object>) field.get(model); if (list == null) { CollectionList annotation = field.getAnnotation(CollectionList.class); RedisList<Object> redisList = new RedisList<Object>(annotation.of(), nest, field, model); field.set(model, redisList); } } if (field.isAnnotationPresent(CollectionSet.class)) { Validator.checkValidCollection(field); Set<Object> set = (Set<Object>) field.get(model); if (set == null) { CollectionSet annotation = field.getAnnotation(CollectionSet.class); RedisSet<Object> redisSet = new RedisSet<Object>(annotation.of(), nest, field, model); field.set(model, redisSet); } } if (field.isAnnotationPresent(CollectionSortedSet.class)) { Validator.checkValidCollection(field); Set<Object> sortedSet = (Set<Object>) field.get(model); if (sortedSet == null) { CollectionSortedSet annotation = field.getAnnotation(CollectionSortedSet.class); RedisSortedSet<Object> redisSortedSet = new RedisSortedSet<Object>(annotation.of(), annotation.by(), nest, field, model); field.set(model, redisSortedSet); } } if (field.isAnnotationPresent(CollectionMap.class)) { Validator.checkValidCollection(field); Map<Object, Object> map = (Map<Object, Object>) field.get(model); if (map == null) { CollectionMap annotation = field.getAnnotation(CollectionMap.class); RedisMap<Object, Object> redisMap = new RedisMap<Object, Object>( annotation.key(), annotation.value(), nest, field, model); field.set(model, redisMap); } } } catch (IllegalArgumentException e) { throw new InvalidFieldException(); } catch (IllegalAccessException e) { throw new InvalidFieldException(); } } }
/* * (non-Javadoc) * * @see java.util.concurrent.Callable#call() */ public AnnotationInfo call() throws Exception { Field riakKeyField = null; Field riakVClockField = null; Field usermetaMapField = null; Field linksField = null; List<UsermetaField> usermetaItemFields = new ArrayList<UsermetaField>(); List<RiakIndexField> indexFields = new ArrayList<RiakIndexField>(); final Field[] fields = classToScan.getDeclaredFields(); for (Field field : fields) { if (field.isAnnotationPresent(RiakKey.class)) { riakKeyField = ClassUtil.checkAndFixAccess(field); } if (field.isAnnotationPresent(RiakVClock.class)) { // restrict the field type to byte[] or VClock if (!(field.getType().isArray() && field.getType().getComponentType().equals(byte.class)) && !field.getType().isAssignableFrom(VClock.class)) { throw new IllegalArgumentException(field.getType().toString()); } riakVClockField = ClassUtil.checkAndFixAccess(field); } if (field.isAnnotationPresent(RiakUsermeta.class)) { RiakUsermeta a = field.getAnnotation(RiakUsermeta.class); String key = a.key(); if (!"".equals(key)) { usermetaItemFields.add(new UsermetaField(ClassUtil.checkAndFixAccess(field))); } else { usermetaMapField = ClassUtil.checkAndFixAccess(field); } } if (field.isAnnotationPresent(RiakIndex.class)) { indexFields.add(new RiakIndexField(ClassUtil.checkAndFixAccess(field))); } if (field.isAnnotationPresent(RiakLinks.class)) { linksField = ClassUtil.checkAndFixAccess(field); } } return new AnnotationInfo( riakKeyField, usermetaItemFields, usermetaMapField, indexFields, linksField, riakVClockField); }
public Map<String, Object> dumpStats() { HashMap<String, Object> map = new HashMap<String, Object>(); for (Class<?> clazz = this.getClass(); clazz != null; clazz = clazz.getSuperclass()) { Field[] fields = clazz.getDeclaredFields(); for (Field field : fields) { if (field.isAnnotationPresent(ManagedAttribute.class) || (field.isAnnotationPresent(Property.class) && field.getAnnotation(Property.class).exposeAsManagedAttribute())) { String attributeName = field.getName(); try { field.setAccessible(true); Object value = field.get(this); map.put(attributeName, value != null ? value.toString() : null); } catch (Exception e) { log.warn("Could not retrieve value of attribute (field) " + attributeName, e); } } } Method[] methods = this.getClass().getMethods(); for (Method method : methods) { if (method.isAnnotationPresent(ManagedAttribute.class) || (method.isAnnotationPresent(Property.class) && method.getAnnotation(Property.class).exposeAsManagedAttribute())) { String method_name = method.getName(); if (method_name.startsWith("is") || method_name.startsWith("get")) { try { Object value = method.invoke(this); String attributeName = Util.methodNameToAttributeName(method_name); map.put(attributeName, value != null ? value.toString() : null); } catch (Exception e) { log.warn("Could not retrieve value of attribute (method) " + method_name, e); } } else if (method_name.startsWith("set")) { String stem = method_name.substring(3); Method getter = ResourceDMBean.findGetter(getClass(), stem); if (getter != null) { try { Object value = getter.invoke(this); String attributeName = Util.methodNameToAttributeName(method_name); map.put(attributeName, value != null ? value.toString() : null); } catch (Exception e) { log.warn("Could not retrieve value of attribute (method) " + method_name, e); } } } } } } return map; }
public List<Method> getMethods(Object objeto) { List<Method> methodGet = mappedMethods.get(objeto.getClass()); if (methodGet != null) { return methodGet; } methodGet = new ArrayList<Method>(); Method methods[] = objeto.getClass().getMethods(); List exclude = Arrays.asList(EXCLUDED_FIELDS); try { Field field; String fieldName; for (int j = 0; j < methods.length; j++) { field = null; fieldName = ""; try { if (methods[j] != null && !methods[j].isAnnotationPresent(Transient.class) && !methods[j].isAnnotationPresent(NotAudited.class) && !methods[j].isAnnotationPresent(Id.class) && !exclude.contains(methods[j].getName())) { fieldName = getMethodName(methods[j]); } if (fieldName != null && !fieldName.equals("")) { try { field = getDeclaredField(methods[j].getDeclaringClass(), fieldName); } catch (NoSuchFieldException ex) { continue; } if (field != null && !field.isAnnotationPresent(Transient.class) && !field.isAnnotationPresent(NotAudited.class) && !field.isAnnotationPresent(Id.class)) { methodGet.add(methods[j]); } } } catch (Exception ex) { logger.log(Level.SEVERE, ex.getMessage(), ex); } } } catch (Exception ex) { logger.log(Level.SEVERE, ex.getMessage(), ex); } mappedMethods.put(objeto.getClass(), methodGet); return methodGet; }
public void inJectAll(Activity activity) { Field[] fields = activity.getClass().getDeclaredFields(); if (fields != null && fields.length > 0) { for (Field field : fields) { if (field.isAnnotationPresent(InjectView.class)) { injectView(activity, field); } else if (field.isAnnotationPresent(InjectResource.class)) { injectResource(activity, field); } else if (field.isAnnotationPresent(Inject.class)) { inject(activity, field); } } } }
/** {@inheritDoc} */ @Override public Object postProcessAfterInitialization(Object bean, String beanName) { if (bean == null) return null; Class<?> beanClass = bean.getClass(); Field[] fields = beanClass.getDeclaredFields(); for (Field field : fields) { // Expect to get annnotation Autowired if (field.isAnnotationPresent(AutowiredFF4JProperty.class)) { autoWiredProperty(bean, field); } else if (field.isAnnotationPresent(AutowiredFF4JFeature.class)) { autoWiredFeature(bean, field); } } return bean; }
public List<Model.Property> listProperties() { List<Model.Property> properties = new ArrayList<Model.Property>(); Set<Field> fields = new HashSet<Field>(); Class<?> tclazz = clazz; while (!tclazz.equals(Object.class)) { Collections.addAll(fields, tclazz.getDeclaredFields()); tclazz = tclazz.getSuperclass(); } for (Field f : fields) { if (Modifier.isTransient(f.getModifiers())) { continue; } if (Modifier.isStatic(f.getModifiers())) { continue; } if (f.isAnnotationPresent(Transient.class) && !f.getType().equals(Blob.class)) { continue; } Model.Property mp = buildProperty(f); if (mp != null) { properties.add(mp); } } return properties; }
public int parse(Class<?> clazz) throws Exception { if (!doesClassHaveExcelReaderAnnotation(clazz)) { return 0; } String fileName = getFileName(clazz); Sheet sheet = getSheet(fileName); Field[] fields = clazz.getDeclaredFields(); int count = 0; for (Field field : fields) { if (field.isAnnotationPresent(TestCase.class)) { try { // method.invoke(null); System.out.println("Field name: " + field.getName()); count++; } catch (Exception e) { } } } return count; }
/** * Takes care of the id properties, either identifying the Ids or getting them from idProperties * of @Path * * @throws Exception */ private void parseNodeProperty() throws Exception { if (Is.empty(treeAnnotation.idProperties())) { idProperties = ""; for (Field field : nodeClass.getDeclaredFields()) { if (field.isAnnotationPresent(Id.class)) { if (!Is.empty(idProperties)) { idProperties = idProperties + ","; } idProperties = idProperties + field.getName(); } } } else { idProperties = treeAnnotation.idProperties(); } if (Is.empty(idProperties)) { throw new Exception(XavaResources.getString("error.nodePropertiesUndefined")); } String[] properties = idProperties.split(","); idPropertiesList = new ArrayList<String>(); for (String property : properties) { if (!Is.empty(property.trim())) { idPropertiesList.add(property.trim()); } } }
/** * 构建ResultMap对象 * * @param id * @param clazz * @param configuration * @return */ private ResultMap buildResultMap(String id, Class<?> clazz, Configuration configuration) { // 判断是否已经存在缓存里 if (configuration.hasResultMap(id)) { return configuration.getResultMap(id); } List<ResultMapping> resultMappings = Lists.newArrayList(); Map<String, Field> columns = EntityUtil.getFields(clazz); for (Map.Entry<String, Field> column : columns.entrySet()) { Field field = column.getValue(); String fieldName = field.getName(); Class<?> columnTypeClass = resolveResultJavaType(clazz, fieldName, null); List<ResultFlag> flags = Lists.newArrayList(); if (field.isAnnotationPresent(Id.class)) { flags.add(ResultFlag.ID); } String columnName = column.getKey(); resultMappings.add( buildResultMapping(configuration, fieldName, columnName, columnTypeClass, flags)); } // 构建ResultMap ResultMap.Builder resultMapBuilder = new ResultMap.Builder(configuration, id, clazz, resultMappings); ResultMap rm = resultMapBuilder.build(); // 放到缓存中 configuration.addResultMap(rm); return rm; }
/** Initialize all options */ static { logger.info("Initialize all options."); Field[] fields = Config.class.getDeclaredFields(); for (Field field : fields) { if (field.isAnnotationPresent(Ora2PgOption.class)) { Ora2PgOption option = field.getAnnotation(Ora2PgOption.class); Builder builder = null; if (StringUtils.isEmpty(option.opt())) { builder = Option.builder(); } else { builder = Option.builder(option.opt()); } builder.longOpt(option.longOpt()); if (option.hasArg()) { builder .hasArg(true) .argName(option.argName()) .optionalArg(option.optionalArg()) .type(option.type()); } else { builder.hasArg(false); } OPTIONS.addOption(builder.desc(option.desc()).build()); } } }
/** * 获取一组声明了特殊注解的字段 * * @param ann 注解类型 * @return 字段数组 */ public <AT extends Annotation> Field[] getFields(Class<AT> ann) { List<Field> fields = new LinkedList<Field>(); for (Field f : this.getFields()) { if (f.isAnnotationPresent(ann)) fields.add(f); } return fields.toArray(new Field[fields.size()]); }
/** * get ViewHolder class and make reference for evert @link(DynamicViewId) to the actual view if * target contains HashMap<String, Integer> will replaced with the idsMap */ public static void parseDynamicView( Object target, View container, HashMap<String, Integer> idsMap) { for (Field field : target.getClass().getDeclaredFields()) { if (field.isAnnotationPresent(DynamicViewId.class)) { /* if variable is annotated with @DynamicViewId */ final DynamicViewId dynamicViewIdAnnotation = field.getAnnotation(DynamicViewId.class); /* get the Id of the view. if it is not set in annotation user the variable name */ String id = dynamicViewIdAnnotation.id(); if (id.equalsIgnoreCase("")) id = field.getName(); if (idsMap.containsKey(id)) { try { /* get the view Id from the Hashmap and make the connection to the real View */ field.set(target, container.findViewById(idsMap.get(id))); } catch (IllegalArgumentException e) { } catch (IllegalAccessException e) { e.printStackTrace(); } } } else if ((field.getName().equalsIgnoreCase("ids")) && (field.getType() == idsMap.getClass())) { try { field.set(target, idsMap); } catch (IllegalArgumentException e) { } catch (IllegalAccessException e) { e.printStackTrace(); } } } }
/** Removed fields cache from original code. */ protected static Collection<Field> getFields(Class<?> clazz) { Collection<Field> fields = ReflectUtil.getFields(clazz); Iterator<Field> iterator = fields.iterator(); while (iterator.hasNext()) { Field field = iterator.next(); if (!field.isAnnotationPresent(SpringBean.class)) { iterator.remove(); } else if (!field.isAccessible()) { // If the field isn't public, try to make it accessible try { field.setAccessible(true); } catch (SecurityException se) { throw new StripesRuntimeException( "Field " + clazz.getName() + "." + field.getName() + "is marked " + "with @SpringBean and is not public. An attempt to call " + "setAccessible(true) resulted in a SecurityException. Please " + "either make the field public, annotate a public setter instead " + "or modify your JVM security policy to allow Stripes to " + "setAccessible(true).", se); } } } return fields; }
public CacheKeyFilter(Class<?> cachedClass) { for (Field field : cachedClass.getDeclaredFields()) { if (field.isAnnotationPresent(CacheKey.class)) { cachedKeys.add(field.getName()); } } }
/** * Method to validate that the properties object has been correctly loaded * * @param props: The Properties object to validate * @return true if valid, false otherwise */ private static boolean validateProps(Properties props) { /* Validate size */ if (props != null && props.entrySet().size() == IndexerConstants.NUM_PROPERTIES) { /* Get all required properties and ensure they have been set */ Field[] flds = IndexerConstants.class.getDeclaredFields(); boolean valid = true; Object key; for (Field f : flds) { if (f.isAnnotationPresent(RequiredConstant.class)) { try { key = f.get(null); if (!props.containsKey(key) || props.get(key) == null) { System.err.println("The required property " + f.getName() + " is not set"); valid = false; } } catch (IllegalArgumentException e) { } catch (IllegalAccessException e) { } } } return valid; } return false; }
public static String collectSecureSettings(Context paramContext) { StringBuilder localStringBuilder = new StringBuilder(); Field[] arrayOfField = Settings.Secure.class.getFields(); int i = arrayOfField.length; int j = 0; while (true) if (j < i) { Field localField = arrayOfField[j]; if ((!localField.isAnnotationPresent(Deprecated.class)) && (localField.getType() == String.class) && (isAuthorized(localField))) ; try { String str = Settings.Secure.getString( paramContext.getContentResolver(), (String) localField.get(null)); if (str != null) localStringBuilder.append(localField.getName()).append("=").append(str).append("\n"); j++; } catch (IllegalArgumentException localIllegalArgumentException) { while (true) Log.w(ACRA.LOG_TAG, "Error : ", localIllegalArgumentException); } catch (IllegalAccessException localIllegalAccessException) { while (true) Log.w(ACRA.LOG_TAG, "Error : ", localIllegalAccessException); } } return localStringBuilder.toString(); }
protected void retrieveClassModelStructure() { this.classHandleName = objectClassModel.getAnnotation(ObjectClass.class).name(); fields = objectClassModel.getDeclaredFields(); Map<Class, Coder> tmpMapCoder = new HashMap<Class, Coder>(); Coder coderTmp = null; try { for (Field f : fields) { if (f.isAnnotationPresent(Attribute.class)) { coderTmp = tmpMapCoder.get(f.getAnnotation(Attribute.class).coder()); if (coderTmp == null) { coderTmp = f.getAnnotation(Attribute.class).coder().newInstance(); tmpMapCoder.put(f.getAnnotation(Attribute.class).coder(), coderTmp); } matchingObjectCoderIsValid(f, coderTmp); mapFieldCoder.put(f.getAnnotation(Attribute.class).name(), coderTmp); } } } catch (InstantiationException | IllegalAccessException e) { logger.error("Error in retreving the annotations of the fields"); e.printStackTrace(); } finally { tmpMapCoder = null; coderTmp = null; } }
private Field getUniqueUiField(String alias) { Set<Field> resourceFields = GwtReflectionUtils.getFields(owner.getClass()); if (resourceFields.size() == 0) { return null; } Field result = null; for (Field f : resourceFields) { if (alias.equals(f.getName()) && f.isAnnotationPresent(UiField.class)) { if (result != null) { throw new GwtTestUiBinderException( "There are more than one '" + f.getName() + "' @UiField in class '" + owner.getClass().getName() + "' or its superclass"); } result = f; } } return result; }