codec: remove comment blocks at bottom of files

We kept commented out code at bottom of files for easy access.

As we prepare to release a new version, we can now clean up the codebase
and remove the clutter.

Author: ugorji

codec/0_init_test.go

@@ -223,76 +223,3 @@ func approxDataSize(rv reflect.Value) (sum int) {
 	}
 	return
 }
-
-// // --- functions below are used by both benchmarks and tests
-
-// // log message only when testVerbose = true (ie go test ... -- -tv).
-// //
-// // These are for intormational messages that do not necessarily
-// // help with diagnosing a failure, or which are too large.
-// func logTv(x interface{}, format string, args ...interface{}) {
-// 	if !testVerbose {
-// 		return
-// 	}
-// 	if t, ok := x.(testing.TB); ok { // only available from go 1.9
-// 		t.Helper()
-// 	}
-// 	logT(x, format, args...)
-// }
-
-// // logT logs messages when running as go test -v
-// //
-// // Use it for diagnostics messages that help diagnost failure,
-// // and when the output is not too long ie shorter than like 100 characters.
-// //
-// // In general, any logT followed by failT should call this.
-// func logT(x interface{}, format string, args ...interface{}) {
-// 	if x == nil {
-// 		if len(format) == 0 || format[len(format)-1] != '\n' {
-// 			format = format + "\n"
-// 		}
-// 		fmt.Printf(format, args...)
-// 		return
-// 	}
-// 	if t, ok := x.(testing.TB); ok { // only available from go 1.9
-// 		t.Helper()
-// 		t.Logf(format, args...)
-// 	}
-// }
-
-// func failTv(x testing.TB, args ...interface{}) {
-// 	x.Helper()
-// 	if testVerbose {
-// 		failTMsg(x, args...)
-// 	}
-// 	x.FailNow()
-// }
-
-// func failT(x testing.TB, args ...interface{}) {
-// 	x.Helper()
-// 	failTMsg(x, args...)
-// 	x.FailNow()
-// }
-
-// func failTMsg(x testing.TB, args ...interface{}) {
-// 	x.Helper()
-// 	if len(args) > 0 {
-// 		if format, ok := args[0].(string); ok {
-// 			logT(x, format, args[1:]...)
-// 		} else if len(args) == 1 {
-// 			logT(x, "%v", args[0])
-// 		} else {
-// 			logT(x, "%v", args)
-// 		}
-// 	}
-// }
-
-// --- functions below are used only by benchmarks alone
-
-// func benchFnCodecEncode(ts interface{}, bsIn []byte, h Handle) (bs []byte, err error) {
-// 	return testCodecEncode(ts, bsIn, fnBenchmarkByteBuf, h)
-// }
-
-// func benchFnCodecDecode(bs []byte, ts interface{}, h Handle) (err error) {
-// 	return testCodecDecode(bs, ts, h)
-// }

codec/base.notfastpath.go

@@ -32,6 +32,3 @@ type fastpathRtRtid struct {
 type fastpathARtRtid [0]fastpathRtRtid
 
 var fastpathAvRtRtid fastpathARtRtid
-
-//var fastpathAV fastpathA
-// var fastpathTV fastpathT

codec/codec_run_test.go

@@ -4178,74 +4178,3 @@ func testEqualH(v1, v2 interface{}, h Handle) (err error) {
 	}
 	return
 }
-
-// func testEqualH(v1, v2 interface{}, h Handle) (err error) {
-// 	// ...
-// 	//
-// 	// var o gocmp.Option
-// 	// var p []gocmp.Option
-// 	// if zeroAsNil {
-// 	// }
-// 	// if mapKeyAsStr {
-// 	// }
-// 	// if bh.NilCollectionToZeroLength {
-// 	//
-// 	// ...
-// 	//
-// 	// o = gocmpopts.AcyclicTransformer("T1", f)
-// 	// p = append(p, o)
-// 	// if !gocmp.Equal(v1, v2, p...) {
-// 	// 	if testv.UseDiff {
-// 	// 		err = errors.New(gocmp.Diff(v1, v2, p...))
-// 	// 	} else {
-// 	// 		err = errDeepEqualNotMatch
-// 	// 	}
-// 	// }
-// 	// return
-// 	//
-// 	// ...
-// 	//
-// 	// o = cmp.Transformer("T1", func(in interface{}) (out interface{}) {
-// 	// 	out.Real, out.Imag = real(in), imag(in)
-// 	// 	return out
-// 	// })
-// }
-
-// type testUnixNanoTimeExt struct {
-// 	// keep timestamp here, so that do not incur interface-conversion costs
-// 	// ts int64
-// }
-
-// func (x *testUnixNanoTimeExt) WriteExt(v interface{}) []byte {
-// 	v2 := v.(*time.Time)
-// 	bs := make([]byte, 8)
-// 	bigenstd.PutUint64(bs, uint64(v2.UnixNano()))
-// 	return bs
-// }
-// func (x *testUnixNanoTimeExt) ReadExt(v interface{}, bs []byte) {
-// 	v2 := v.(*time.Time)
-// 	ui := bigenstd.Uint64(bs)
-// 	*v2 = time.Unix(0, int64(ui)).UTC()
-// }
-
-// type testUnixNanoTimeInterfaceExt struct{}
-
-// func (x testUnixNanoTimeInterfaceExt) ConvertExt(v interface{}) interface{} {
-// 	v2 := v.(*time.Time) // structs are encoded by passing the ptr
-// 	return v2.UTC().UnixNano()
-// }
-
-// func (x testUnixNanoTimeInterfaceExt) UpdateExt(dest interface{}, v interface{}) {
-// 	tt := dest.(*time.Time)
-// 	*tt = time.Unix(0, v.(int64)).UTC()
-// 	// switch v2 := v.(type) {
-// 	// case int64:
-// 	// 	*tt = time.Unix(0, v2).UTC()
-// 	// case uint64:
-// 	// 	*tt = time.Unix(0, int64(v2)).UTC()
-// 	// //case float64:
-// 	// //case string:
-// 	// default:
-// 	// 	panic(fmt.Errorf("unsupported format for time conversion: expecting int64/uint64; got %T", v))
-// 	// }
-// }

