Exemplo n.º 1
1
 public void testImmutable() {
   Class<Fastq> cls = Fastq.class;
   assertTrue(Modifier.isPublic(cls.getModifiers()));
   assertTrue(Modifier.isFinal(cls.getModifiers()));
   Field[] fields = cls.getDeclaredFields();
   for (Field field : fields) {
     assertTrue(Modifier.isPrivate(field.getModifiers()));
     assertTrue(
         Modifier.isFinal(field.getModifiers())
             || (Modifier.isVolatile(field.getModifiers())
                 && Modifier.isTransient(field.getModifiers())));
   }
 }
Exemplo n.º 2
0
 @Override
 public final T serializeAs(Object o, Class<?> clazz) throws SerializerException {
   if (PrimitiveHandler.isPrimitive(o)) {
     // Problem
     throw new SerializerException("Asked to serialize primitive instance as a composite object");
   }
   // We get here if the object is not primitive
   Map<String, T> contents = new HashMap<String, T>();
   for (Field field : GenericSerializer.getAllFields(o.getClass())) {
     // Is this field declared as transient?
     if (Modifier.isTransient(field.getModifiers())) {
       // Yes: don't serialize this field
       continue;
     }
     field.setAccessible(true);
     try {
       String field_name = field.getName();
       Object field_value = field.get(o);
       Class<?> declared_type = field.getType();
       T serialized_value = m_serializer.serializeAs(field_value, declared_type);
       contents.put(field_name, serialized_value);
     } catch (IllegalArgumentException e) {
       throw new SerializerException(e);
     } catch (IllegalAccessException e) {
       throw new SerializerException(e);
     }
   }
   return serializeObject(o, contents);
 }
Exemplo n.º 3
0
 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;
 }
Exemplo n.º 4
0
 public void makeValid() {
   if (getIssuetype() != null) {
     Class<?> klass = getClass();
     while (klass != HashMap.class) {
       for (Field field : klass.getDeclaredFields()) {
         if (!getIssuetype().getFields().containsKey(field.getName())) {
           if (Modifier.isFinal(field.getModifiers())
               || Modifier.isStatic(field.getModifiers())
               || Modifier.isTransient(field.getModifiers())) {
             continue;
           }
           field.setAccessible(true);
           try {
             field.set(this, null);
           } catch (IllegalArgumentException e) {
             // TODO Auto-generated catch block
             e.printStackTrace();
           } catch (IllegalAccessException e) {
             // TODO Auto-generated catch block
             e.printStackTrace();
           }
         }
       }
       klass = klass.getSuperclass();
     }
     for (Map.Entry<String, Object> e : new HashMap<String, Object>(this).entrySet()) {
       if (!getIssuetype().getFields().containsKey(e.getKey())) {
         this.remove(e.getKey());
       }
     }
   }
 }
Exemplo n.º 5
0
 /**
  * 是否规定的忽略字段
  *
  * @param f
  * @return
  */
 public static boolean isIgnoredField(Field f) {
   int mods = f.getModifiers();
   return Modifier.isStatic(mods)
       || Modifier.isFinal(mods)
       || Modifier.isTransient(mods)
       || f.getName().startsWith("this$");
 }
Exemplo n.º 6
0
 private static void reflectionAppend(
     Object obj,
     Object obj1,
     Class class1,
     CompareToBuilder comparetobuilder,
     boolean flag,
     String as[]) {
   Field afield[] = class1.getDeclaredFields();
   AccessibleObject.setAccessible(afield, true);
   int i = 0;
   do {
     if (i >= afield.length || comparetobuilder.comparison != 0) {
       return;
     }
     Field field = afield[i];
     if (!ArrayUtils.contains(as, field.getName())
         && field.getName().indexOf('$') == -1
         && (flag || !Modifier.isTransient(field.getModifiers()))
         && !Modifier.isStatic(field.getModifiers())) {
       try {
         comparetobuilder.append(field.get(obj), field.get(obj1));
       } catch (IllegalAccessException illegalaccessexception) {
         throw new InternalError("Unexpected IllegalAccessException");
       }
     }
     i++;
   } while (true);
 }
