Added support for omitempty:"true"

nytzuga · nytzuga · commit 563bd26ce99f · 2023-10-16T17:29:46.000-03:00
diff --git a/codec/reflectcodec/struct_fielder.go b/codec/reflectcodec/struct_fielder.go
@@ -18,13 +18,18 @@ const (
 
 	// TagValue is the value the tag must have to be serialized.
 	TagValue = "true"
+
+	// TagValue is the value the tag must have to be serialized, this variant
+	// includes Omit Empty
+	TagWithOmitEmptyValue = "true,omitempty"
 )
 
 var _ StructFielder = (*structFielder)(nil)
 
 type FieldDesc struct {
 	Index       int
 	MaxSliceLen uint32
+	OmitEmpty   bool
 }
 
 // StructFielder handles discovery of serializable fields in a struct.
@@ -83,9 +88,16 @@ func (s *structFielder) GetSerializedFields(t reflect.Type) ([]FieldDesc, error)
 		// Serialize/Deserialize field if it has
 		// any tag with the right value
 		captureField := false
+		omitEmpty := false
 		for _, tag := range s.tags {
-			if field.Tag.Get(tag) == TagValue {
+			switch tagValue := field.Tag.Get(tag); tagValue {
+			case TagValue:
+				captureField = true
+			case TagWithOmitEmptyValue:
 				captureField = true
+				omitEmpty = true
+			}
+			if captureField {
 				break
 			}
 		}
@@ -107,6 +119,7 @@ func (s *structFielder) GetSerializedFields(t reflect.Type) ([]FieldDesc, error)
 		serializedFields = append(serializedFields, FieldDesc{
 			Index:       i,
 			MaxSliceLen: maxSliceLen,
+			OmitEmpty:   omitEmpty,
 		})
 	}
 	s.serializedFieldIndices[t] = serializedFields // cache result
diff --git a/codec/reflectcodec/type_codec.go b/codec/reflectcodec/type_codec.go
@@ -92,17 +92,16 @@ func (c *genericCodec) Size(value interface{}) (int, error) {
 	}
 
 	metaValue := reflect.ValueOf(value)
-	switch valueKind := metaValue.Kind(); valueKind {
-	case reflect.Ptr:
+	if metaValue.Kind() == reflect.Ptr {
 		metaValue = metaValue.Elem()
 	}
 
-	size, _, err := c.size(metaValue)
+	size, _, err := c.size(metaValue, false)
 	return size, err
 }
 
 // size returns the size of the value along with whether the value is constant sized.
