feat: Enable annotation detection for inherited structures.

Author: Deanly

src/main/java/net/deanly/structlayout/codec/decode/StructDecoder.java

@@ -15,19 +15,20 @@ public static <T> StructDecodeResult<T> decode(Class<T> type, byte[] data, int s
             throw new InvalidDataOffsetException(startOffset, data.length);
         }
 
-        // 1. 인스턴스 생성
+        // 1. 디코딩할 객체의 인스턴스 생성
         T instance = ClassFactory.createNoArgumentsInstance(type);
 
-        // 2. 필드 정렬
-        Field[] fields = type.getDeclaredFields();
-        List<Field> orderedFields = FieldHelper.getOrderedFields(fields);
+        // 2. 상속 계층의 모든 필드 수집 및 정렬
+        List<Field> allFields = FieldHelper.getAllDeclaredFieldsIncludingSuperclasses(type);
+        List<Field> orderedFields = FieldHelper.getOrderedFields(allFields);
 
-        // 3. 디코딩 처리
+        // 3. 디코딩: 필드 순서대로 Byte 데이터를 객체 필드에 매핑
         int offset = startOffset;
         for (Field field : orderedFields) {
             offset += FieldProcessor.processField(instance, field, data, offset);
         }
 
+        // 4. 디코딩 결과 반환
         return StructDecodeResult.of(instance, offset - startOffset);
     }
 }

src/main/java/net/deanly/structlayout/codec/encode/StructEncoder.java

@@ -15,38 +15,65 @@ public static <T> byte[] encode(T instance) {
             return new byte[0]; // Null 객체는 빈 배열 반환
         }
 
-        // 1. 필드 정렬
-        Field[] fields = instance.getClass().getDeclaredFields();
-        List<Field> orderedFields = FieldHelper.getOrderedFields(fields);
+        // 1. 상속 계층 필드 가져오기
+        List<Field> allFields = getAllDeclaredFields(instance.getClass());
 
-        // 2. 필드 별 byte[] 처리
+        // 2. 필드 정렬
+        List<Field> orderedFields = FieldHelper.getOrderedFields(allFields);
+
+        // 3. 필드 처리 및 병합
         List<byte[]> fieldChunks = new ArrayList<>();
         for (Field field : orderedFields) {
             field.setAccessible(true);
             byte[] chunk = FieldProcessor.processField(instance, field);
             fieldChunks.add(chunk);
         }
 
-        // 3. 생성된 byte[] 병합 및 반환
+        // 4. 병합된 결과 반환
         return ByteArrayHelper.mergeChunks(fieldChunks);
     }
 
