unmarshal: optimize slice capacity growth in unmarshalArray function (#…

…87)

When unmarshaling an array from a plist file into a slice, two issues
occur related to slice capacity growth:

- Unnecessary growth: The slice grows even when the current capacity is
  enough to hold all elements. Specifically, the slice grows
  `if cnt >= val.Cap()`, even when the current capacity is sufficient.
- Doubling capacity: The slice's capacity is always doubled, which is
  inefficient. It should follow a more dynamic growth pattern, similar
  to Go's built-in slice growth algorithm.

Fixes #86

unmarshal.go

@@ -218,10 +218,10 @@ func (p *Decoder) unmarshalArray(a *cfArray, val reflect.Value) {
 		// Slice of element values.
 		// Grow slice.
 		cnt := len(a.values) + val.Len()
-		if cnt >= val.Cap() {
-			ncap := 2 * cnt
-			if ncap < 4 {
-				ncap = 4
+		if cnt > val.Cap() {
+			ncap := val.Cap()
+			for ncap < cnt {
+				ncap = growSliceCap(ncap)
 			}
 			new := reflect.MakeSlice(val.Type(), val.Len(), ncap)
 			reflect.Copy(new, val)
@@ -242,7 +242,16 @@ func (p *Decoder) unmarshalArray(a *cfArray, val reflect.Value) {
 		p.unmarshal(sval, val.Index(n))
 		n++
 	}
-	return
+}
+
+func growSliceCap(cap int) int {
+	if cap == 0 {
+		return 4
+	} else if cap < 1024 {
+		return cap * 2 // Double for small slices
+	} else {
+		return cap + cap/4 // Increase by 25% for large slices
+	}
 }
 
 func (p *Decoder) unmarshalDictionary(dict *cfDictionary, val reflect.Value) {