-func (c *genericCodec) size(value reflect.Value) (int, bool, error) {
+func (c *genericCodec) size(value reflect.Value, omitEmpty bool) (int, bool, error) {
 	switch valueKind := value.Kind(); valueKind {
 	case reflect.Uint8:
 		return wrappers.ByteLen, true, nil
@@ -125,15 +124,22 @@ func (c *genericCodec) size(value reflect.Value) (int, bool, error) {
 	case reflect.String:
 		return wrappers.StringLen(value.String()), false, nil
 	case reflect.Ptr:
-		if value.IsNil() {
-			return magicBytesPtrPrefixSize, false, nil
+		if omitEmpty {
+			if value.IsNil() {
+				return magicBytesPtrPrefixSize, false, nil
+			}
+			size, _, err := c.size(value.Elem(), omitEmpty)
+			if err != nil {
+				return 0, false, err
+			}
+			return magicBytesPtrPrefixSize + size, false, nil
 		}
-		size, _, err := c.size(value.Elem())
-		if err != nil {
-			return 0, false, err
+
+		if value.IsNil() { // Can't marshal nil (except nil slices *or* if omitEmpty)
+			return 0, false, errMarshalNil
 		}
-		return magicBytesPtrPrefixSize + size, false, nil
 
+		return c.size(value.Elem(), omitEmpty)
 	case reflect.Interface:
 		if value.IsNil() {
 			// Can't marshal nil interfaces (but nil slices are fine)
@@ -142,7 +148,7 @@ func (c *genericCodec) size(value reflect.Value) (int, bool, error) {
 		underlyingValue := value.Interface()
 		underlyingType := reflect.TypeOf(underlyingValue)
 		prefixSize := c.typer.PrefixSize(underlyingType)
-		valueSize, _, err := c.size(value.Elem())
+		valueSize, _, err := c.size(value.Elem(), omitEmpty)
 		if err != nil {
 			return 0, false, err
 		}
@@ -154,7 +160,7 @@ func (c *genericCodec) size(value reflect.Value) (int, bool, error) {
 			return wrappers.IntLen, false, nil
 		}
 
-		size, constSize, err := c.size(value.Index(0))
+		size, constSize, err := c.size(value.Index(0), omitEmpty)
 		if err != nil {
 			return 0, false, err
 		}
@@ -166,7 +172,7 @@ func (c *genericCodec) size(value reflect.Value) (int, bool, error) {
 		}
 
 		for i := 1; i < numElts; i++ {
-			innerSize, _, err := c.size(value.Index(i))
+			innerSize, _, err := c.size(value.Index(i), omitEmpty)
 			if err != nil {
 				return 0, false, err
 			}
@@ -180,7 +186,7 @@ func (c *genericCodec) size(value reflect.Value) (int, bool, error) {
 			return 0, true, nil
 		}
 
-		size, constSize, err := c.size(value.Index(0))
+		size, constSize, err := c.size(value.Index(0), omitEmpty)
 		if err != nil {
 			return 0, false, err
 		}
@@ -192,7 +198,7 @@ func (c *genericCodec) size(value reflect.Value) (int, bool, error) {
 		}
 
 		for i := 1; i < numElts; i++ {
-			innerSize, _, err := c.size(value.Index(i))
+			innerSize, _, err := c.size(value.Index(i), omitEmpty)
 			if err != nil {
 				return 0, false, err
 			}
@@ -211,7 +217,7 @@ func (c *genericCodec) size(value reflect.Value) (int, bool, error) {
 			constSize = true
 		)
 		for _, fieldDesc := range serializedFields {
-			innerSize, innerConstSize, err := c.size(value.Field(fieldDesc.Index))
+			innerSize, innerConstSize, err := c.size(value.Field(fieldDesc.Index), fieldDesc.OmitEmpty)
 			if err != nil {
 				return 0, false, err
 			}
@@ -226,11 +232,11 @@ func (c *genericCodec) size(value reflect.Value) (int, bool, error) {
 			return wrappers.IntLen, false, nil
 		}
 
-		keySize, keyConstSize, err := c.size(iter.Key())
+		keySize, keyConstSize, err := c.size(iter.Key(), omitEmpty)
 		if err != nil {
 			return 0, false, err
 		}
-		valueSize, valueConstSize, err := c.size(iter.Value())
+		valueSize, valueConstSize, err := c.size(iter.Value(), omitEmpty)
 		if err != nil {
 			return 0, false, err
 		}
@@ -245,7 +251,7 @@ func (c *genericCodec) size(value reflect.Value) (int, bool, error) {
 				totalValueSize = valueSize
 			)
 			for iter.Next() {
-				valueSize, _, err := c.size(iter.Value())
+				valueSize, _, err := c.size(iter.Value(), omitEmpty)
 				if err != nil {
 					return 0, false, err
 				}
@@ -259,7 +265,7 @@ func (c *genericCodec) size(value reflect.Value) (int, bool, error) {
 				totalKeySize = keySize
 			)
 			for iter.Next() {
-				keySize, _, err := c.size(iter.Key())
+				keySize, _, err := c.size(iter.Key(), omitEmpty)
 				if err != nil {
 					return 0, false, err
 				}
@@ -270,11 +276,11 @@ func (c *genericCodec) size(value reflect.Value) (int, bool, error) {
 		default:
 			totalSize := wrappers.IntLen + keySize + valueSize
 			for iter.Next() {
-				keySize, _, err := c.size(iter.Key())
+				keySize, _, err := c.size(iter.Key(), omitEmpty)
 				if err != nil {
 					return 0, false, err
 				}
-				valueSize, _, err := c.size(iter.Value())
+				valueSize, _, err := c.size(iter.Value(), omitEmpty)
 				if err != nil {
 					return 0, false, err
 				}
@@ -295,18 +301,17 @@ func (c *genericCodec) MarshalInto(value interface{}, p *wrappers.Packer) error
 	}
 
 	metaValue := reflect.ValueOf(value)
-	switch valueKind := metaValue.Kind(); valueKind {
-	case reflect.Ptr:
+	if metaValue.Kind() == reflect.Ptr {
 		metaValue = metaValue.Elem()
 	}
 
-	return c.marshal(metaValue, p, c.maxSliceLen)
+	return c.marshal(metaValue, p, c.maxSliceLen, false)
 }
 
 // marshal writes the byte representation of [value] to [p]
 // [value]'s underlying value must not be a nil pointer or interface
 // c.lock should be held for the duration of this function
-func (c *genericCodec) marshal(value reflect.Value, p *wrappers.Packer, maxSliceLen uint32) error {
+func (c *genericCodec) marshal(value reflect.Value, p *wrappers.Packer, maxSliceLen uint32, omitEmpty bool) error {
 	switch valueKind := value.Kind(); valueKind {
 	case reflect.Uint8:
 		p.PackByte(uint8(value.Uint()))
@@ -339,15 +344,20 @@ func (c *genericCodec) marshal(value reflect.Value, p *wrappers.Packer, maxSlice
 		p.PackBool(value.Bool())
 		return p.Err
 	case reflect.Ptr:
-		if value.IsNil() {
-			p.PackFixedBytes(MagicBytesPtrNil)
-			return p.Err
-		}
-		p.PackFixedBytes(MagicBytesPtr)
-		if p.Err != nil {
-			return p.Err
+		if omitEmpty {
+			if value.IsNil() {
+				p.PackFixedBytes(MagicBytesPtrNil)
+				return p.Err
+			}
+			p.PackFixedBytes(MagicBytesPtr)
+			if p.Err != nil {
+				return p.Err
+			}
+		} else if value.IsNil() {
+			return errMarshalNil
 		}
-		return c.marshal(value.Elem(), p, c.maxSliceLen)
+
+		return c.marshal(value.Elem(), p, c.maxSliceLen, omitEmpty)
 	case reflect.Interface:
 		if value.IsNil() { // Can't marshal nil (except nil slices)
 			return errMarshalNil
@@ -357,7 +367,7 @@ func (c *genericCodec) marshal(value reflect.Value, p *wrappers.Packer, maxSlice
 		if err := c.typer.PackPrefix(p, underlyingType); err != nil {
 			return err
 		}
-		if err := c.marshal(value.Elem(), p, c.maxSliceLen); err != nil {
+		if err := c.marshal(value.Elem(), p, c.maxSliceLen, omitEmpty); err != nil {
 			return err
 		}
 		return p.Err
@@ -387,7 +397,7 @@ func (c *genericCodec) marshal(value reflect.Value, p *wrappers.Packer, maxSlice
 			return p.Err
 		}
 		for i := 0; i < numElts; i++ { // Process each element in the slice
-			if err := c.marshal(value.Index(i), p, c.maxSliceLen); err != nil {
+			if err := c.marshal(value.Index(i), p, c.maxSliceLen, omitEmpty); err != nil {
 				return err
 			}
 		}
@@ -407,7 +417,7 @@ func (c *genericCodec) marshal(value reflect.Value, p *wrappers.Packer, maxSlice
 			)
 		}
 		for i := 0; i < numElts; i++ { // Process each element in the array
-			if err := c.marshal(value.Index(i), p, c.maxSliceLen); err != nil {
+			if err := c.marshal(value.Index(i), p, c.maxSliceLen, omitEmpty); err != nil {
 				return err
 			}
 		}
@@ -418,7 +428,7 @@ func (c *genericCodec) marshal(value reflect.Value, p *wrappers.Packer, maxSlice
 			return err
 		}
 		for _, fieldDesc := range serializedFields { // Go through all fields of this struct that are serialized
-			if err := c.marshal(value.Field(fieldDesc.Index), p, fieldDesc.MaxSliceLen); err != nil { // Serialize the field and write to byte array
+			if err := c.marshal(value.Field(fieldDesc.Index), p, fieldDesc.MaxSliceLen, fieldDesc.OmitEmpty); err != nil { // Serialize the field and write to byte array
 				return err
 			}
 		}
@@ -449,7 +459,7 @@ func (c *genericCodec) marshal(value reflect.Value, p *wrappers.Packer, maxSlice
 		startOffset := p.Offset
 		endOffset := p.Offset
 		for i, key := range keys {
-			if err := c.marshal(key, p, c.maxSliceLen); err != nil {
+			if err := c.marshal(key, p, c.maxSliceLen, omitEmpty); err != nil {
 				return err
 			}
 			if p.Err != nil {
@@ -482,7 +492,7 @@ func (c *genericCodec) marshal(value reflect.Value, p *wrappers.Packer, maxSlice
 			}
 
 			// serialize and pack value
-			if err := c.marshal(value.MapIndex(key.key), p, c.maxSliceLen); err != nil {
+			if err := c.marshal(value.MapIndex(key.key), p, c.maxSliceLen, omitEmpty); err != nil {
 				return err
 			}
 		}
@@ -507,7 +517,7 @@ func (c *genericCodec) Unmarshal(bytes []byte, dest interface{}) error {
 	if destPtr.Kind() != reflect.Ptr {
 		return errNeedPointer
 	}
-	if err := c.unmarshal(&p, destPtr.Elem(), c.maxSliceLen); err != nil {
+	if err := c.unmarshal(&p, destPtr.Elem(), c.maxSliceLen, false); err != nil {
 		return err
 	}
 	if p.Offset != len(bytes) {
@@ -522,7 +532,7 @@ func (c *genericCodec) Unmarshal(bytes []byte, dest interface{}) error {
 
 // Unmarshal from p.Bytes into [value]. [value] must be addressable.
 // c.lock should be held for the duration of this function
-func (c *genericCodec) unmarshal(p *wrappers.Packer, value reflect.Value, maxSliceLen uint32) error {
+func (c *genericCodec) unmarshal(p *wrappers.Packer, value reflect.Value, maxSliceLen uint32, omitEmpty bool) error {
 	switch value.Kind() {
 	case reflect.Uint8:
 		value.SetUint(uint64(p.UnpackByte()))
@@ -609,7 +619,7 @@ func (c *genericCodec) unmarshal(p *wrappers.Packer, value reflect.Value, maxSli
 		value.Set(reflect.MakeSlice(value.Type(), numElts, numElts))
 		// Unmarshal each element into the appropriate index of the slice
 		for i := 0; i < numElts; i++ {
-			if err := c.unmarshal(p, value.Index(i), c.maxSliceLen); err != nil {
+			if err := c.unmarshal(p, value.Index(i), c.maxSliceLen, omitEmpty); err != nil {
 				return fmt.Errorf("couldn't unmarshal slice element: %w", err)
 			}
 		}
@@ -627,7 +637,7 @@ func (c *genericCodec) unmarshal(p *wrappers.Packer, value reflect.Value, maxSli
 			return nil
 		}
 		for i := 0; i < numElts; i++ {
-			if err := c.unmarshal(p, value.Index(i), c.maxSliceLen); err != nil {
+			if err := c.unmarshal(p, value.Index(i), c.maxSliceLen, omitEmpty); err != nil {
 				return fmt.Errorf("couldn't unmarshal array element: %w", err)
 			}
 		}
@@ -644,7 +654,7 @@ func (c *genericCodec) unmarshal(p *wrappers.Packer, value reflect.Value, maxSli
 			return err
 		}
 		// Unmarshal into the struct
-		if err := c.unmarshal(p, intfImplementor, c.maxSliceLen); err != nil {
+		if err := c.unmarshal(p, intfImplementor, c.maxSliceLen, omitEmpty); err != nil {
 			return fmt.Errorf("couldn't unmarshal interface: %w", err)
 		}
 		// And assign the filled struct to the value
@@ -658,7 +668,7 @@ func (c *genericCodec) unmarshal(p *wrappers.Packer, value reflect.Value, maxSli
 		}
 		// Go through the fields and umarshal into them
 		for _, fieldDesc := range serializedFieldIndices {
-			if err := c.unmarshal(p, value.Field(fieldDesc.Index), fieldDesc.MaxSliceLen); err != nil {
+			if err := c.unmarshal(p, value.Field(fieldDesc.Index), fieldDesc.MaxSliceLen, fieldDesc.OmitEmpty); err != nil {
 				return fmt.Errorf("couldn't unmarshal struct: %w", err)
 			}
 		}
@@ -669,11 +679,13 @@ func (c *genericCodec) unmarshal(p *wrappers.Packer, value reflect.Value, maxSli
 		// Create a new pointer to a new value of the underlying type
 		v := reflect.New(t)
 		// Fill the value
-		if bytes.Equal(MagicBytesPtrNil, p.UnpackIfMatches(MagicBytesPtrNil, MagicBytesPtr)) {
-			// Nil
-			return nil
+		if omitEmpty {
+			if bytes.Equal(MagicBytesPtrNil, p.UnpackIfMatches(MagicBytesPtrNil, MagicBytesPtr)) {
+				// Nil
+				return nil
+			}
 		}
-		if err := c.unmarshal(p, v.Elem(), c.maxSliceLen); err != nil {
+		if err := c.unmarshal(p, v.Elem(), c.maxSliceLen, omitEmpty); err != nil {
 			return fmt.Errorf("couldn't unmarshal pointer: %w", err)
 		}
 		// Assign to the top-level struct's member
@@ -708,7 +720,7 @@ func (c *genericCodec) unmarshal(p *wrappers.Packer, value reflect.Value, maxSli
 
 			keyStartOffset := p.Offset
 
-			if err := c.unmarshal(p, mapKey, c.maxSliceLen); err != nil {
+			if err := c.unmarshal(p, mapKey, c.maxSliceLen, omitEmpty); err != nil {
 				return fmt.Errorf("couldn't unmarshal map key (%s): %w", mapKeyType, err)
 			}
 
@@ -726,7 +738,7 @@ func (c *genericCodec) unmarshal(p *wrappers.Packer, value reflect.Value, maxSli
 
 			// Get the value
 			mapValue := reflect.New(mapValueType).Elem()
-			if err := c.unmarshal(p, mapValue, c.maxSliceLen); err != nil {
+			if err := c.unmarshal(p, mapValue, c.maxSliceLen, omitEmpty); err != nil {
 				return fmt.Errorf("couldn't unmarshal map value for key %s: %w", mapKey, err)
 			}
 
diff --git a/codec/test_codec.go b/codec/test_codec.go

Original file line number	Diff line number	Diff line change
`@@ -92,17 +92,16 @@ func (c *genericCodec) Size(value interface{}) (int, error) {`
`92`	`92`	`}`
`93`	`93`
`94`	`94`	`metaValue := reflect.ValueOf(value)`
`95`		`- switch valueKind := metaValue.Kind(); valueKind {`
`96`		`- case reflect.Ptr:`
	`95`	`+ if metaValue.Kind() == reflect.Ptr {`
`97`	`96`	`metaValue = metaValue.Elem()`
`98`	`97`	`}`
`99`	`98`
`100`		`- size, _, err := c.size(metaValue)`
	`99`	`+ size, _, err := c.size(metaValue, false)`
`101`	`100`	`return size, err`
`102`	`101`	`}`
`103`	`102`
`104`	`103`	`// size returns the size of the value along with whether the value is constant sized.`
`105`		`-func (c *genericCodec) size(value reflect.Value) (int, bool, error) {`
	`104`	`+func (c *genericCodec) size(value reflect.Value, omitEmpty bool) (int, bool, error) {`
`106`	`105`	`switch valueKind := value.Kind(); valueKind {`
`107`	`106`	`case reflect.Uint8:`
`108`	`107`	`return wrappers.ByteLen, true, nil`
`@@ -125,15 +124,22 @@ func (c *genericCodec) size(value reflect.Value) (int, bool, error) {`
`125`	`124`	`case reflect.String:`
`126`	`125`	`return wrappers.StringLen(value.String()), false, nil`
`127`	`126`	`case reflect.Ptr:`
`128`		`- if value.IsNil() {`
`129`		`- return magicBytesPtrPrefixSize, false, nil`
	`127`	`+ if omitEmpty {`
	`128`	`+ if value.IsNil() {`
	`129`	`+ return magicBytesPtrPrefixSize, false, nil`
	`130`	`+ }`
	`131`	`+ size, _, err := c.size(value.Elem(), omitEmpty)`
	`132`	`+ if err != nil {`
	`133`	`+ return 0, false, err`
	`134`	`+ }`
	`135`	`+ return magicBytesPtrPrefixSize + size, false, nil`
`130`	`136`	`}`
`131`		`- size, _, err := c.size(value.Elem())`
`132`		`- if err != nil {`
`133`		`- return 0, false, err`
	`137`	`+`
	`138`	`+ if value.IsNil() { // Can't marshal nil (except nil slices or if omitEmpty)`
	`139`	`+ return 0, false, errMarshalNil`
`134`	`140`	`}`
`135`		`- return magicBytesPtrPrefixSize + size, false, nil`
`136`	`141`
	`142`	`+ return c.size(value.Elem(), omitEmpty)`
`137`	`143`	`case reflect.Interface:`
`138`	`144`	`if value.IsNil() {`
`139`	`145`	`// Can't marshal nil interfaces (but nil slices are fine)`
`@@ -142,7 +148,7 @@ func (c *genericCodec) size(value reflect.Value) (int, bool, error) {`
`142`	`148`	`underlyingValue := value.Interface()`
`143`	`149`	`underlyingType := reflect.TypeOf(underlyingValue)`
`144`	`150`	`prefixSize := c.typer.PrefixSize(underlyingType)`
`145`		`- valueSize, _, err := c.size(value.Elem())`
	`151`	`+ valueSize, _, err := c.size(value.Elem(), omitEmpty)`
`146`	`152`	`if err != nil {`
`147`	`153`	`return 0, false, err`
`148`	`154`	`}`
`@@ -154,7 +160,7 @@ func (c *genericCodec) size(value reflect.Value) (int, bool, error) {`
`154`	`160`	`return wrappers.IntLen, false, nil`
`155`	`161`	`}`
`156`	`162`
`157`		`- size, constSize, err := c.size(value.Index(0))`
	`163`	`+ size, constSize, err := c.size(value.Index(0), omitEmpty)`
`158`	`164`	`if err != nil {`
`159`	`165`	`return 0, false, err`
`160`	`166`	`}`
`@@ -166,7 +172,7 @@ func (c *genericCodec) size(value reflect.Value) (int, bool, error) {`
`166`	`172`	`}`
`167`	`173`
`168`	`174`	`for i := 1; i < numElts; i++ {`
`169`		`- innerSize, _, err := c.size(value.Index(i))`
	`175`	`+ innerSize, _, err := c.size(value.Index(i), omitEmpty)`
`170`	`176`	`if err != nil {`
`171`	`177`	`return 0, false, err`
`172`	`178`	`}`
`@@ -180,7 +186,7 @@ func (c *genericCodec) size(value reflect.Value) (int, bool, error) {`
`180`	`186`	`return 0, true, nil`
`181`	`187`	`}`
`182`	`188`
`183`		`- size, constSize, err := c.size(value.Index(0))`
	`189`	`+ size, constSize, err := c.size(value.Index(0), omitEmpty)`
`184`	`190`	`if err != nil {`
`185`	`191`	`return 0, false, err`
`186`	`192`	`}`
`@@ -192,7 +198,7 @@ func (c *genericCodec) size(value reflect.Value) (int, bool, error) {`
`192`	`198`	`}`
`193`	`199`
`194`	`200`	`for i := 1; i < numElts; i++ {`
`195`		`- innerSize, _, err := c.size(value.Index(i))`
	`201`	`+ innerSize, _, err := c.size(value.Index(i), omitEmpty)`
`196`	`202`	`if err != nil {`
`197`	`203`	`return 0, false, err`
`198`	`204`	`}`
`@@ -211,7 +217,7 @@ func (c *genericCodec) size(value reflect.Value) (int, bool, error) {`
`211`	`217`	`constSize = true`
`212`	`218`	`)`
`213`	`219`	`for _, fieldDesc := range serializedFields {`
`214`		`- innerSize, innerConstSize, err := c.size(value.Field(fieldDesc.Index))`
	`220`	`+ innerSize, innerConstSize, err := c.size(value.Field(fieldDesc.Index), fieldDesc.OmitEmpty)`
`215`	`221`	`if err != nil {`
`216`	`222`	`return 0, false, err`
`217`	`223`	`}`
`@@ -226,11 +232,11 @@ func (c *genericCodec) size(value reflect.Value) (int, bool, error) {`
`226`	`232`	`return wrappers.IntLen, false, nil`
`227`	`233`	`}`
`228`	`234`
`229`		`- keySize, keyConstSize, err := c.size(iter.Key())`
	`235`	`+ keySize, keyConstSize, err := c.size(iter.Key(), omitEmpty)`
`230`	`236`	`if err != nil {`
`231`	`237`	`return 0, false, err`
`232`	`238`	`}`
`233`		`- valueSize, valueConstSize, err := c.size(iter.Value())`
	`239`	`+ valueSize, valueConstSize, err := c.size(iter.Value(), omitEmpty)`
`234`	`240`	`if err != nil {`
`235`	`241`	`return 0, false, err`
`236`	`242`	`}`
`@@ -245,7 +251,7 @@ func (c *genericCodec) size(value reflect.Value) (int, bool, error) {`
`245`	`251`	`totalValueSize = valueSize`
`246`	`252`	`)`
`247`	`253`	`for iter.Next() {`
`248`		`- valueSize, _, err := c.size(iter.Value())`
	`254`	`+ valueSize, _, err := c.size(iter.Value(), omitEmpty)`
`249`	`255`	`if err != nil {`
`250`	`256`	`return 0, false, err`
`251`	`257`	`}`
`@@ -259,7 +265,7 @@ func (c *genericCodec) size(value reflect.Value) (int, bool, error) {`
`259`	`265`	`totalKeySize = keySize`
`260`	`266`	`)`
`261`	`267`	`for iter.Next() {`
`262`		`- keySize, _, err := c.size(iter.Key())`
	`268`	`+ keySize, _, err := c.size(iter.Key(), omitEmpty)`
`263`	`269`	`if err != nil {`
`264`	`270`	`return 0, false, err`
`265`	`271`	`}`
`@@ -270,11 +276,11 @@ func (c *genericCodec) size(value reflect.Value) (int, bool, error) {`
`270`	`276`	`default:`
`271`	`277`	`totalSize := wrappers.IntLen + keySize + valueSize`
`272`	`278`	`for iter.Next() {`
`273`		`- keySize, _, err := c.size(iter.Key())`
	`279`	`+ keySize, _, err := c.size(iter.Key(), omitEmpty)`
`274`	`280`	`if err != nil {`
`275`	`281`	`return 0, false, err`
`276`	`282`	`}`
`277`		`- valueSize, _, err := c.size(iter.Value())`
	`283`	`+ valueSize, _, err := c.size(iter.Value(), omitEmpty)`
`278`	`284`	`if err != nil {`
`279`	`285`	`return 0, false, err`
`280`	`286`	`}`
`@@ -295,18 +301,17 @@ func (c genericCodec) MarshalInto(value interface{}, p wrappers.Packer) error`
`295`	`301`	`}`
`296`	`302`
`297`	`303`	`metaValue := reflect.ValueOf(value)`
`298`		`- switch valueKind := metaValue.Kind(); valueKind {`
`299`		`- case reflect.Ptr:`
	`304`	`+ if metaValue.Kind() == reflect.Ptr {`
`300`	`305`	`metaValue = metaValue.Elem()`
`301`	`306`	`}`
`302`	`307`
`303`		`- return c.marshal(metaValue, p, c.maxSliceLen)`
	`308`	`+ return c.marshal(metaValue, p, c.maxSliceLen, false)`
`304`	`309`	`}`
`305`	`310`
`306`	`311`	`// marshal writes the byte representation of [value] to [p]`
`307`	`312`	`// [value]'s underlying value must not be a nil pointer or interface`
`308`	`313`	`// c.lock should be held for the duration of this function`
`309`		`-func (c genericCodec) marshal(value reflect.Value, p wrappers.Packer, maxSliceLen uint32) error {`
	`314`	`+func (c genericCodec) marshal(value reflect.Value, p wrappers.Packer, maxSliceLen uint32, omitEmpty bool) error {`
`310`	`315`	`switch valueKind := value.Kind(); valueKind {`
`311`	`316`	`case reflect.Uint8:`
`312`	`317`	`p.PackByte(uint8(value.Uint()))`
`@@ -339,15 +344,20 @@ func (c genericCodec) marshal(value reflect.Value, p wrappers.Packer, maxSlice`
`339`	`344`	`p.PackBool(value.Bool())`
`340`	`345`	`return p.Err`
`341`	`346`	`case reflect.Ptr:`
`342`		`- if value.IsNil() {`
`343`		`- p.PackFixedBytes(MagicBytesPtrNil)`
`344`		`- return p.Err`
`345`		`- }`
`346`		`- p.PackFixedBytes(MagicBytesPtr)`
`347`		`- if p.Err != nil {`
`348`		`- return p.Err`
	`347`	`+ if omitEmpty {`
	`348`	`+ if value.IsNil() {`
	`349`	`+ p.PackFixedBytes(MagicBytesPtrNil)`
	`350`	`+ return p.Err`
	`351`	`+ }`
	`352`	`+ p.PackFixedBytes(MagicBytesPtr)`
	`353`	`+ if p.Err != nil {`
	`354`	`+ return p.Err`
	`355`	`+ }`
	`356`	`+ } else if value.IsNil() {`
	`357`	`+ return errMarshalNil`
`349`	`358`	`}`
`350`		`- return c.marshal(value.Elem(), p, c.maxSliceLen)`
	`359`	`+`
	`360`	`+ return c.marshal(value.Elem(), p, c.maxSliceLen, omitEmpty)`
`351`	`361`	`case reflect.Interface:`
`352`	`362`	`if value.IsNil() { // Can't marshal nil (except nil slices)`
`353`	`363`	`return errMarshalNil`
`@@ -357,7 +367,7 @@ func (c genericCodec) marshal(value reflect.Value, p wrappers.Packer, maxSlice`
`357`	`367`	`if err := c.typer.PackPrefix(p, underlyingType); err != nil {`
`358`	`368`	`return err`
`359`	`369`	`}`
`360`		`- if err := c.marshal(value.Elem(), p, c.maxSliceLen); err != nil {`
	`370`	`+ if err := c.marshal(value.Elem(), p, c.maxSliceLen, omitEmpty); err != nil {`
`361`	`371`	`return err`
`362`	`372`	`}`
`363`	`373`	`return p.Err`
`@@ -387,7 +397,7 @@ func (c genericCodec) marshal(value reflect.Value, p wrappers.Packer, maxSlice`
`387`	`397`	`return p.Err`
`388`	`398`	`}`
`389`	`399`	`for i := 0; i < numElts; i++ { // Process each element in the slice`
`390`		`- if err := c.marshal(value.Index(i), p, c.maxSliceLen); err != nil {`
	`400`	`+ if err := c.marshal(value.Index(i), p, c.maxSliceLen, omitEmpty); err != nil {`
`391`	`401`	`return err`
`392`	`402`	`}`
`393`	`403`	`}`
`@@ -407,7 +417,7 @@ func (c genericCodec) marshal(value reflect.Value, p wrappers.Packer, maxSlice`
`407`	`417`	`)`
`408`	`418`	`}`
`409`	`419`	`for i := 0; i < numElts; i++ { // Process each element in the array`
`410`		`- if err := c.marshal(value.Index(i), p, c.maxSliceLen); err != nil {`
	`420`	`+ if err := c.marshal(value.Index(i), p, c.maxSliceLen, omitEmpty); err != nil {`
`411`	`421`	`return err`
`412`	`422`	`}`
`413`	`423`	`}`
`@@ -418,7 +428,7 @@ func (c genericCodec) marshal(value reflect.Value, p wrappers.Packer, maxSlice`
`418`	`428`	`return err`
`419`	`429`	`}`
`420`	`430`	`for _, fieldDesc := range serializedFields { // Go through all fields of this struct that are serialized`
`421`		`- if err := c.marshal(value.Field(fieldDesc.Index), p, fieldDesc.MaxSliceLen); err != nil { // Serialize the field and write to byte array`
	`431`	`+ if err := c.marshal(value.Field(fieldDesc.Index), p, fieldDesc.MaxSliceLen, fieldDesc.OmitEmpty); err != nil { // Serialize the field and write to byte array`
`422`	`432`	`return err`
`423`	`433`	`}`
`424`	`434`	`}`
`@@ -449,7 +459,7 @@ func (c genericCodec) marshal(value reflect.Value, p wrappers.Packer, maxSlice`
`449`	`459`	`startOffset := p.Offset`
`450`	`460`	`endOffset := p.Offset`
`451`	`461`	`for i, key := range keys {`
`452`		`- if err := c.marshal(key, p, c.maxSliceLen); err != nil {`
	`462`	`+ if err := c.marshal(key, p, c.maxSliceLen, omitEmpty); err != nil {`
`453`	`463`	`return err`
`454`	`464`	`}`
`455`	`465`	`if p.Err != nil {`
`@@ -482,7 +492,7 @@ func (c genericCodec) marshal(value reflect.Value, p wrappers.Packer, maxSlice`
`482`	`492`	`}`
`483`	`493`
`484`	`494`	`// serialize and pack value`
`485`		`- if err := c.marshal(value.MapIndex(key.key), p, c.maxSliceLen); err != nil {`
	`495`	`+ if err := c.marshal(value.MapIndex(key.key), p, c.maxSliceLen, omitEmpty); err != nil {`
`486`	`496`	`return err`
`487`	`497`	`}`
`488`	`498`	`}`
`@@ -507,7 +517,7 @@ func (c *genericCodec) Unmarshal(bytes []byte, dest interface{}) error {`
`507`	`517`	`if destPtr.Kind() != reflect.Ptr {`
`508`	`518`	`return errNeedPointer`
`509`	`519`	`}`
`510`		`- if err := c.unmarshal(&p, destPtr.Elem(), c.maxSliceLen); err != nil {`
	`520`	`+ if err := c.unmarshal(&p, destPtr.Elem(), c.maxSliceLen, false); err != nil {`
`511`	`521`	`return err`
`512`	`522`	`}`
`513`	`523`	`if p.Offset != len(bytes) {`
`@@ -522,7 +532,7 @@ func (c *genericCodec) Unmarshal(bytes []byte, dest interface{}) error {`
`522`	`532`
`523`	`533`	`// Unmarshal from p.Bytes into [value]. [value] must be addressable.`
`524`	`534`	`// c.lock should be held for the duration of this function`
`525`		`-func (c genericCodec) unmarshal(p wrappers.Packer, value reflect.Value, maxSliceLen uint32) error {`
	`535`	`+func (c genericCodec) unmarshal(p wrappers.Packer, value reflect.Value, maxSliceLen uint32, omitEmpty bool) error {`
`526`	`536`	`switch value.Kind() {`
`527`	`537`	`case reflect.Uint8:`
`528`	`538`	`value.SetUint(uint64(p.UnpackByte()))`
`@@ -609,7 +619,7 @@ func (c genericCodec) unmarshal(p wrappers.Packer, value reflect.Value, maxSli`
`609`	`619`	`value.Set(reflect.MakeSlice(value.Type(), numElts, numElts))`
`610`	`620`	`// Unmarshal each element into the appropriate index of the slice`
`611`	`621`	`for i := 0; i < numElts; i++ {`
`612`		`- if err := c.unmarshal(p, value.Index(i), c.maxSliceLen); err != nil {`
	`622`	`+ if err := c.unmarshal(p, value.Index(i), c.maxSliceLen, omitEmpty); err != nil {`
`613`	`623`	`return fmt.Errorf("couldn't unmarshal slice element: %w", err)`
`614`	`624`	`}`
`615`	`625`	`}`
`@@ -627,7 +637,7 @@ func (c genericCodec) unmarshal(p wrappers.Packer, value reflect.Value, maxSli`
`627`	`637`	`return nil`
`628`	`638`	`}`
`629`	`639`	`for i := 0; i < numElts; i++ {`
`630`		`- if err := c.unmarshal(p, value.Index(i), c.maxSliceLen); err != nil {`
	`640`	`+ if err := c.unmarshal(p, value.Index(i), c.maxSliceLen, omitEmpty); err != nil {`
`631`	`641`	`return fmt.Errorf("couldn't unmarshal array element: %w", err)`
`632`	`642`	`}`
`633`	`643`	`}`
`@@ -644,7 +654,7 @@ func (c genericCodec) unmarshal(p wrappers.Packer, value reflect.Value, maxSli`
`644`	`654`	`return err`
`645`	`655`	`}`
`646`	`656`	`// Unmarshal into the struct`
`647`		`- if err := c.unmarshal(p, intfImplementor, c.maxSliceLen); err != nil {`
	`657`	`+ if err := c.unmarshal(p, intfImplementor, c.maxSliceLen, omitEmpty); err != nil {`
`648`	`658`	`return fmt.Errorf("couldn't unmarshal interface: %w", err)`
`649`	`659`	`}`
`650`	`660`	`// And assign the filled struct to the value`
`@@ -658,7 +668,7 @@ func (c genericCodec) unmarshal(p wrappers.Packer, value reflect.Value, maxSli`
`658`	`668`	`}`
`659`	`669`	`// Go through the fields and umarshal into them`
`660`	`670`	`for _, fieldDesc := range serializedFieldIndices {`
`661`		`- if err := c.unmarshal(p, value.Field(fieldDesc.Index), fieldDesc.MaxSliceLen); err != nil {`
	`671`	`+ if err := c.unmarshal(p, value.Field(fieldDesc.Index), fieldDesc.MaxSliceLen, fieldDesc.OmitEmpty); err != nil {`
`662`	`672`	`return fmt.Errorf("couldn't unmarshal struct: %w", err)`
`663`	`673`	`}`
`664`	`674`	`}`
`@@ -669,11 +679,13 @@ func (c genericCodec) unmarshal(p wrappers.Packer, value reflect.Value, maxSli`
`669`	`679`	`// Create a new pointer to a new value of the underlying type`
`670`	`680`	`v := reflect.New(t)`
`671`	`681`	`// Fill the value`
`672`		`- if bytes.Equal(MagicBytesPtrNil, p.UnpackIfMatches(MagicBytesPtrNil, MagicBytesPtr)) {`
`673`		`- // Nil`
`674`		`- return nil`
	`682`	`+ if omitEmpty {`
	`683`	`+ if bytes.Equal(MagicBytesPtrNil, p.UnpackIfMatches(MagicBytesPtrNil, MagicBytesPtr)) {`
	`684`	`+ // Nil`
	`685`	`+ return nil`
	`686`	`+ }`
`675`	`687`	`}`
`676`		`- if err := c.unmarshal(p, v.Elem(), c.maxSliceLen); err != nil {`
	`688`	`+ if err := c.unmarshal(p, v.Elem(), c.maxSliceLen, omitEmpty); err != nil {`
`677`	`689`	`return fmt.Errorf("couldn't unmarshal pointer: %w", err)`
`678`	`690`	`}`
`679`	`691`	`// Assign to the top-level struct's member`
`@@ -708,7 +720,7 @@ func (c genericCodec) unmarshal(p wrappers.Packer, value reflect.Value, maxSli`
`708`	`720`
`709`	`721`	`keyStartOffset := p.Offset`
`710`	`722`
`711`		`- if err := c.unmarshal(p, mapKey, c.maxSliceLen); err != nil {`
	`723`	`+ if err := c.unmarshal(p, mapKey, c.maxSliceLen, omitEmpty); err != nil {`
`712`	`724`	`return fmt.Errorf("couldn't unmarshal map key (%s): %w", mapKeyType, err)`
`713`	`725`	`}`
`714`	`726`
`@@ -726,7 +738,7 @@ func (c genericCodec) unmarshal(p wrappers.Packer, value reflect.Value, maxSli`
`726`	`738`
`727`	`739`	`// Get the value`
`728`	`740`	`mapValue := reflect.New(mapValueType).Elem()`
`729`		`- if err := c.unmarshal(p, mapValue, c.maxSliceLen); err != nil {`
	`741`	`+ if err := c.unmarshal(p, mapValue, c.maxSliceLen, omitEmpty); err != nil {`
`730`	`742`	`return fmt.Errorf("couldn't unmarshal map value for key %s: %w", mapKey, err)`
`731`	`743`	`}`
`732`	`744`