codec: fix encode/decode struct to array. Other misc fixes.

- Use pointers now that size of structFieldInfos has grown.
- Use unsorted field names consistently.
- Fix up test initialization

Update #13 .

codec/bench_test.go

@@ -31,7 +31,6 @@ var (
 	//For depth>1, we likely trigger stack growth for encoders, making benchmarking unreliable.
 	benchDepth     int
 	benchInitDebug bool
-	benchInitChan  = make(chan bool, 1)
 	benchCheckers  []benchChecker
 )
 
@@ -43,14 +42,15 @@ type benchChecker struct {
 	decodefn benchDecFn
 }
 
-func init() {
+func benchInitFlags() {
 	flag.BoolVar(&benchInitDebug, "bdbg", false, "Bench Debug")
 	flag.IntVar(&benchDepth, "bd", 1, "Bench Depth: If >1, potential unreliable results due to stack growth")
 	flag.BoolVar(&benchDoInitBench, "bi", false, "Run Bench Init")
 	flag.BoolVar(&benchVerify, "bv", false, "Verify Decoded Value during Benchmark")
 	flag.BoolVar(&benchUnscientificRes, "bu", false, "Show Unscientific Results during Benchmark")
-	flag.Parse()
+}
 
+func benchInit() {	
 	benchTs = newTestStruc(benchDepth, true)
 	approxSize = approxDataSize(reflect.ValueOf(benchTs))
 	bytesLen := 1024 * 4 * (benchDepth + 1) * (benchDepth + 1)
@@ -65,10 +65,7 @@ func init() {
 		benchChecker{"json", fnJsonEncodeFn, fnJsonDecodeFn},
 	)
 	if benchDoInitBench {
-		go func() {
-			<-benchInitChan
-			runBenchInit()
-		}()
+		runBenchInit()
 	}
 }
 

codec/codecs_test.go

@@ -48,8 +48,9 @@ const (
 )
 
 var (
-	testInitDebug   bool
-	testUseIoEncDec bool
+	testInitDebug     bool
+	testUseIoEncDec   bool
+	testStructToArray bool
 	_                           = fmt.Printf
 	skipVerifyVal   interface{} = &(struct{}{})
 	timeLoc                     = time.FixedZone("UTC-08:00", -8*60*60)         //time.UTC-8
@@ -68,17 +69,22 @@ var (
 	testBincH    = &BincHandle{}
 )
 
-func init() {
+func testInitFlags() {
 	// delete(testDecOpts.ExtFuncs, timeTyp)
 	flag.BoolVar(&testInitDebug, "tdbg", false, "Test Debug")
 	flag.BoolVar(&testUseIoEncDec, "tio", false, "Use IO Reader/Writer for Marshal/Unmarshal")
-	flag.Parse()
+	flag.BoolVar(&testStructToArray, "ts2a", false, "Set StructToArray option")
+}	
+
+func testInit() {	
 	gob.Register(new(TestStruc))
 	if testInitDebug {
 		ts0 := newTestStruc(2, false)
 		fmt.Printf("====> depth: %v, ts: %#v\n", 2, ts0)
 	}
 
+	testBincH.StructToArray = testStructToArray
+	testMsgpackH.StructToArray = testStructToArray
 	testMsgpackH.RawToString = true 
 	//testMsgpackH.AddExt(byteSliceTyp, 0, testMsgpackH.BinaryEncodeExt, testMsgpackH.BinaryDecodeExt)
 	testMsgpackH.AddExt(timeTyp, 1, testMsgpackH.TimeEncodeExt, testMsgpackH.TimeDecodeExt)
@@ -851,6 +857,7 @@ func TestBincCodecsMisc(t *testing.T) {
 func TestMsgpackRpcGo(t *testing.T) {
 	doTestRpcOne(t, GoRpc, testMsgpackH, true, true, true)
 }
+
 func TestMsgpackRpcSpec(t *testing.T) {
 	doTestRpcOne(t, MsgpackSpecRpc, testMsgpackH, true, true, true)
 }

codec/decode.go

@@ -425,6 +425,7 @@ func (d *Decoder) decodeValue(rv reflect.Value) {
 				break
 			}
 			sfi := getStructFieldInfos(rtid, rt)
+			sissis := sfi.sis 
 			for j := 0; j < containerLen; j++ {
 				// var rvkencname string
 				// ddecode(&rvkencname)
@@ -432,8 +433,8 @@ func (d *Decoder) decodeValue(rv reflect.Value) {
 				rvkencname := dd.decodeString()
 				// rvksi := sfi.getForEncName(rvkencname)
 				if k := sfi.indexForEncName(rvkencname); k > -1 {
-					sfik := sfi.sis[k]
-					if sfik.i > -1 {
+					sfik := sissis[k]
+					if sfik.i != -1 {
 						d.decodeValue(rv.Field(int(sfik.i)))
 					} else {
 						d.decodeValue(rv.FieldByIndex(sfik.is))
@@ -449,12 +450,17 @@ func (d *Decoder) decodeValue(rv reflect.Value) {
 				}
 			}
 		} else if currEncodedType == detArray {
-			containerLen := dd.readMapLen()
+			containerLen := dd.readArrayLen()
 			if containerLen == 0 {
 				break
 			}
-			for j := 0; j < containerLen; j++ {
-				d.decodeValue(rv.Field(j))
+			sfi := getStructFieldInfos(rtid, rt)
+			for _, si := range sfi.sisp {
+				if si.i != -1 {
+					d.decodeValue(rv.Field(int(si.i)))
+				} else {
+					d.decodeValue(rv.FieldByIndex(si.is))
+				}
 			}
 		} else {
 			decErr("Only encoded map or array can be decoded into a struct")

codec/encode.go

@@ -447,19 +447,19 @@ func (e *Encoder) encodeValue(rv reflect.Value) {
 	return
 }
 
-func (e *Encoder) encStruct(sis structFieldInfos, rv reflect.Value) {
+func (e *Encoder) encStruct(sis *structFieldInfos, rv reflect.Value) {
 	newlen := len(sis.sis)
 	rvals := make([]reflect.Value, newlen)
 	var encnames []string
 	toMap := !(sis.toArray || e.h.structToArray())
+	sissis := sis.sisp
+	// if toMap, use the sorted array. If toArray, use unsorted array (to match sequence in struct)
 	if toMap {
+		sissis = sis.sis
 		encnames = make([]string, newlen)
 	}
 	newlen = 0
-	// var rv0 reflect.Value
-	// for i := 0; i < l; i++ {
-	// 	si := sis[i]
-	for _, si := range sis.sis {
+	for _, si := range sissis {
 		if si.i != -1 {
 			rvals[newlen] = rv.Field(int(si.i))
 		} else {
@@ -472,7 +472,7 @@ func (e *Encoder) encStruct(sis structFieldInfos, rv reflect.Value) {
 			encnames[newlen] = si.encName
 		} else {
 			if si.omitEmpty && isEmptyValue(rvals[newlen]) {
-				rvals[newlen] = reflect.Value{}
+				rvals[newlen] = reflect.Value{} //encode as nil
 			}
 		}
 		newlen++

codec/helper.go

@@ -41,7 +41,7 @@ var (
 	bigen               = binary.BigEndian
 	structInfoFieldName = "_struct"
 
-	cachedStructFieldInfos      = make(map[uintptr]structFieldInfos, 4)
+	cachedStructFieldInfos      = make(map[uintptr]*structFieldInfos, 4)
 	cachedStructFieldInfosMutex sync.RWMutex
 
 	nilIntfSlice     = []interface{}(nil)
@@ -107,7 +107,8 @@ type structFieldInfo struct {
 
 type structFieldInfos struct {
 	toArray bool 
-	sis     []structFieldInfo
+	sis     []structFieldInfo // sorted. Used when enc/dec struct to map.
+	sisp    []structFieldInfo // unsorted. Used when enc/dec struct to array.
 }
 
 type sfiSortedByEncName []*structFieldInfo
@@ -124,12 +125,13 @@ func (p sfiSortedByEncName) Swap(i, j int) {
 	p[i], p[j] = p[j], p[i]
 }
 
-func (sis structFieldInfos) indexForEncName(name string) int {
-	sislen := len(sis.sis)
+func (sis *structFieldInfos) indexForEncName(name string) int {
+	sissis := sis.sis 
+	sislen := len(sissis)
 	if sislen < binarySearchThreshold {
 		// linear search. faster than binary search in my testing up to 16-field structs.
 		for i := 0; i < sislen; i++ {
-			if sis.sis[i].encName == name {
+			if sissis[i].encName == name {
 				return i
 			}
 		}
@@ -139,20 +141,20 @@ func (sis structFieldInfos) indexForEncName(name string) int {
 		for i < j {
 			h = i + (j-i)/2
 			// i ≤ h < j
-			if sis.sis[h].encName < name {
+			if sissis[h].encName < name {
 				i = h + 1 // preserves f(i-1) == false
 			} else {
 				j = h // preserves f(j) == true
 			}
 		}
-		if i < sislen && sis.sis[i].encName == name {
+		if i < sislen && sissis[i].encName == name {
 			return i
 		}
 	}
 	return -1
 }
 
-func getStructFieldInfos(rtid uintptr, rt reflect.Type) (sis structFieldInfos) {
+func getStructFieldInfos(rtid uintptr, rt reflect.Type) (sis *structFieldInfos) {
 	var ok bool
 	cachedStructFieldInfosMutex.RLock()
 	sis, ok = cachedStructFieldInfos[rtid]
@@ -167,6 +169,7 @@ func getStructFieldInfos(rtid uintptr, rt reflect.Type) (sis structFieldInfos) {
 		return
 	}
 
+	sis = new(structFieldInfos)
 	var siInfo *structFieldInfo
 	if f, ok := rt.FieldByName(structInfoFieldName); ok {
 		siInfo = parseStructFieldInfo(structInfoFieldName, f.Tag.Get(structTagName))
@@ -174,11 +177,14 @@ func getStructFieldInfos(rtid uintptr, rt reflect.Type) (sis structFieldInfos) {
 	}
 	sisp := make([]*structFieldInfo, 0, rt.NumField())
 	rgetStructFieldInfos(rt, nil, make(map[string]bool), &sisp, siInfo)
+	sis.sisp = make([]structFieldInfo, len(sisp))
+	sis.sis = make([]structFieldInfo, len(sisp))
+	for i := 0; i < len(sisp); i++ {
+		sis.sisp[i] = *sisp[i]
+	}
+	
 	sort.Sort(sfiSortedByEncName(sisp))
-
-	lsis := len(sisp)	
-	sis.sis = make([]structFieldInfo, lsis)
-	for i := 0; i < lsis; i++ {
+	for i := 0; i < len(sisp); i++ {
 		sis.sis[i] = *sisp[i]
 	}
 	// sis = sisp

codec/z_helper_test.go

@@ -12,6 +12,7 @@ package codec
 import (
 	"errors"
 	"reflect"
+	"flag"
 	"testing"
 )
 
@@ -20,9 +21,12 @@ var (
 	failNowOnFail = true
 )
 
-// does final initialization
 func init() {
-	close(benchInitChan)
+	testInitFlags()
+	benchInitFlags()
+	flag.Parse()
+	testInit()
+	benchInit()
 }
 
 func checkErrT(t *testing.T, err error) {