Exemplo n.º 7
0
  private ObjectMap<String, FieldMetadata> cacheFields(Class type) {
    ArrayList<Field> allFields = new ArrayList();
    Class nextClass = type;
    while (nextClass != Object.class) {
      Collections.addAll(allFields, nextClass.getDeclaredFields());
      nextClass = nextClass.getSuperclass();
    }

    ObjectMap<String, FieldMetadata> nameToField = new ObjectMap();
    for (int i = 0, n = allFields.size(); i < n; i++) {
      Field field = allFields.get(i);

      int modifiers = field.getModifiers();
      if (Modifier.isTransient(modifiers)) continue;
      if (Modifier.isStatic(modifiers)) continue;
      if (field.isSynthetic()) continue;

      if (!field.isAccessible()) {
        try {
          field.setAccessible(true);
        } catch (AccessControlException ex) {
          continue;
        }
      }

      nameToField.put(field.getName(), new FieldMetadata(field));
    }
    typeToFields.put(type, nameToField);
    return nameToField;
  }
  public String[] save() {
    ArrayList<String> lines = new ArrayList<String>();
    Field[] fields = getClass().getDeclaredFields();
    lines.add("<config>");
    for (Field f : fields) {
      if (isConfigItem(f)) {
        Object obj;
        try {
          f.setAccessible(true);
          obj = f.get(this);
        } catch (IllegalAccessException e) {
          e.printStackTrace();
          continue;
        }
        if (obj instanceof ConfigParser) {
          lines.add("<" + f.getName() + ">");
          ConfigParser parser = (ConfigParser) obj;
          parser.save(lines);
          lines.add("</" + f.getName() + ">");
        } else {
          String item_name = f.getName();
          if (!Modifier.isTransient(f.getModifiers())) {
            lines.add("<" + item_name + ">" + obj.toString() + "</" + item_name + ">");
          }
        }
      }
    }
    lines.add("</config>");

    return lines.toArray(new String[lines.size()]);
  }
Exemplo n.º 9
0
 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;
 }
  /**
   * Applications which override this can do custom serialization.
   *
   * @param object the object to write.
   */
  public void writeObjectImpl(Object obj) throws IOException {
    Class cl = obj.getClass();

    try {
      Method method = cl.getMethod("writeReplace", new Class[0]);
      Object repl = method.invoke(obj, new Object[0]);

      writeObject(repl);
      return;
    } catch (Exception e) {
    }

    try {
      writeMapBegin(cl.getName());
      for (; cl != null; cl = cl.getSuperclass()) {
        Field[] fields = cl.getDeclaredFields();
        for (int i = 0; i < fields.length; i++) {
          Field field = fields[i];

          if (Modifier.isTransient(field.getModifiers()) || Modifier.isStatic(field.getModifiers()))
            continue;

          // XXX: could parameterize the handler to only deal with public
          field.setAccessible(true);

          writeString(field.getName());
          writeObject(field.get(obj));
        }
      }
      writeMapEnd();
    } catch (IllegalAccessException e) {
      throw new IOExceptionWrapper(e);
    }
  }
