Improve the function, complete the code, update the README content.

Author: shengyanli1982

README.md

@@ -67,7 +67,19 @@ func main() {
 -   Composite types: strings, byte slices, arrays
 -   Special types: padding bytes for alignment
 
-### 2. Smart Field Tags
+### 2. Automatic Size Tracking
+
+-   Automatically manages lengths of variable-sized fields
+-   Eliminates manual size calculation and tracking
+-   Reduces potential errors in binary protocol implementations
+
+### 3. Performance Optimizations
+
+-   Reflection caching for repeated operations
+-   Efficient memory allocation
+-   Optimized encoding/decoding paths
+
+### 4. Smart Field Tags
 
 ```go
 type Example struct {
@@ -78,7 +90,7 @@ type Example struct {
 }
 ```
 
-### 3. Struct Tag Reference
+### 5. Struct Tag Reference
 
 The `struc` tag supports various formats and options for precise binary data control:
 
@@ -152,10 +164,12 @@ type ByteOrderTypes struct {
 type SpecialTypes struct {
     // Skip this field during packing/unpacking
     Ignored  int    `struc:"skip"`
+    // Completely ignore this field (won't be included in binary)
+    Private  string `struc:"-"`
     // Size reference from another field
     Data     []byte `struc:"sizefrom=Size"`
     // Custom type implementation
-    Custom   Custom
+    YourCustomType   CustomBinaryer
 }
 ```
 
@@ -165,42 +179,110 @@ Tag Format: `struc:"type,option1,option2"`
 -   `big`/`little`: Byte order specification
 -   `sizeof=Field`: Specify this field tracks another field's size
 -   `sizefrom=Field`: Specify this field's size is tracked by another field
--   `skip`: Skip this field during packing/unpacking
+-   `skip`: Skip this field during packing/unpacking (space is reserved in binary)
+-   `-`: Completely ignore this field (not included in binary)
 -   `[N]type`: Fixed-size array of type with length N
 -   `[]type`: Dynamic-size array/slice of type
 
-### 4. Automatic Size Tracking
+#### Why `omitempty` is not supported?
 
--   Automatically manages lengths of variable-sized fields
--   Eliminates manual size calculation and tracking
--   Reduces potential errors in binary protocol implementations
+Unlike JSON serialization where fields can be optionally omitted, binary serialization requires a strict and fixed byte layout. Here's why `omitempty` is not supported:
 
-### 5. Performance Optimizations
+1. **Fixed Binary Layout**
 
--   Reflection caching for repeated operations
--   Efficient memory allocation
--   Optimized encoding/decoding paths
+    - Binary protocols require precise byte positioning
+    - Each field must occupy its predefined position and size
+    - Omitting fields would break the byte alignment
+
+2. **Parsing Dependencies**
+
+    - Binary data is parsed sequentially, byte by byte
+    - If fields are omitted, the byte stream becomes misaligned
+    - The receiving end cannot correctly reconstruct the data structure
+
+3. **Protocol Stability**
+
+    - Binary protocols need strict version control
+    - Allowing optional fields would break protocol stability
+    - Makes it impossible to maintain backward compatibility
+
+4. **Debugging Complexity**
+    - With omitted fields, binary data becomes unpredictable
+    - Makes it extremely difficult to debug byte streams
+    - Increases the complexity of troubleshooting
+
+If you need to mark certain fields as optional, consider these alternatives:
+
+-   Use explicit flag fields to indicate validity
+-   Use default values for optional fields
+-   Use the `struc:"-"` tag to completely exclude fields from serialization
 
 ## Advanced Usage
 
-### Custom Endianness
+### Custom Type Implementation
+
+If you need complete control over how a type is serialized and deserialized in binary format, you can implement the `CustomBinaryer` interface:
 
 ```go
-type Custom struct {
-    BigEndian    int32  `struc:"big"`    // Explicit big-endian
-    LittleEndian int32  `struc:"little"` // Explicit little-endian
+type CustomBinaryer interface {
+    // Pack serializes data into a byte slice
+    Pack(p []byte, opt *Options) (int, error)
+
+    // Unpack deserializes data from a Reader
+    Unpack(r io.Reader, length int, opt *Options) error
+
+    // Size returns the size of serialized data
+    Size(opt *Options) int
+
+    // String returns the string representation of the type
+    String() string
 }
 ```
 
-### Fixed-Size Arrays
+For example, implementing a 3-byte integer type:
 
 ```go
-type FixedArray struct {
-    Data [16]byte `struc:"[16]byte"` // Fixed-size byte array
-    Ints [4]int32 `struc:"[4]int32"` // Fixed-size integer array
+// Usage example
+type Message struct {
+    Value CustomBinaryer  // Using custom type
+}
+
+// Int3 is a custom 3-byte integer type
+type Int3 uint32
+
+func (i *Int3) Pack(p []byte, opt *Options) (int, error) {
+    // Convert 4-byte integer to 3 bytes
+    var tmp [4]byte
+    binary.BigEndian.PutUint32(tmp[:], uint32(*i))
+    copy(p, tmp[1:]) // Only copy the last 3 bytes
+    return 3, nil
+}
+
+func (i *Int3) Unpack(r io.Reader, length int, opt *Options) error {
+    var tmp [4]byte
+    if _, err := r.Read(tmp[1:]); err != nil {
+        return err
+    }
+    *i = Int3(binary.BigEndian.Uint32(tmp[:]))
+    return nil
+}
+
+func (i *Int3) Size(opt *Options) int {
+    return 3 // Fixed 3-byte size
+}
+
+func (i *Int3) String() string {
+    return strconv.FormatUint(uint64(*i), 10)
 }
 ```
 
+Benefits of custom types:
+
+-   Complete control over binary format
+-   Support for special data layouts
+-   Ability to implement compression or encryption
+-   Suitable for handling legacy system formats
+
 ## Best Practices
 
 1. **Use Appropriate Types**
@@ -297,19 +379,19 @@ goos: windows
 goarch: amd64
 pkg: github.com/shengyanli1982/struc/v2
 cpu: 12th Gen Intel(R) Core(TM) i5-12400F
-BenchmarkArrayEncode-12          3203236               373.2 ns/op           137 B/op          4 allocs/op
-BenchmarkSliceEncode-12          2985786               400.9 ns/op           137 B/op          4 allocs/op
-BenchmarkArrayDecode-12          3407203               349.8 ns/op            73 B/op          2 allocs/op
-BenchmarkSliceDecode-12          2768002               433.5 ns/op           112 B/op          4 allocs/op
-BenchmarkEncode-12               2656374               462.5 ns/op           168 B/op          4 allocs/op
-BenchmarkStdlibEncode-12         6035904               206.0 ns/op           136 B/op          3 allocs/op
-BenchmarkManualEncode-12        49696231                25.64 ns/op           64 B/op          1 allocs/op
-BenchmarkDecode-12               2812420               421.0 ns/op           103 B/op          2 allocs/op
-BenchmarkStdlibDecode-12         5953122               195.3 ns/op            80 B/op          3 allocs/op
-BenchmarkManualDecode-12        100000000               12.21 ns/op            8 B/op          1 allocs/op
-BenchmarkFullEncode-12           1000000              1800 ns/op             456 B/op          4 allocs/op
-BenchmarkFullDecode-12            598369              1974 ns/op             327 B/op          5 allocs/op
-BenchmarkFieldPool-12           19483657                62.86 ns/op          168 B/op          4 allocs/op
+BenchmarkArrayEncode-12          3215172               377.1 ns/op           137 B/op          4 allocs/op
+BenchmarkSliceEncode-12          3022616               395.9 ns/op           137 B/op          4 allocs/op
+BenchmarkArrayDecode-12          3407570               349.5 ns/op            73 B/op          2 allocs/op
+BenchmarkSliceDecode-12          2778577               424.7 ns/op           112 B/op          4 allocs/op
+BenchmarkEncode-12               2776862               431.2 ns/op           168 B/op          4 allocs/op
+BenchmarkStdlibEncode-12         5990055               197.5 ns/op           136 B/op          3 allocs/op
+BenchmarkManualEncode-12        59896976                24.82 ns/op           64 B/op          1 allocs/op
+BenchmarkDecode-12               2913640               404.5 ns/op           103 B/op          2 allocs/op
+BenchmarkStdlibDecode-12         5984299               195.2 ns/op            80 B/op          3 allocs/op
+BenchmarkManualDecode-12        100574584               11.95 ns/op            8 B/op          1 allocs/op
+BenchmarkFullEncode-12           1000000              1688 ns/op             456 B/op          4 allocs/op
+BenchmarkFullDecode-12            596047              1901 ns/op             327 B/op          5 allocs/op
+BenchmarkFieldPool-12           19045561                61.38 ns/op          168 B/op          4 allocs/op
 ```
 
 ## License