groot/{rbytes,rdict}: add BuildStreamers API

groot/rbytes/rbytes.go

@@ -27,6 +27,9 @@ type StreamerInfo interface {
 	CheckSum() int
 	ClassVersion() int
 	Elements() []StreamerElement
+
+	// BuildStreamers builds the r/w streamers.
+	BuildStreamers() error
 }
 
 // StreamerElement describes a ROOT StreamerElement

groot/rdict/rdict.go

@@ -12,6 +12,7 @@ import (
 	"reflect"
 	"strconv"
 	"strings"
+	"sync"
 	"text/tabwriter"
 
 	"go-hep.org/x/hep/groot/rbase"
@@ -34,6 +35,13 @@ type StreamerInfo struct {
 	clsver int32
 	objarr *rcont.ObjArray
 	elems  []rbytes.StreamerElement
+
+	mu       sync.Mutex
+	init     bool
+	robjwise interface{}
+	wobjwise interface{}
+	rmbrwise interface{}
+	wmbrwise interface{}
 }
 
 // NewStreamerInfo creates a new StreamerInfo from Go provided informations.
@@ -151,6 +159,28 @@ func (si *StreamerInfo) String() string {
 
 }
 
+// BuildStreamers builds the r/w streamers.
+func (si *StreamerInfo) BuildStreamers() error {
+	si.mu.Lock()
+	defer si.mu.Unlock()
+	if si.init {
+		return nil
+	}
+	return si.build()
+}
+
+func (si *StreamerInfo) build() (err error) {
+	panic("not implemented")
+
+	defer func() {
+		if err == nil {
+			si.init = true
+		}
+	}()
+
+	return err
+}
+
 type Element struct {
 	Name   rbase.Named
 	Type   rmeta.Enum // element type
@@ -825,7 +855,7 @@ func NewStreamerSTL(name string, vtype rmeta.ESTLType, ctype rmeta.Enum) *Stream
 		StreamerElement: StreamerElement{
 			named: *rbase.NewNamed(name, ""),
 			esize: int32(ptrSize + 2*intSize),
-			ename: rmeta.STLNameFor(vtype, ctype),
+			ename: rmeta.STLNameFrom(name, vtype, ctype),
 			etype: rmeta.Streamer,
 		},
 		vtype: vtype,

groot/riofs/streamers.go

@@ -20,9 +20,10 @@ var (
 )
 
 func stdvecSIFrom(name, ename string, ctx rbytes.StreamerInfoContext) rbytes.StreamerInfo {
+	const vers = 1
 	ename = strings.TrimSpace(ename)
 	if etyp, ok := rmeta.CxxBuiltins[ename]; ok {
-		si := rdict.NewStreamerInfo(name, 1, []rbytes.StreamerElement{
+		si := rdict.NewStreamerInfo(name, vers, []rbytes.StreamerElement{
 			rdict.NewStreamerSTL(
 				name, rmeta.STLvector, rmeta.GoType2ROOTEnum[etyp],
 			),
@@ -34,7 +35,7 @@ func stdvecSIFrom(name, ename string, ctx rbytes.StreamerInfoContext) rbytes.Str
 		return nil
 	}
 
-	si := rdict.NewStreamerInfo(name, 1, []rbytes.StreamerElement{
+	si := rdict.NewStreamerInfo(name, vers, []rbytes.StreamerElement{
 		rdict.NewStreamerSTL(name, rmeta.STLvector, rmeta.Object),
 	})
 	return si

groot/rmeta/cxx.go

@@ -129,6 +129,13 @@ var CxxBuiltins = map[string]reflect.Type{
 	"Size_t":   reflect.TypeOf(float32(0)),
 }
 
+func STLNameFrom(name string, vtype ESTLType, ctype Enum) string {
+	if ctype == Object {
+		return name
+	}
+	return STLNameFor(vtype, ctype)
+}
+
 // STLNameFor creates a regular C++ STL container name given a STL enum type
 // and a ROOT enum value for the contained element.
 func STLNameFor(vtype ESTLType, ctype Enum) string {
@@ -222,5 +229,5 @@ func rmeta2Name(t Enum) string {
 	case STLstring:
 		return "string"
 	}
-	panic(fmt.Errorf("not implemented: t=%d (%v)", t, t))
+	panic(fmt.Errorf("not implemented: t=%v (%d)", t, t))
 }

groot/rtree/read_streamers.go

@@ -675,6 +675,21 @@ func rstreamerFrom(se rbytes.StreamerElement, ptr interface{}, lcnt leafCount, s
 					return r.Err()
 				}
 
+			case rmeta.UChar:
+				fptr := rf.Addr().Interface().(*[]uint8)
+				return func(r *rbytes.RBuffer) error {
+					var hdr [6]byte
+					_, _ = r.Read(hdr[:])
+					n := int(r.ReadI32())
+					*fptr = rbytes.ResizeU8(*fptr, n)
+					if n > 0 {
+						r.ReadArrayU8(*fptr)
+					} else {
+						*fptr = []uint8{}
+					}
+					return r.Err()
+				}
+
 			case rmeta.UShort:
 				fptr := rf.Addr().Interface().(*[]uint16)
 				return func(r *rbytes.RBuffer) error {
@@ -735,8 +750,40 @@ func rstreamerFrom(se rbytes.StreamerElement, ptr interface{}, lcnt leafCount, s
 					return r.Err()
 				}
 
+			case rmeta.TString:
+				fptr := rf.Addr().Interface().(*[]string)
+				return func(r *rbytes.RBuffer) error {
+					start := r.Pos()
+					_, pos, bcnt := r.ReadVersion("vector<string>")
+					n := int(r.ReadI32())
+					*fptr = make([]string, n)
+					for i := 0; i < n; i++ {
+						(*fptr)[i] = r.ReadString()
+					}
+					r.CheckByteCount(pos, bcnt, start, "vector<string>")
+					return r.Err()
+				}
+
 			case rmeta.Object:
 				switch se.TypeName() {
+				case "vector<vector<float> >":
+					fptr := rf.Addr().Interface().(*[][]float32)
+					return func(r *rbytes.RBuffer) error {
+						start := r.Pos()
+						_, pos, bcnt := r.ReadVersion("vector<vector<float> >")
+						n := int(r.ReadI32())
+						*fptr = make([][]float32, n)
+						for i := 0; i < n; i++ {
+							nn := int(r.ReadI32())
+							(*fptr)[i] = make([]float32, nn)
+							for j := 0; j < nn; j++ {
+								(*fptr)[i][j] = r.ReadF32()
+							}
+						}
+						r.CheckByteCount(pos, bcnt, start, "vector<vector<float> >")
+						return r.Err()
+					}
+
 				case "vector<string>", "std::vector<std::string>":
 					fptr := rf.Addr().Interface().(*[]string)
 					*fptr = make([]string, 0, 8)
@@ -1047,6 +1094,8 @@ func gotypeFromSE(se rbytes.StreamerElement, lcount Leaf, ctx rbytes.StreamerInf
 				return reflect.SliceOf(reflect.TypeOf(uint64(0)))
 			case rmeta.Bool:
 				return reflect.SliceOf(reflect.TypeOf(false))
+			case rmeta.TString:
+				return reflect.SliceOf(reflect.TypeOf(""))
 			case rmeta.Object:
 				switch se.TypeName() {
 				case "vector<string>", "std::vector<std::string>":