Exemplo n.º 11
0
 public String process() {
   if (this.type.getCanonicalName() == null) {
     //          new RuntimeException( "Ignoring anonymous class: " + this.type
     // ).printStackTrace( );
   } else {
     this.elem(Elem.mapping);
     if (this.abs) {
       this.attr("abstract", "true");
     } else {
       this.attr("name", this.type.getSimpleName())
           .attr("extends", this.type.getSuperclass().getCanonicalName());
     }
     this.attr("class", this.type.getCanonicalName());
     if (BindingFileSearch.INSTANCE.MSG_BASE_CLASS.isAssignableFrom(this.type.getSuperclass())
         || BindingFileSearch.INSTANCE.MSG_DATA_CLASS.isAssignableFrom(
             this.type.getSuperclass())) {
       this.elem(Elem.structure)
           .attr("map-as", this.type.getSuperclass().getCanonicalName())
           .end();
     }
     for (Field f : this.type.getDeclaredFields()) {
       if (!Ats.from(f).has(Transient.class) || Modifier.isTransient(f.getModifiers())) {
         TypeBinding tb = getTypeBinding(f);
         if (!(tb instanceof NoopTypeBinding)) {
           //                System.out.printf( "BOUND:  %-70s [type=%s:%s]\n",
           // f.getDeclaringClass( ).getCanonicalName( ) +"."+ f.getName( ), tb.getTypeName( ),
           // f.getType( ).getCanonicalName( ) );
           this.append(tb.toString());
         }
       }
     }
     this.end();
   }
   return this.toString();
 }
Exemplo n.º 12
0
  /**
   * Appends the fields and values defined by the given object of the given Class.
   *
   * @param lhs the left hand object
   * @param rhs the right hand object
   * @param clazz the class to append details of
   * @param builder the builder to append to
   * @param useTransients whether to test transient fields
   * @param excludeFields array of field names to exclude from testing
   */
  private static void reflectionAppend(
      Object lhs,
      Object rhs,
      Class<?> clazz,
      EqualsBuilder builder,
      boolean useTransients,
      String[] excludeFields) {

    if (isRegistered(lhs, rhs)) {
      return;
    }

    try {
      register(lhs, rhs);
      Field[] fields = clazz.getDeclaredFields();
      AccessibleObject.setAccessible(fields, true);
      for (int i = 0; i < fields.length && builder.isEquals; i++) {
        Field f = fields[i];
        if (!Arrays.contains(excludeFields, f.getName())
            && (f.getName().indexOf('$') == -1)
            && (useTransients || !Modifier.isTransient(f.getModifiers()))
            && (!Modifier.isStatic(f.getModifiers()))) {
          try {
            builder.append(f.get(lhs), f.get(rhs));
          } catch (IllegalAccessException e) {
            // this can't happen. Would get a Security exception instead
            // throw a runtime exception in case the impossible happens.
            throw new InternalError("Unexpected IllegalAccessException");
          }
        }
      }
    } finally {
      unregister(lhs, rhs);
    }
  }
Exemplo n.º 13
0
  private void writeToFile(final Object object, final int depth, final Class clazz)
      throws IllegalAccessException {
    for (Field field : clazz.getDeclaredFields()) {
      final int modifier = field.getModifiers();
      if (Modifier.isPrivate(modifier)
          && !Modifier.isTransient(modifier)
          && !Modifier.isStatic(modifier)) {
        field.setAccessible(true);

        final Object data = field.get(object);
        if (writeKey(field, depth, data)) {
          continue;
        }
        if (data instanceof StorageObject) {
          writer.println();
          writeToFile(data, depth + 1, data.getClass());
        } else if (data instanceof Map) {
          writeMap((Map<Object, Object>) data, depth + 1);
        } else if (data instanceof Collection) {
          writeCollection((Collection<Object>) data, depth + 1);
        } else if (data instanceof Location) {
          writeLocation((Location) data, depth + 1);
        } else {
          writeScalar(data);
          writer.println();
        }
      }
    }
  }
