.

t/neo/.gitignore

+out.mem
+out.cpu
+mem.out
+cpu.out
+
+# files after go test -c
+*.test

t/neo/xcommon/xfmt/fmt.go

 // TODO copyright/license
 
-// Package xfmt provide addons to std fmt and strconv package with focus on
+// Package xfmt provide addons to std fmt and strconv packages with focus on
 // formatting text without allocations.
 package xfmt
 
@@ -8,6 +8,8 @@ import (
 	"encoding/hex"
 
 	"../xslice"
+
+	"lab.nexedi.com/kirr/go123/mem"
 )
 
 const (
@@ -21,6 +23,15 @@ type Stringer interface {
 	XFmtString(b []byte) []byte
 }
 
+// Buffer provides syntactic sugar for formatting mimicking fmt.Printf style
+// XXX combine with bytes.Buffer ?
+type Buffer []byte
+
+// Reset empties the buffer keeping underlying storage for future formattings
+func (b *Buffer) Reset() {
+	*b = (*b)[:0]
+}
+
 // Append appends to b formatted x
 //
 // NOTE sadly since x is interface it makes real value substituted to it
@@ -32,6 +43,13 @@ func Append(b []byte, x Stringer) []byte {
 	return x.XFmtString(b)
 }
 
+// V, similarly to %v, adds x formatted by default rules
+// XXX -> v(interface {}) ?
+func (b *Buffer) V(x Stringer) *Buffer {
+	*b = Append(*b, x)
+	return b
+}
+
 // AppendHex appends to b hex representation of x
 func AppendHex(b []byte, x []byte) []byte {
 	lx := hex.EncodedLen(len(x))
@@ -41,8 +59,21 @@ func AppendHex(b []byte, x []byte) []byte {
 	return b
 }
 
-// AppendHex64 appends to b x formateed 16-character hex string
-func AppendHex64(b []byte, x uint64) []byte {
+// X, similarly to %x, adds hex representation of x
+func (b *Buffer) X(x []byte) *Buffer {
+	*b = AppendHex(*b, x)
+	return b
+}
+
+// XXX do we need it here ?
+func (b *Buffer) Xs(x string) *Buffer {
+	return b.X(mem.Bytes(x))
+}
+
+// TODO XX = %X
+
+// AppendHex016 appends to b x formatted 16-character hex string
+func AppendHex016(b []byte, x uint64) []byte {
         // like sprintf("%016x") but faster and less allocations
 	l := len(b)
         b = xslice.Grow(b, 16)
@@ -53,3 +84,9 @@ func AppendHex64(b []byte, x uint64) []byte {
         }
 	return b
 }
+
+// X016, similarly to %016x, adds hex representation of uint64 x
+func (b *Buffer) X016(x uint64) *Buffer {
+	*b = AppendHex016(*b, x)
+	return b
+}

t/neo/xcommon/xfmt/fmt_test.go

+// TODO copyright/license
+
+package xfmt
+
+import (
+	"fmt"
+	"reflect"
+	"testing"
+)
+
+// verify formatting result is the same in between std fmt and xfmt
+func TestXFmt(t *testing.T) {
+	testv := []struct {format, xformatMeth string; value interface{}} {
+		{"%x",		"X",		[]byte("hello")},
+		{"%x",		"Xs",		"world"},
+		{"%016x",	"X016",		uint64(124)},
+	}
+
+	buf := &Buffer{}
+	xbuf := reflect.ValueOf(buf)
+
+	for _, tt := range testv {
+		// result via fmt
+		resFmt := fmt.Sprintf(tt.format, tt.value)
+
+		// result via xfmt (via reflect.Call)
+		buf.Reset()
+
+		xmeth := xbuf.MethodByName(tt.xformatMeth)
+		if !xmeth.IsValid() {
+			t.Errorf(".%v: no such method", tt.xformatMeth)
+			continue
+		}
+
+		xargv := []reflect.Value{reflect.ValueOf(tt.value)}
+
+		xretv := []reflect.Value{}
+		callOk := false
+		func () {
+			defer func() {
+				if r := recover(); r != nil {
+					t.Errorf("%v: panic: %v", tt, r)
+				}
+			}()
+			xretv = xmeth.Call(xargv)
+			callOk = true
+		}()
+		if !callOk {
+			continue
+		}
+
+		// check all formatters return pointer to the same buf
+		// (this way it is handy to do .S("hello ") .X016(123) .V(zzz) ...
+		if !(len(xretv) == 1 && xretv[0].Interface() == buf) {
+			t.Errorf(".%v: returned %#v  ; want %#v", tt.xformatMeth, xretv[0].Interface(), buf)
+			continue
+		}
+
+		resXFmt := string(*buf)
+
+		// results must be the same
+		if resFmt != resXFmt {
+			t.Errorf(".%v(%v) -> %q   !=   printf(%q) -> %q",
+				tt.xformatMeth, tt.value, resXFmt, tt.format, resFmt)
+		}
+	}
+}