Feat: Complete Decoder implementation, refactor Encoder, add TypeConverter functionality

- Refactored `StructEncoder` for better maintainability and performance.
- Fully implemented `StructDecoder` for decoding structures from byte arrays.
- Introduced `TypeConverterHelper` functionality for robust type conversion between various types, including null value handling, primitives, and complex objects.
- Ensured consistent handling of null and default values across both Encoder and Decoder components.
- Added comprehensive tests for all new features, including type conversion validation and edge cases.

Author: Deanly

src/main/java/net/deanly/structlayout/StructLayout.java

@@ -1,8 +1,8 @@
 package net.deanly.structlayout;
 
 import net.deanly.structlayout.analysis.HexDumpUtil;
-import net.deanly.structlayout.codec.StructEncoder;
-import net.deanly.structlayout.codec.StructDecoder;
+import net.deanly.structlayout.codec.encode.StructEncoder;
+import net.deanly.structlayout.codec.decode.StructDecoder;
 
 public class StructLayout {
 

src/main/java/net/deanly/structlayout/analysis/CachedLayoutProvider.java

@@ -46,10 +46,17 @@ public class CachedLayoutProvider {
     }
 
     /**
-     * 주어진 DataType에 맞는 Layout을 가져옵니다.
+     * Retrieves a Layout instance corresponding to the specified DataType. If the layout
+     * instance is not already cached, it will attempt to create a new instance using the
+     * layout class provided by the DataType.
      *
-     * @param dataType DataType (엔디안을 포함한 데이터 타입)
-     * @return Layout<T> 인스턴스
+     * @param <T> The type of the value being processed by the Layout.
+     * @param dataType The DataType for which the Layout needs to be retrieved.
+     *                 Must not be null and must provide a valid layout definition.
+     * @return A Layout instance associated with the specified DataType.
+     *         Never null unless an unexpected error occurs.
+     * @throws LayoutInitializationException If the Layout cannot be instantiated or
+     *                                       there is an error during initialization.
      */
     @SuppressWarnings("unchecked")
     public static <T> Layout<T> getLayout(DataType dataType) {

src/main/java/net/deanly/structlayout/analysis/StructAnalyzer.java

@@ -11,6 +11,13 @@
 import java.lang.reflect.Modifier;
 import java.util.Collection;
 
+/**
+ * The StructAnalyzer class provides utilities to compute the total size of an
+ * object based on its annotated fields. It processes fields annotated with
+ * specific annotations, including {@code StructField}, {@code SequenceField},
+ * and {@code StructObjectField}, to calculate the byte layout of an object
+ * for structured serialization or other purposes.
+ */
 public class StructAnalyzer {
 
     /**

src/main/java/net/deanly/structlayout/annotation/SequenceField.java

@@ -7,22 +7,38 @@
 import java.lang.annotation.RetentionPolicy;
 import java.lang.annotation.Target;
 
+/**
+ * Annotation to define a sequence field within a structured layout.
+ * It targets fields that are part of a sequence with multiple elements
+ * and optionally specifies the type of length prefix and element data types.
+ */
 @Retention(RetentionPolicy.RUNTIME)
 @Target(ElementType.FIELD)
 public @interface SequenceField {
+
     /**
-     * Field's order in the structure
+     * Specifies the order of the field within a structured object or layout.
+     * The order determines the sequence in which the field will be processed,
+     * serialized, or deserialized in relation to other fields.
+     *
+     * @return the order of the field
      */
     int order();
 
     /**
-     * The data type of the length prefix, indicating the number of elements in the sequence.
-     * If null, no length prefix is used.
+     * Specifies the data type of the length prefix for a sequence field.
+     * This determines how the length of the sequence is represented, utilizing
+     * a specific data type from the {@link DataType} enum.
+     *
+     * @return the data type used to represent the length of the sequence,
+     *         with the default being {@code DataType.UINT32_LE}.
      */
     DataType lengthType() default DataType.UINT32_LE; // Default length type (nullable)
 
     /**
-     * Specifies the sequence element type using the Type enum.
+     * Specifies the data type of the elements in the sequence.
+     *
+     * @return the data type of elements, as defined by the {@link DataType} enum
      */
     DataType elementType(); // Type of the elements in the sequence