Exemplo n.º 14
0
  /**
   * This method uses reflection to build a valid hash code.
   *
   * <p>It uses <code>AccessibleObject.setAccessible</code> to gain access to private fields. This
   * means that it will throw a security exception if run under a security manager, if the
   * permissions are not set up correctly. It is also not as efficient as testing explicitly.
   *
   * <p>Transient members will not be used, as they are likely derived fields, and not part of the
   * value of the <code>Object</code>.
   *
   * <p>Static fields will not be tested. Superclass fields will be included.
   *
   * @param obj the object to create a <code>hashCode</code> for
   * @return the generated hash code, or zero if the given object is <code>null</code>
   */
  public static int reflectionHashCode(Object obj) {
    if (obj == null) return 0;

    Class<?> targetClass = obj.getClass();
    if (isArrayOfPrimitives(obj)) {
      // || ObjectUtils.isPrimitiveOrWrapper(targetClass)) {
      return ObjectUtils.nullSafeHashCode(obj);
    }

    if (targetClass.isArray()) {
      return reflectionHashCode((Object[]) obj);
    }

    if (obj instanceof Collection) {
      return reflectionHashCode((Collection<?>) obj);
    }

    if (obj instanceof Map) {
      return reflectionHashCode((Map<?, ?>) obj);
    }

    // determine whether the object's class declares hashCode() or has a
    // superClass other than java.lang.Object that declares hashCode()
    Class<?> clazz = (obj instanceof Class) ? (Class<?>) obj : obj.getClass();
    Method hashCodeMethod = ReflectionUtils.findMethod(clazz, "hashCode", new Class[0]);

    if (hashCodeMethod != null) {
      return obj.hashCode();
    }

    // could not find a hashCode other than the one declared by
    // java.lang.Object
    int hash = INITIAL_HASH;

    try {
      while (targetClass != null) {
        Field[] fields = targetClass.getDeclaredFields();
        AccessibleObject.setAccessible(fields, true);

        for (int i = 0; i < fields.length; i++) {
          Field field = fields[i];
          int modifiers = field.getModifiers();

          if (!Modifier.isStatic(modifiers) && !Modifier.isTransient(modifiers)) {
            hash = MULTIPLIER * hash + reflectionHashCode(field.get(obj));
          }
        }
        targetClass = targetClass.getSuperclass();
      }
    } catch (IllegalAccessException exception) {
      // ///CLOVER:OFF
      ReflectionUtils.handleReflectionException(exception);
      // ///CLOVER:ON
    }

    return hash;
  }
Exemplo n.º 15
0
 private void writeObject(java.io.ObjectOutputStream out)
     throws IOException, IllegalAccessException {
   Field[] fields = this.getClass().getDeclaredFields();
   for (Field field : fields) {
     if (!"serialVersionUID".equals(field.getName())
         && !Modifier.isTransient(field.getModifiers())) {
       Object obj = field.get(this);
       out.writeObject(obj);
     }
   }
 }
Exemplo n.º 16
0
 private void readObject(java.io.ObjectInputStream in)
     throws IOException, ClassNotFoundException, IllegalAccessException {
   Field[] fields = this.getClass().getDeclaredFields();
   for (Field field : fields) {
     if (!"serialVersionUID".equals(field.getName())
         && !Modifier.isTransient(field.getModifiers())) {
       field.setAccessible(true);
       field.set(this, in.readObject());
     }
   }
 }
Exemplo n.º 17
0
  /** Creates a map of the classes fields. */
  protected HashMap getFieldMap(Class cl) {
    HashMap fieldMap = new HashMap();

    for (; cl != null; cl = cl.getSuperclass()) {
      Field[] fields = cl.getDeclaredFields();
      for (int i = 0; i < fields.length; i++) {
        Field field = fields[i];

        if (Modifier.isTransient(field.getModifiers()) || Modifier.isStatic(field.getModifiers()))
          continue;
        else if (fieldMap.get(field.getName()) != null) continue;

        // XXX: could parameterize the handler to only deal with public
        try {
          field.setAccessible(true);
        } catch (Throwable e) {
          e.printStackTrace();
        }

        Class type = field.getType();
        FieldDeserializer deser;

        if (String.class.equals(type)) deser = new StringFieldDeserializer(field);
        else if (byte.class.equals(type)) {
          deser = new ByteFieldDeserializer(field);
        } else if (short.class.equals(type)) {
          deser = new ShortFieldDeserializer(field);
        } else if (int.class.equals(type)) {
          deser = new IntFieldDeserializer(field);
        } else if (long.class.equals(type)) {
          deser = new LongFieldDeserializer(field);
        } else if (float.class.equals(type)) {
          deser = new FloatFieldDeserializer(field);
        } else if (double.class.equals(type)) {
          deser = new DoubleFieldDeserializer(field);
        } else if (boolean.class.equals(type)) {
          deser = new BooleanFieldDeserializer(field);
        } else if (java.sql.Date.class.equals(type)) {
          deser = new SqlDateFieldDeserializer(field);
        } else if (java.sql.Timestamp.class.equals(type)) {
          deser = new SqlTimestampFieldDeserializer(field);
        } else if (java.sql.Time.class.equals(type)) {
          deser = new SqlTimeFieldDeserializer(field);
        } else {
          deser = new ObjectFieldDeserializer(field);
        }

        fieldMap.put(field.getName(), deser);
      }
    }

    return fieldMap;
  }