codec/decode.base.go

@@ -942,85 +942,3 @@ func bytesOKdbi(v []byte, _ dBytesIntoState) []byte {
 func bytesOKs(bs []byte, _ dBytesAttachState) []byte {
 	return bs
 }
-
-// ----
-
-// func (d *decoderBase) isAttachedReaderBytes(usingBuf bool) bool {
-// 	return usingBuf || !(d.bytes && d.zeroCopy)
-// }
-
-// func (d *decoderBase) stringZC(v []byte, state dBytesAttachState) (s string) {
-// 	// This method is called a lot. Inlining helps with performance.
-// 	//
-// 	// MARKER: TUNED BELOW TO force inlining
-// 	// - inlined d.string(...)
-// 	// - remove if len(v) == 0 { check
-// 	// - used double indexing to eliminate inline cost of the addition (v[0]:v[0]+1)
-
-// 	// if len(v) == 0 {
-// 	// } else if len(v) == 1 {
-// 	if len(v) == 1 {
-// 		s = str4byte(v[0]) // str256[v[0]:][:1] // str256[v[0] : v[0]+1]
-// 		// s = unsafe.String((*byte)(unsafe.Add(unsafe.Pointer(unsafe.StringData(str256)), v[0])), 1)
-// 	} else if state == dBytesAttachViewZerocopy { // !scratchBuf && d.bytes && d.zeroCopy
-// 		s = stringView(v)
-// 	} else if d.is == nil || d.c != containerMapKey || len(v) > internMaxStrLen {
-// 		s = string(v)
-// 	} else {
-// 		s = d.is.string(v)
-// 	}
-// 	return
-// }
-
-// func (d *decoderBase) string(v []byte) (s string) {
-// 	if d.is == nil || d.c != containerMapKey || len(v) < 2 || len(v) > internMaxStrLen {
-// 		return string(v)
-// 	}
-// 	return d.is.string(v)
-// }
-
-// func (x decNegintPosintFloatNumberHelper) roundFloat(v float64, prec int) float64 {
-// 	ratio := math.Pow(10, float64(prec))
-// 	return math.Round(v*ratio) / ratio
-// }
-
-// func (d *decoderBase) interfaceExtConvertAndDecodeGetRV(v interface{}, ext InterfaceExt) reflect.Value {
-// 	// var v interface{} = ext.ConvertExt(rv)
-// 	// d.d.decode(&v)
-// 	// ext.UpdateExt(rv, v)
-
-// 	// assume v is a pointer:
-// 	// - if struct|array, pass as is to ConvertExt
-// 	// - else make it non-addressable and pass to ConvertExt
-// 	// - make return value from ConvertExt addressable
-// 	// - decode into it
-// 	// - return the interface for passing into UpdateExt.
-// 	// - interface should be a pointer if struct|array, else a value
-
-// 	var s interface{}
-// 	rv := reflect.ValueOf(v)
-// 	rv2 := rv.Elem()
-// 	rvk := rv2.Kind()
-// 	if rvk == reflect.Struct || rvk == reflect.Array {
-// 		s = ext.ConvertExt(v)
-// 	} else {
-// 		s = ext.ConvertExt(rv2i(rv2))
-// 	}
-// 	rv = reflect.ValueOf(s)
-
-// 	// We cannot use isDecodeable here, as the value converted may be nil,
-// 	// or it may not be nil but is not addressable and thus we cannot extend it, etc.
-// 	// Instead, we just ensure that the value is addressable.
-
-// 	if !rv.CanAddr() {
-// 		rvk = rv.Kind()
-// 		rv2 = d.oneShotAddrRV(rv.Type(), rvk)
-// 		if rvk == reflect.Interface {
-// 			rvSetIntf(rv2, rv)
-// 		} else {
-// 			rvSetDirect(rv2, rv)
-// 		}
-// 		rv = rv2
-// 	}
-// 	return rv
-// }

codec/decode.go

@@ -1959,119 +1959,3 @@ func (dh helperDecDriver[T]) decFnLoad(rt reflect.Type, rtid uintptr, tinfos *Ty
 	}
 	return
 }
