added

vendor/github.com/glycerine/greenpack/msgp/nilbits.go

@@ -0,0 +1,126 @@
+package msgp
+
+import (
+	"fmt"
+	//"runtime/debug"
+)
+
+const MaxNestedStructPointerDepth = 8
+
+// NilBitsStack is a helper for Unmarshal
+// methods to track where we are when
+// deserializing from empty/nil/missing
+// fields.
+type NilBitsStack struct {
+	// simulate getting nils on the wire
+	AlwaysNil     bool
+	LifoAlwaysNil int                                 // this lifo always had false in it, so change it to a count.
+	LifoBts       [MaxNestedStructPointerDepth][]byte // caps our static tree depth at 8, but avoids all memory allocation during the decode hotpath.
+
+	// UnsafeZeroCopy will make strings point to the
+	// original msgpack buffers. This is unsafe because
+	// if the buffer changes the string will change/be
+	// invalid/not protected against re-use. But for
+	// processing and disposing of single messages, one-at-at-time,
+	// without re-using any part of a message (or making a copy of strings explicitly with copy()
+	// if you must) then we can avoid all allocations for strings.
+	UnsafeZeroCopy bool
+}
+
+func (r *NilBitsStack) Init(cfg *RuntimeConfig) {
+	if cfg != nil {
+		r.UnsafeZeroCopy = cfg.UnsafeZeroCopy
+	}
+}
+
+func (r *NilBitsStack) IsNil(bts []byte) bool {
+	if r.AlwaysNil {
+		return true
+	}
+	if len(bts) != 0 && bts[0] == mnil {
+		return true
+	}
+	return false
+}
+
+// OnlyNilSlice is a slice that contains
+// only the msgpack nil (0xc0) bytes.
+var OnlyNilSlice = []byte{mnil}
+
+// AlwaysNilString returns a string representation
+// of the internal state of the NilBitsStack for
+// debugging purposes.
+func (r *NilBitsStack) AlwaysNilString() string {
+
+	s := "bottom: "
+	for i := 0; i > r.LifoAlwaysNil; i++ {
+		s += "T"
+	}
+	/*	for _, v := range r.LifoAlwaysNil {
+			if v {
+				s += "T"
+			} else {
+				s += "f"
+			}
+		}
+	*/
+	return s
+}
+
+// PushAlwaysNil will set r.AlwaysNil to true
+// and store bts on the internal stack.
+func (r *NilBitsStack) PushAlwaysNil(bts []byte) []byte {
+	//fmt.Printf("PushAlwaysNil(), pre we are '%v'. Called from: stack is '%v'\n", r.AlwaysNilString(), string(debug.Stack()))
+	// save current state
+
+	if r.LifoAlwaysNil == MaxNestedStructPointerDepth {
+		panic(fmt.Sprintf("we hit our maximum nested struct-inside-struct depth! you must recompile msgp with github.com/glycerine/greenpack/msgp/nilbits.go: MaxNestedStructPointerDepth set to greater than the current value of %v, and then regenerate your msgp Unmarshaling code.", MaxNestedStructPointerDepth))
+	}
+
+	r.LifoBts[r.LifoAlwaysNil] = bts
+	r.LifoAlwaysNil++
+
+	// set reader r to always return nils
+	r.AlwaysNil = true
+
+	return OnlyNilSlice
+}
+
+// PopAlwaysNil pops the last []byte off the internal
+// stack and returns it. If the stack is empty
+// we panic.
+func (r *NilBitsStack) PopAlwaysNil() (bts []byte) {
+	//fmt.Printf("my NilBitsTack.PopAlwaysNil() called!! ...  stack is '%v'\n", string(debug.Stack()))
+	//	defer func() {
+	//		fmt.Printf("len of bts returned by PopAlwaysNil: %v, and debug string: '%v'\n",
+	//			len(bts), r.AlwaysNilString())
+	//	}()
+	n := r.LifoAlwaysNil
+	if n == 0 {
+		panic("PopAlwaysNil called on empty lifo")
+	}
+	if n < 0 {
+		panic("PopAlwaysNil called on illegal-less-thab-empty lifo")
+	}
+	bts = r.LifoBts[n-1]
+
+	r.LifoAlwaysNil--
+	if r.LifoAlwaysNil == 0 {
+		r.AlwaysNil = false
+	}
+
+	return bts
+}
+
+func ShowFound(found []bool) string {
+	s := "["
+	for i := range found {
+		if found[i] {
+			s += "1,"
+		} else {
+			s += "0,"
+		}
+	}
+	s += "]"
+	return s
+}