Exemplo n.º 18
0
 private static void collectFieldAccessors(Class<?> aClass, List<Accessor> accessors) {
   for (Field field : aClass.getFields()) {
     final int modifiers = field.getModifiers();
     if (Modifier.isPublic(modifiers)
         && !Modifier.isStatic(modifiers)
         && !Modifier.isFinal(modifiers)
         && !Modifier.isTransient(modifiers)
         && field.getAnnotation(Transient.class) == null) {
       accessors.add(new FieldAccessor(field));
     }
   }
 }
  private static void findProperties(Class<?> clazz, Map<String, Property> properties) {
    Class<?> superClass = clazz.getSuperclass(); // Process super classes first
    if (superClass != null) findProperties(superClass, properties);

    for (Field field : clazz.getDeclaredFields()) {
      int modifiers = field.getModifiers();
      if (!Modifier.isStatic(modifiers)
          && !Modifier.isTransient(modifiers)
          && !properties.containsKey(field.getName())) {
        properties.put(Helper.toLowerCase(field.getName()), new FieldProperty(field));
      }
    }
  }
 /**
  * Performs a deep comparison (using reflection) of two objects to determine whether they are
  * different.
  *
  * <p>If the object is a Question then the answer is treated specially because the original value
  * of the answer from our point of view is the value provided by the client in an Answer fact. If
  * no such fact exists then the value on the question itself is used. Scenarios are:
  *
  * <ul>
  *   <li>Question which client has just answered - the new object is different if the answer is
  *       not the value provided by the client. i.e. if the rules have changed it to something else
  *       e.g. converting text to upper case.
  *   <li>Another question - the new object is different if the answer is not the value on the
  *       original object.
  * </ul>
  *
  * @param originalObject
  * @param newObject
  * @return
  */
 private boolean different(TohuObject originalObject, TohuObject newObject) {
   if (!originalObject.equals(newObject)) {
     return true;
   }
   // special handling for Question answers
   if (originalObject instanceof Question) {
     Question originalQuestion = (Question) originalObject;
     String originalAnswer;
     if (clientAnswers != null && clientAnswers.containsKey(originalQuestion.getId())) {
       // original answer is the one provided by the client
       originalAnswer = clientAnswers.get(originalQuestion.getId());
     } else {
       // original answer not provided by client so is contained in the original question
       originalAnswer =
           originalQuestion.getAnswer() == null ? null : originalQuestion.getAnswer().toString();
     }
     Question newQuestion = (Question) newObject;
     String newAnswer =
         newQuestion.getAnswer() == null ? null : newQuestion.getAnswer().toString();
     if (originalAnswer == null ? newAnswer != null : !originalAnswer.equals(newAnswer)) {
       return true;
     }
   }
   Class<?> clazz = originalObject.getClass();
   do {
     // compare all non-static non-transient fields
     for (Field field : clazz.getDeclaredFields()) {
       int modifiers = field.getModifiers();
       if (!Modifier.isStatic(modifiers) && !Modifier.isTransient(modifiers)) {
         boolean answerField = field.isAnnotationPresent(Question.AnswerField.class);
         // answer fields are skipped because we have checked this already
         if (!answerField) {
           field.setAccessible(true);
           try {
             Object originalValue = field.get(originalObject);
             Object newValue = field.get(newObject);
             if (originalValue == null ? newValue != null : !originalValue.equals(newValue)) {
               return true;
             }
           } catch (IllegalArgumentException e) {
             throw new RuntimeException(e);
           } catch (IllegalAccessException e) {
             throw new RuntimeException(e);
           }
         }
       }
     }
     clazz = clazz.getSuperclass();
   } while (clazz != null);
   return false;
 }
 @SuppressWarnings("unchecked")
 @Test
 public void FullySerializable() {
   Set<Class<?>> checked = new HashSet<Class<?>>();
   checked.addAll(
       Arrays.asList(
           Collection.class,
           List.class,
           Set.class,
           Map.class,
           Object.class,
           String.class,
           Class.class));
   Stack<Class<?>> classes = new Stack<Class<?>>();
   classes.addAll(
       Arrays.<Class<?>>asList(
           NumberPath.class,
           NumberOperation.class,
           NumberTemplate.class,
           BeanPath.class,
           DefaultQueryMetadata.class));
   while (!classes.isEmpty()) {
     Class<?> clazz = classes.pop();
     checked.add(clazz);
     if (!Serializable.class.isAssignableFrom(clazz) && !clazz.isPrimitive()) {
       fail(clazz.getName() + " is not serializable");
     }
     for (Field field : clazz.getDeclaredFields()) {
       if (Modifier.isTransient(field.getModifiers())) {
         continue;
       }
       Set<Class<?>> types = new HashSet<Class<?>>(3);
       types.add(field.getType());
       if (field.getType().getSuperclass() != null) {
         types.add(field.getType().getSuperclass());
       }
       if (field.getType().getComponentType() != null) {
         types.add(field.getType().getComponentType());
       }
       if (Collection.class.isAssignableFrom(field.getType())) {
         types.add(ReflectionUtils.getTypeParameterAsClass(field.getGenericType(), 0));
       } else if (Map.class.isAssignableFrom(field.getType())) {
         types.add(ReflectionUtils.getTypeParameterAsClass(field.getGenericType(), 0));
         types.add(ReflectionUtils.getTypeParameterAsClass(field.getGenericType(), 1));
       }
       types.removeAll(checked);
       classes.addAll(types);
     }
   }
 }