+    /**
+     * 상속 계층의 모든 필드를 가져오는 메서드
+     */
+    private static List<Field> getAllDeclaredFields(Class<?> clazz) {
+        List<Field> fields = new ArrayList<>();
+        while (clazz != null && clazz != Object.class) {
+            Field[] declaredFields = clazz.getDeclaredFields();
+            for (Field field : declaredFields) {
+                if (FieldHelper.isStructField(field)) { // `@Struct*` 관련 필드만 필터링
+                    fields.add(field);
+                }
+            }
+            clazz = clazz.getSuperclass(); // 부모 클래스로 이동
+        }
+        return fields;
+    }
+
 
     public static <T> void encodeWithDebug(T instance) {
         if (instance == null) {
             return;
         }
 
-        Field[] fields = instance.getClass().getDeclaredFields();
-        List<Field> orderedFields = FieldHelper.getOrderedFields(fields);
+        // 1. 상속 계층 필드 가져오기
+        List<Field> allFields = getAllDeclaredFields(instance.getClass());
 
-        List<FieldDebugInfo> debugInfos = new ArrayList<>();
+        // 2. 필드 정렬
+        List<Field> orderedFields = FieldHelper.getOrderedFields(allFields);
 
+        // 3. Debug 정보를 생성
+        List<FieldDebugInfo> debugInfos = new ArrayList<>();
         for (Field field : orderedFields) {
             field.setAccessible(true);
             debugInfos.addAll(FieldProcessor.processFieldRecursivelyWithDebug(instance, field, null));
         }
 
+        // 4. Debug 출력
+        printDebugInfo(debugInfos);
+    }
+
+    private static void printDebugInfo(List<FieldDebugInfo> debugInfos) {
         int offset = 0;
         int totalBytes = 0;
 

src/main/java/net/deanly/structlayout/codec/helpers/FieldHelper.java

@@ -42,6 +42,33 @@ public static List<Field> getOrderedFields(Field[] fields) {
         return orderedFields;
     }
 
+    /**
+     * Returns a list of fields from the given array that are annotated with specific annotations
+     * and orders them according to the order value defined in their annotations.
+     *
+     * The supported annotations are:
+     * - {@code StructSequenceField}
+     * - {@code StructObjectField}
+     * - {@code StructField}
+     * - {@code StructSequenceObjectField}
+     *
+     * @param fields the list of fields to be filtered and ordered
+     * @return a list of fields annotated with the supported annotations, ordered by their `order` value
+     */
+    public static List<Field> getOrderedFields(List<Field> fields) {
+        List<Field> orderedFields = new ArrayList<>();
+        for (Field field : fields) {
+            if (field.isAnnotationPresent(StructSequenceField.class) ||
+                    field.isAnnotationPresent(StructObjectField.class) ||
+                    field.isAnnotationPresent(StructField.class) ||
+                    field.isAnnotationPresent(StructSequenceObjectField.class)) {
+                orderedFields.add(field);
+            }
+        }
+        orderedFields.sort(Comparator.comparingInt(FieldHelper::getOrderValue));
+        return orderedFields;
+    }
+
     /**
      * Retrieves the order value of the given field based on its annotation.
      * The method checks for specific annotations in the following order:
@@ -69,6 +96,47 @@ public static int getOrderValue(Field field) {
         throw new FieldOrderException(field.getName());
     }
 
+    /**
+     * Checks if the given {@code Field} is annotated with any of the supported
+     * struct-related annotations: {@code StructField}, {@code StructSequenceField},
+     * {@code StructObjectField}, or {@code StructSequenceObjectField}.
+     *
+     * @param field the {@code Field} to be checked for struct-related annotations
+     * @return {@code true} if the field is annotated with one of the supported
+     *         struct-related annotations; {@code false} otherwise
+     */
+    public static boolean isStructField(Field field) {
+        return field.isAnnotationPresent(StructField.class)
+                || field.isAnnotationPresent(StructSequenceField.class)
+                || field.isAnnotationPresent(StructObjectField.class)
+                || field.isAnnotationPresent(StructSequenceObjectField.class);
+    }
+
+    /**
+     * Retrieves all declared fields from the specified class and its superclasses,
+     * filtering only those annotated with struct-related annotations.
+     *
+     * The method iterates through the class hierarchy, starting from the given
+     * class and moving up to its superclasses, excluding {@code Object.class}.
+     * For each class, it collects declared fields that satisfy the given filter criteria.
+     *
+     * @param clazz the class to inspect for declared fields, including fields
+     *              from its superclasses
+     * @return a list of fields that are declared in the class and its superclasses,
+     *         and are annotated with struct-related annotations
+     */
+    public static List<Field> getAllDeclaredFieldsIncludingSuperclasses(Class<?> clazz) {
+        List<Field> fields = new ArrayList<>();
+        while (clazz != null && clazz != Object.class) {
+            for (Field field : clazz.getDeclaredFields()) {
+                if (isStructField(field)) { // `@Struct*` 어노테이션 필터링
+                    fields.add(field);
+                }
+            }
+            clazz = clazz.getSuperclass(); // 부모 클래스로 이동
+        }
+        return fields;
+    }
 
     public static boolean isFieldTypeApplicable(Class<?> structFieldType, Class<? extends net.deanly.structlayout.Field<?>> fieldType) {
         // Field의 필드 타입 가져오기

src/test/java/net/deanly/structlayout/codec/StructInheritanceTest.java

@@ -0,0 +1,131 @@
+package net.deanly.structlayout.codec;
+
+import net.deanly.structlayout.annotation.StructField;
+import net.deanly.structlayout.annotation.StructObjectField;
+import net.deanly.structlayout.annotation.StructSequenceField;
+import net.deanly.structlayout.codec.decode.StructDecoder;
+import net.deanly.structlayout.codec.encode.StructEncoder;
+import net.deanly.structlayout.type.basic.*;
+import org.junit.jupiter.api.Test;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
+public class StructInheritanceTest {
+
+    // 부모 클래스 정의
+    public static class ParentStruct {
+        @StructField(order = 0, type = Int32LEField.class)
+        private int parentField1;
+
+        @StructField(order = 1, type = Int16LEField.class)
+        private short parentField2;
+
+        public ParentStruct() {
+        }
+
+        public ParentStruct(int parentField1, short parentField2) {
+            this.parentField1 = parentField1;
+            this.parentField2 = parentField2;
+        }
+
+        public int getParentField1() {
+            return parentField1;
+        }
+
+        public short getParentField2() {
+            return parentField2;
+        }
+    }
+
+    // 자식 클래스 정의
+    public static class ChildStruct extends ParentStruct {
+        @StructField(order = 2, type = ByteField.class)
+        private byte childField1;
+
+        @StructSequenceField(order = 3, lengthType = UInt8Field.class, elementType = Int32BEField.class)
+        private int[] childField2;
+
+        @StructObjectField(order = 4)
+        private NestedObject nestedObject;
+
+        public ChildStruct() {
+        }
+
+        public ChildStruct(int parentField1, short parentField2, byte childField1, int[] childField2, NestedObject nestedObject) {
+            super(parentField1, parentField2);
+            this.childField1 = childField1;
+            this.childField2 = childField2;
+            this.nestedObject = nestedObject;
+        }
+
+        public byte getChildField1() {
+            return childField1;
+        }
+
+        public int[] getChildField2() {
+            return childField2;
+        }
+
+        public NestedObject getNestedObject() {
+            return nestedObject;
+        }
+    }
+
+    // 중첩된 객체 정의
+    public static class NestedObject {
+        @StructField(order = 0, type = Int32BEField.class)
+        private int nestedField1;
+
+        @StructField(order = 1, type = Int16BEField.class)
+        private short nestedField2;
+
+        public NestedObject() {
+        }
+
+        public NestedObject(int nestedField1, short nestedField2) {
+            this.nestedField1 = nestedField1;
+            this.nestedField2 = nestedField2;
+        }
+
+        public int getNestedField1() {
+            return nestedField1;
+        }
+
+        public short getNestedField2() {
+            return nestedField2;
+        }
+    }
+
+    @Test
+    public void testEncodeDecodeInheritanceStruct() {
+        // 1. 테스트 데이터를 설정
+        int parentField1 = 42;
+        short parentField2 = 320;
+        byte childField1 = 7;
+        int[] childField2 = new int[]{10, 20, 30};
+        NestedObject nestedObject = new NestedObject(130, (short) 25);
+
+        ChildStruct original = new ChildStruct(parentField1, parentField2, childField1, childField2, nestedObject);
+
+        // 2. Encode 처리
+        byte[] encodedData = StructEncoder.encode(original);
+
+        // 3. Decode 처리
+        ChildStruct decoded = StructDecoder.decode(ChildStruct.class, encodedData, 0).getValue();
+
+        // 4. 부모 필드 검증
+        assertEquals(parentField1, decoded.getParentField1(), "ParentField1 did not match");
+        assertEquals(parentField2, decoded.getParentField2(), "ParentField2 did not match");
+
+        // 5. 자식 필드 검증
+        assertEquals(childField1, decoded.getChildField1(), "ChildField1 did not match");
+
+        for (int i = 0; i < childField2.length; i++) {
+            assertEquals(childField2[i], decoded.getChildField2()[i], "ChildField2[" + i + "] did not match");
+        }
+
+        // 6. 중첩 객체 검증
+        assertEquals(nestedObject.getNestedField1(), decoded.getNestedObject().getNestedField1(), "NestedField1 did not match");
+        assertEquals(nestedObject.getNestedField2(), decoded.getNestedObject().getNestedField2(), "NestedField2 did not match");
+    }
+}