Albert Strasheim <fullung@...> writes:

Hello,

Well, I do not pretend that this solution is well implemented or bug free, since it took me not that much time to realize :).

Two annotations are defined :

- IgnoreField to specify that the following field must not be included in the equivalent structure. The wanted behavior is to include all fields by default and exclude some of them if necessary. - FieldOrder to specify with an integer with is the field position in the resulting structure

For instance, the following class :

public class MyStruct extends Structure { @IgnoreField public int[] pouet = new int[4];

@FieldOrder(2) public int two;

@FieldOrder(1) public int one; }

is expected to be seen as :

struct MyStruct { int one; int two; };

The fields are sorted according to their FieldOrder value. To help with this task, a class CustomField is provided (the Field class is made Comparable). There may be fields without the FieldOrder annotation. They are placed at the end of the ordered list, keeping the java definition order : This modification remains compatible with the existing implementation. [1][2]

Here are some code excerpt :

// The IgnoreField annotation @Target(ElementType.FIELD) @Retention(RetentionPolicy.RUNTIME) public @interface IgnoreField { }

// The FieldOrder annotation @Target(ElementType.FIELD) @Retention(RetentionPolicy.RUNTIME) public @interface FieldOrder { int value() default 0; }

/** * The CustomField class * @author nvienne * */ public class CustomField implements Comparable<CustomField>{ private int order = 0; private Field field = null; private boolean active = false; private boolean ordered = false;

public CustomField(Field f) { field = f; if(f.getAnnotation(IgnoreField.class) == null) { active = true; } if(f.getAnnotation(FieldOrder.class) != null) { order = f.getAnnotation(FieldOrder.class).value(); ordered = true; } }

public boolean isActive() { return active; } public boolean isOrdered() { return ordered; } public int getOrder() { return order; } public Field getField() { return field; }

public int compareTo(CustomField arg0) { if(order < arg0.getOrder()) return -1; else if (order == arg0.getOrder()) return 0; else return 1; } }

Structure.java was modified in the beginning of the function calculateSize :

/** * BEGIN CODE MODIFICATION */ Field[] class_fields = getClass().getFields(); List<CustomField> ordered_fields = new ArrayList<CustomField>(); List<CustomField> unordered_fields = new ArrayList<CustomField>(); for (int i=0; i<class_fields.length; i++) { CustomField cf = new CustomField(class_fields[i]); if(cf.isActive()) { if(cf.isOrdered()) ordered_fields.add(cf); else { unordered_fields.add(cf); } } } Collections.sort(ordered_fields); ordered_fields.addAll(unordered_fields); CustomField[] fields = new CustomField[ordered_fields.size()]; fields = ordered_fields.toArray(fields);

//Field[] fields = getClass().getFields();

if (REVERSE_FIELDS) { for (int i=0;i < fields.length/2;i++) { int idx = fields.length-1-i; //Field tmp = fields[i]; CustomField tmp = fields[i]; fields[i] = fields[idx]; fields[idx] = tmp; } }

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

/** * END CODE MODIFICATION */

This last part is far from being perfect and - I think - could be improved.

Two more remarks : [1] The behavior of leaving the unannotated field at the end in their definition order may not be the best one. It's also possible to give them a field order equal to 0 (with the same field order value, the fields are ordered according to their definition order). Then, negative order values are placed before and positive ones after. [2] Only the public non-static fields are taken into account. This method may be a starting point to extend the concerned fields to protected or private annotated attributes. I've not tried this for now.

Regards,