feat: update ProtocolType

benchmark/src/test/java/org/indunet/fastproto/benchmark/Sample.java

@@ -22,8 +22,6 @@
 import org.indunet.fastproto.annotation.*;
 import org.indunet.fastproto.util.CodecUtils;
 
-import java.io.ByteArrayOutputStream;
-import java.nio.charset.StandardCharsets;
 import java.util.Random;
 import java.util.stream.IntStream;
 
@@ -77,7 +75,7 @@ public class Sample {
     public Sample() {
         val random = new Random();
 
-        this.bool1 = random.nextInt() % 2 == 0 ? true : false;
+        this.bool1 = random.nextBoolean();
         this.byte8 = (byte) random.nextInt(Byte.MAX_VALUE);
         this.short16 = (short) random.nextInt(Short.MAX_VALUE);
         this.int32 = random.nextInt();

src/main/java/org/indunet/fastproto/ProtocolType.java

@@ -16,6 +16,7 @@
 
 package org.indunet.fastproto;
 
+import lombok.val;
 import org.indunet.fastproto.annotation.*;
 
 import java.lang.annotation.Annotation;
@@ -45,6 +46,22 @@ public interface ProtocolType {
     Class<? extends Annotation> UINT64 = UInt64Type.class;
     Class<? extends Annotation> ENUM = EnumType.class;
 
+    static <T> T proxy(AutoType autoType, Class<T> dataTypeAnnotationClass) {
+        return (T) Proxy.newProxyInstance(ProtocolType.class.getClassLoader(), new Class<?>[] {dataTypeAnnotationClass}, (proxy, method, args) -> {
+            val mth = Arrays.stream(autoType.getClass().getMethods())
+                    .filter(m -> m.getName().equals(method.getName()))
+                    .findAny()
+                    .get();
+
+            if (Arrays.asList("offset", "byteOffset", "bitOffset", "length")
+                    .contains(mth.getName())) {
+                return ((int[]) mth.invoke(autoType, args))[0];
+            } else {
+                return mth.invoke(autoType, args);
+            }
+        });
+    }
+
     static ProtocolType proxy(Annotation typeAnnotation) {
         return (ProtocolType) Proxy.newProxyInstance(ProtocolType.class.getClassLoader(), new Class<?>[]{ProtocolType.class, typeAnnotation.annotationType()}, (proxy, method, args) -> {
             switch (method.getName()) {

src/main/java/org/indunet/fastproto/annotation/AutoType.java

@@ -18,13 +18,24 @@
 package org.indunet.fastproto.annotation;
 
 import org.indunet.fastproto.EndianPolicy;
+import org.indunet.fastproto.graph.resolve.validate.DecodingFormulaValidator;
+import org.indunet.fastproto.graph.resolve.validate.EncodingFormulaValidator;
+
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
 
 /**
  * Auto type.
  *
  * @author Deng Ran
  * @since 3.7.1
  */
+@DataType
+@Validator({DecodingFormulaValidator.class, EncodingFormulaValidator.class})
+@Target(ElementType.FIELD)
+@Retention(RetentionPolicy.RUNTIME)
 public @interface AutoType {
     int[] offset() default {};
 
@@ -37,4 +48,6 @@
     EndianPolicy[] endianPolicy() default {};
 
     String charset() default "UTF-8";
+
+    String name() default "";
 }

src/main/java/org/indunet/fastproto/annotation/EnumType.java

@@ -16,7 +16,6 @@
 
 package org.indunet.fastproto.annotation;
 
-import org.indunet.fastproto.EndianPolicy;
 import org.indunet.fastproto.graph.resolve.validate.DecodingFormulaValidator;
 import org.indunet.fastproto.graph.resolve.validate.EncodingFormulaValidator;
 

src/main/java/org/indunet/fastproto/codec/CodecMapper.java

@@ -21,6 +21,7 @@
 import org.indunet.fastproto.exception.CodecError;
 import org.indunet.fastproto.exception.CodecException;
 import org.indunet.fastproto.exception.DecodingException;
+import org.indunet.fastproto.exception.ResolveException;
 
 import java.lang.reflect.ParameterizedType;
 import java.lang.reflect.Type;
@@ -221,6 +222,16 @@ public static <T, R> Function<T, R> getFormula(Class<? extends Function> clazz)
         });
     }
 
+    public static Class getDataTypeAnnotationClass(Class fieldType) {
+        return codecMap.entrySet().stream()
+                .filter(e -> e.getValue().keySet().stream()
+                        .anyMatch(p -> p.test(fieldType)))
+                .map(Map.Entry::getKey)
+                .findAny()
+                .orElseThrow(() -> new ResolveException(
+                        String.format("%s is not supported", fieldType.getName())));
+    }
+
     public static Function<byte[], ?> getDecoder(CodecContext context, Class<? extends Function> clazz) {
         if (clazz != null) {
             val type = Arrays.stream(clazz.getGenericInterfaces())

src/main/java/org/indunet/fastproto/graph/resolve/TypeAnnotationFlow.java

@@ -18,10 +18,13 @@
 
 import lombok.val;
 import org.indunet.fastproto.ProtocolType;
+import org.indunet.fastproto.annotation.AutoType;
 import org.indunet.fastproto.annotation.DataType;
+import org.indunet.fastproto.codec.CodecMapper;
 import org.indunet.fastproto.exception.ResolveException;
 import org.indunet.fastproto.graph.Reference;
 
+import java.lang.annotation.Annotation;
 import java.util.Arrays;
 
 /**
@@ -40,10 +43,19 @@ public void process(Reference reference) {
                 .findAny()
                 .orElseThrow(ResolveException::new);
 
-        reference.setDataTypeAnnotation(typeAnnotation);
+        if (typeAnnotation instanceof AutoType) {
+            Class<? extends Annotation> type = CodecMapper.getDataTypeAnnotationClass((Class) field.getGenericType());
+            Annotation proxy =  (Annotation) ProtocolType.proxy((AutoType) typeAnnotation, type);
+
+            reference.setDataTypeAnnotation(proxy);
+            reference.setProtocolType(ProtocolType.proxy(proxy));
+        } else {
+            reference.setDataTypeAnnotation(typeAnnotation);
+            reference.setProtocolType(ProtocolType.proxy(typeAnnotation));
+        }
+
         reference.setReferenceType(Reference.ReferenceType.FIELD);
 
-        reference.setProtocolType(ProtocolType.proxy(typeAnnotation));
 
         this.forward(reference);
     }

src/main/java/org/indunet/fastproto/pipeline/encode/InferLengthFlow.java

@@ -17,8 +17,8 @@
 package org.indunet.fastproto.pipeline.encode;
 
 import lombok.val;
-import org.indunet.fastproto.exception.AddressingException;
 import org.indunet.fastproto.exception.CodecError;
+import org.indunet.fastproto.exception.ResolveException;
 import org.indunet.fastproto.graph.Reference;
 import org.indunet.fastproto.pipeline.FlowCode;
 import org.indunet.fastproto.pipeline.Pipeline;
@@ -41,15 +41,15 @@ public void process(PipelineContext context) {
                     val type = r.getProtocolType();
 
                     if (type.offset() < 0 || type.length() < 0) {
-                        throw new AddressingException(CodecError.UNABLE_INFER_LENGTH);
+                        throw new ResolveException(CodecError.UNABLE_INFER_LENGTH);
                     } else {
                         return type.offset() + type.size() + type.length();
                     }
                 }).max()
                 .orElse(0);
 
         if (max == 0) {
-            throw new AddressingException(CodecError.UNABLE_INFER_LENGTH);
+            throw new ResolveException(CodecError.UNABLE_INFER_LENGTH);
         } else {
             context.setDatagram(new byte[max]);
         }

src/test/java/org/indunet/fastproto/ProtocolTypeTest.java

@@ -18,10 +18,11 @@
 
 import lombok.SneakyThrows;
 import lombok.val;
+import org.indunet.fastproto.annotation.BoolType;
 import org.indunet.fastproto.annotation.UInt8Type;
 import org.junit.jupiter.api.Test;
 
-import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.*;
 
 /**
  * @author Deng Ran
@@ -30,7 +31,7 @@
 public class ProtocolTypeTest {
     @Test
     @SneakyThrows
-    public void testProxy() {
+    public void testProxy1() {
         val field = TestObj.class.getDeclaredField("value");
         val typeAnnotation = field.getAnnotation(UInt8Type.class);
         val proxy = ProtocolType.proxy(typeAnnotation);
@@ -39,6 +40,14 @@ public void testProxy() {
         assertEquals(UInt8Type.SIZE, proxy.size());
     }
 
+    @Test
+    public void testProxy2() {
+        val proxy = ProtocolType.proxy(null, BoolType.class);
+
+        assertTrue(proxy instanceof BoolType);
+        assertNotNull(ProtocolType.proxy(proxy));
+    }
+
     public static class TestObj {
         @UInt8Type(offset = 0)
         int value;

src/test/java/org/indunet/fastproto/api/auto/AutoObject.java → src/test/java/org/indunet/fastproto/api/auto/AutoTypeObject.java

@@ -16,15 +16,19 @@
 
 package org.indunet.fastproto.api.auto;
 
+import lombok.val;
 import org.indunet.fastproto.annotation.AutoType;
+import org.indunet.fastproto.util.CodecUtils;
+
+import java.util.Random;
 
 /**
  * Auto object.
  *
  * @author Deng Ran
  * @since 3.7.1
  */
-public class AutoObject {
+public class AutoTypeObject {
     @AutoType(byteOffset = 0, bitOffset = 1)
     Boolean bool1;
 
@@ -40,11 +44,25 @@ public class AutoObject {
     @AutoType(offset = 10)
     Long long64;
 
-    public AutoObject() {
+    public AutoTypeObject() {
+        val random = new Random();
 
+        this.bool1 = random.nextBoolean();
+        this.byte8 = (byte) random.nextInt(128);
+        this.short16 = (short) random.nextInt(Short.MAX_VALUE);
+        this.int32 = random.nextInt();
+        this.long64 = random.nextLong();
     }
 
     public byte[] toBytes() {
-        return null;
+        val bytes = new byte[20];
+
+        CodecUtils.boolType(bytes, 0, 1, this.bool1);
+        CodecUtils.byteType(bytes, 2, this.byte8);
+        CodecUtils.shortType(bytes, 4, this.short16);
+        CodecUtils.int32Type(bytes, 6, this.int32);
+        CodecUtils.int64Type(bytes, 10, this.long64);
+
+        return bytes;
     }
 }

src/test/java/org/indunet/fastproto/api/auto/AutoTest.java → src/test/java/org/indunet/fastproto/api/auto/AutoTypeTest.java

@@ -16,22 +16,33 @@
 
 package org.indunet.fastproto.api.auto;
 
+import lombok.val;
+import org.indunet.fastproto.FastProto;
 import org.junit.jupiter.api.Test;
 
+import static org.junit.jupiter.api.Assertions.assertArrayEquals;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
 /**
  * Unit test of auto type.
  *
  * @author Deng Ran
  * @since 3.7.1
  */
-public class AutoTest {
+public class AutoTypeTest {
     @Test
     public void testParse() {
+        val expected = new AutoTypeObject();
+        val bytes = expected.toBytes();
 
+        assertEquals(expected, FastProto.parse(bytes, AutoTypeObject.class));
     }
 
     @Test
     public void testToBytes() {
+        val object = new AutoTypeObject();
+        val expected = object.toBytes();
 
+        assertArrayEquals(expected, FastProto.toBytes(object, expected.length));
     }
 }