Exemplo n.º 22
0
 private boolean _isIncludableField(Field f) {
   /* I'm pretty sure synthetic fields are to be skipped...
    * (methods definitely are)
    */
   if (f.isSynthetic()) {
     return false;
   }
   // Static fields are never included, nor transient
   int mods = f.getModifiers();
   if (Modifier.isStatic(mods) || Modifier.isTransient(mods)) {
     return false;
   }
   return true;
 }
Exemplo n.º 23
0
 /** setModifiers - set the attribute values related to modifiers here */
 protected void setModifiers() {
   Field javaFieldTarget = (Field) getTarget();
   // For JDK reflection, I don't think we can set the initializer
   int modifiers = getSourceField().getModifiers();
   javaFieldTarget.setStatic(java.lang.reflect.Modifier.isStatic(modifiers));
   javaFieldTarget.setTransient(java.lang.reflect.Modifier.isTransient(modifiers));
   javaFieldTarget.setVolatile(java.lang.reflect.Modifier.isVolatile(modifiers));
   javaFieldTarget.setFinal(java.lang.reflect.Modifier.isFinal(modifiers));
   // Set visibility
   if (java.lang.reflect.Modifier.isPublic(modifiers))
     javaFieldTarget.setJavaVisibility(JavaVisibilityKind.PUBLIC_LITERAL);
   else if (java.lang.reflect.Modifier.isPrivate(modifiers))
     javaFieldTarget.setJavaVisibility(JavaVisibilityKind.PRIVATE_LITERAL);
   else if (java.lang.reflect.Modifier.isProtected(modifiers))
     javaFieldTarget.setJavaVisibility(JavaVisibilityKind.PROTECTED_LITERAL);
   else javaFieldTarget.setJavaVisibility(JavaVisibilityKind.PACKAGE_LITERAL);
 }