-
-// // --------------------------------------------------
-
-// // decSliceHelper assists when decoding into a slice, from a map or an array in the stream.
-// // A slice can be set from a map or array in stream. This supports the MapBySlice interface.
-// //
-// // Note: if IsNil, do not call ElemContainerState.
-// type decSliceHelper[T decDriver] struct {
-// 	d     *decoder[T]
-// 	ct    valueType
-// 	Array bool
-// 	IsNil bool
-// }
-
-// func (d *decoder[T]) decSliceHelperStart() (x decSliceHelper[T], clen int) {
-// 	x.ct = d.d.ContainerType()
-// 	x.d = d
-// 	switch x.ct {
-// 	case valueTypeNil:
-// 		x.IsNil = true
-// 	case valueTypeArray:
-// 		x.Array = true
-// 		clen = d.arrayStart(d.d.ReadArrayStart())
-// 	case valueTypeMap:
-// 		clen = d.mapStart(d.d.ReadMapStart())
-// 		clen += clen
-// 	default:
-// 		halt.errorStr2("to decode into a slice, expect map/array - got ", x.ct.String())
-// 	}
-// 	return
-// }
-
-// func (x decSliceHelper[T]) End() {
-// 	if x.IsNil {
-// 	} else if x.Array {
-// 		x.d.arrayEnd()
-// 	} else {
-// 		x.d.mapEnd()
-// 	}
-// }
-
-// func (x decSliceHelper[T]) ElemContainerState(index int) {
-// 	// Note: if isnil, clen=0, so we never call into ElemContainerState
-// 	if x.Array {
-// 		x.d.arrayElem(index == 0)
-// 	} else if index&1 == 0 { // index%2 == 0 {
-// 		x.d.mapElemKey(index == 0)
-// 	} else {
-// 		x.d.mapElemValue()
-// 	}
-// }
-
-// // func (x decSliceHelper[T]) arrayCannotExpand(hasLen bool, lenv, j, containerLenS int) {
-// // 	x.d.arrayCannotExpand(lenv, j+1)
-// // 	// drain completely and return
-// // 	x.ElemContainerState(j)
-// // 	x.d.swallow()
-// // 	j++
-// // 	for ; x.d.containerNext(j, containerLenS, hasLen); j++ {
-// // 		x.ElemContainerState(j)
-// // 		x.d.swallow()
-// // 	}
-// // 	x.End()
-// // }
-
-// func (x decSliceHelper[T]) arrayCannotExpand(hasLen bool, lenv, j, containerLenS int) {
-// 	x.d.arrayCannotExpand(lenv, j+1)
-// 	x.d.drainSeq(x.ct == valueTypeArray, hasLen, containerLenS, j)
-// }
-
-// func (d *decoder[T]) drainSeq(isArray, hasLen bool, containerLenS, j int) {
-// 	// drain completely and return
-// LOOP:
-// 	if isArray {
-// 		d.arrayElem(j == 0)
-// 	} else if j&1 == 0 {
-// 		d.mapElemKey(j == 0)
-// 	} else {
-// 		d.mapElemValue()
-// 	}
-// 	d.swallow()
-// 	j++
-// 	if d.containerNext(j, containerLenS, hasLen) {
-// 		goto LOOP
-// 	}
-// 	if isArray {
-// 		d.arrayEnd()
-// 	} else {
-// 		d.mapEnd()
-// 	}
-// }
-
-// func (d *decoder[T]) swallowErr() (err error) {
-// 	if !debugging {
-// 		defer func() {
-// 			if x := recover(); x != nil {
-// 				panicValToErr(d, x, &err)
-// 			}
-// 		}()
-// 	}
-// 	d.swallow()
-// 	return
-// }
-
-// func (d *decoder[T]) zerocopy() bool {
-// 	return d.bytes && d.h.ZeroCopy
-// }
-
-// // decodeFloat32 will delegate to an appropriate DecodeFloat32 implementation (if exists),
-// // else if will call DecodeFloat64 and ensure the value doesn't overflow.
-// //
-// // Note that we return float64 to reduce unnecessary conversions
-// func (d *decoder[T]) decodeFloat32() float32 {
-// 	d.d.DecodeFloat32() // custom implementation for 32-bit
-// 	return float32(chkOvf.Float32V(d.d.DecodeFloat64()))
-// }