Exemplo n.º 24
0
 /** Checks if the field is accepted as a JAXB property. */
 static boolean isFieldAccepted(Field field, XmlAccessType accessType) {
   // We only accept non static fields which are not marked @XmlTransient or has transient modifier
   if (field.isAnnotationPresent(XmlTransient.class)
       || Modifier.isTransient(field.getModifiers())) {
     return false;
   }
   if (Modifier.isStatic(field.getModifiers())) {
     return field.isAnnotationPresent(XmlAttribute.class);
   }
   if (accessType == XmlAccessType.PUBLIC_MEMBER && !Modifier.isPublic(field.getModifiers())) {
     return false;
   }
   if (accessType == XmlAccessType.NONE || accessType == XmlAccessType.PROPERTY) {
     return checkJaxbAnnotation(field.getAnnotations());
   } else {
     return true;
   }
 }
Exemplo n.º 25
0
  /**
   * DOCUMENT ME!
   *
   * @param object DOCUMENT ME!
   * @return DOCUMENT ME!
   * @throws FloggyException DOCUMENT ME!
   */
  public static ContentValues getValues(Object object) throws FloggyException {
    ContentValues values = new ContentValues();

    Field[] fields = object.getClass().getDeclaredFields();

    for (Field field : fields) {
      try {
        int modifier = field.getModifiers();

        if (!(Modifier.isStatic(modifier) || Modifier.isTransient(modifier))) {
          String fieldName = field.getName();
          Class fieldType = field.getType();

          try {
            Object value = Utils.getProperty(object, fieldName);

            if (fieldType.equals(boolean.class) || fieldType.equals(Boolean.class)) {
              values.put(field.getName(), (Boolean) value);
            } else if (fieldType.equals(byte.class) || fieldType.equals(Byte.class)) {
              values.put(field.getName(), (Byte) value);
            } else if (fieldType.equals(double.class) || fieldType.equals(Double.class)) {
              values.put(field.getName(), (Double) value);
            } else if (fieldType.equals(float.class) || fieldType.equals(Float.class)) {
              values.put(field.getName(), (Float) value);
            } else if (fieldType.equals(int.class) || fieldType.equals(Integer.class)) {
              values.put(field.getName(), (Integer) value);
            } else if (fieldType.equals(long.class) || fieldType.equals(Long.class)) {
              values.put(field.getName(), (Long) value);
            } else if (fieldType.equals(short.class) || fieldType.equals(Short.class)) {
              values.put(field.getName(), (Short) value);
            } else if (fieldType.equals(String.class)) {
              values.put(field.getName(), (String) value);
            }
          } catch (NoSuchMethodException nsmex) {
            continue;
          }
        }
      } catch (Exception ex) {
        throw Utils.handleException(ex);
      }
    }

    return values;
  }
Exemplo n.º 26
0
  /**
   * Method dumpDumpable
   *
   * @param dumpable object to dump
   */
  private void dumpDumpable(Dumpable dumpable) {
    buffer.append('[');

    Iterator fields = FieldHelper.getNonStaticFields(dumpable.getClass(), Object.class).iterator();

    while (fields.hasNext()) {
      Field field = (Field) fields.next();

      if (!Modifier.isTransient(field.getModifiers())) {
        dumpField(field, dumpable);

        if (fields.hasNext()) {
          buffer.append(", ");
        }
      }
    }

    buffer.append(']');
  }
  /**
   * Return the list of fields of the object except for those with the @DoNotSerizalize annotation.
   *
   * @return
   */
  @Override
  public List<Field> getSerializableFields() {
    List<Field> typeFields = new ArrayList<Field>();

    ReflectionUtils.getAllFields(typeFields, getClass());

    List<Field> toStore = new ArrayList<Field>();
    for (Field field : typeFields) {
      if (!field.isAnnotationPresent(com.orm.dsl.Ignore.class)
          && !field.isAnnotationPresent(Ignore.class)
          && !field.isAnnotationPresent(DoNotSerialize.class)
          && !field.isAnnotationPresent(cl.niclabs.adkmobile.data.DoNotSerialize.class)
          && !Modifier.isStatic(field.getModifiers())
          && !Modifier.isTransient(field.getModifiers())) {
        toStore.add(field);
      }
    }
    return toStore;
  }
Exemplo n.º 28
0
 /** Returns a list of all non-transient non-static fields that are declared in the given class. */
 static List<FieldInfo> getInstanceFields(Class cls, ClassMetadata clsMeta) {
   List<FieldInfo> fields = null;
   if (clsMeta != null) {
     Collection<FieldMetadata> persistentFields = clsMeta.getPersistentFields();
     if (persistentFields != null) {
       fields = new ArrayList<FieldInfo>(persistentFields.size());
       String clsName = cls.getName();
       for (FieldMetadata fieldMeta : persistentFields) {
         if (!clsName.equals(fieldMeta.getDeclaringClassName())) {
           throw new IllegalArgumentException(
               "Persistent field " + fieldMeta + " must be declared in " + clsName);
         }
         Field field;
         try {
           field = cls.getDeclaredField(fieldMeta.getName());
         } catch (NoSuchFieldException e) {
           throw new IllegalArgumentException(
               "Persistent field " + fieldMeta + " is not declared in this class");
         }
         if (!field.getType().getName().equals(fieldMeta.getClassName())) {
           throw new IllegalArgumentException(
               "Persistent field " + fieldMeta + " must be of type " + field.getType().getName());
         }
         if (Modifier.isStatic(field.getModifiers())) {
           throw new IllegalArgumentException(
               "Persistent field " + fieldMeta + " may not be static");
         }
         fields.add(new FieldInfo(field));
       }
     }
   }
   if (fields == null) {
     Field[] declaredFields = cls.getDeclaredFields();
     fields = new ArrayList<FieldInfo>(declaredFields.length);
     for (Field field : declaredFields) {
       int mods = field.getModifiers();
       if (!Modifier.isTransient(mods) && !Modifier.isStatic(mods)) {
         fields.add(new FieldInfo(field));
       }
     }
   }
   return fields;
 }
Exemplo n.º 29
0
  /** Creates a map of the classes fields. */
  protected HashMap getFieldMap(Class cl) {
    HashMap fieldMap = new HashMap();

    for (; cl != null; cl = cl.getSuperclass()) {
      Field[] fields = cl.getDeclaredFields();
      for (int i = 0; i < fields.length; i++) {
        Field field = fields[i];

        if (Modifier.isTransient(field.getModifiers()) || Modifier.isStatic(field.getModifiers()))
          continue;

        // XXX: could parameterize the handler to only deal with public
        field.setAccessible(true);

        fieldMap.put(field.getName(), field);
      }
    }

    return fieldMap;
  }
Exemplo n.º 30
0
 private void initProperties() {
   synchronized (this) {
     if (properties != null) return;
     properties = new HashMap<String, Model.Property>();
     Set<Field> fields = getModelFields(clazz);
     for (Field f : fields) {
       int mod = f.getModifiers();
       if (Modifier.isTransient(mod) || Modifier.isStatic(mod)) {
         continue;
       }
       if (f.isAnnotationPresent(Transient.class)) {
         continue;
       }
       Model.Property mp = buildProperty(f);
       if (mp != null) {
         properties.put(mp.name, mp);
       }
     }
   }
 }