groot: implement RSlicer for TH{1,2}x

Signed-off-by: Sebastien Binet <binet@cern.ch>

groot/gen.rhist.go

@@ -232,6 +232,14 @@ func (h *{{.Name}}) UnmarshalROOT(r *rbytes.RBuffer) error {
 	return r.Err()
 }
 
+func (h *{{.Name}}) RMembers() (mbrs []rbytes.Member) {
+	mbrs = append(mbrs, h.th1.RMembers()...)
+	mbrs = append(mbrs, rbytes.Member{
+		"fArray", &h.arr.Data,
+	})
+	return mbrs
+}
+
 func (h *{{.Name}}) Array() {{.Type}} {
 	return h.arr
 }
@@ -411,6 +419,7 @@ var (
 	_ H1                 = (*{{.Name}})(nil)
 	_ rbytes.Marshaler   = (*{{.Name}})(nil)
 	_ rbytes.Unmarshaler = (*{{.Name}})(nil)
+	_ rbytes.RSlicer     = (*{{.Name}})(nil)
 )
 `
 
@@ -783,6 +792,14 @@ func (h *{{.Name}}) UnmarshalROOT(r *rbytes.RBuffer) error {
 	return r.Err()
 }
 
+func (h *{{.Name}}) RMembers() (mbrs []rbytes.Member) {
+	mbrs = append(mbrs, h.th2.RMembers()...)
+	mbrs = append(mbrs, rbytes.Member{
+		"fArray", &h.arr.Data,
+	})
+	return mbrs
+}
+
 func init() {
 	f := func() reflect.Value {
 		o := new{{.Name}}()
@@ -797,5 +814,6 @@ var (
 	_ H2                 = (*{{.Name}})(nil)
 	_ rbytes.Marshaler   = (*{{.Name}})(nil)
 	_ rbytes.Unmarshaler = (*{{.Name}})(nil)
+	_ rbytes.RSlicer     = (*{{.Name}})(nil)
 )
 `

groot/rbase/attaxis.go

@@ -100,6 +100,23 @@ func (a *AttAxis) UnmarshalROOT(r *rbytes.RBuffer) error {
 	return r.Err()
 }
 
+func (a *AttAxis) RMembers() (mbrs []rbytes.Member) {
+	mbrs = append(mbrs, []rbytes.Member{
+		{"fNdivisions", &a.Ndivs},
+		{"fAxisColor", &a.AxisColor},
+		{"fLabelColor", &a.LabelColor},
+		{"fLabelFont", &a.LabelFont},
+		{"fLabelOffset", &a.LabelOffset},
+		{"fLabelSize", &a.LabelSize},
+		{"fTickLength", &a.Ticks},
+		{"fTitleOffset", &a.TitleOffset},
+		{"fTitleSize", &a.TitleSize},
+		{"fTitleColor", &a.TitleColor},
+		{"fTitleFont", &a.TitleFont},
+	}...)
+	return mbrs
+}
+
 func init() {
 	f := func() reflect.Value {
 		o := NewAttAxis()

groot/rbase/attfill.go

@@ -58,6 +58,13 @@ func (a *AttFill) UnmarshalROOT(r *rbytes.RBuffer) error {
 	return r.Err()
 }
 
+func (a *AttFill) RMembers() []rbytes.Member {
+	return []rbytes.Member{
+		{"fFillColor", &a.Color},
+		{"fFillStyle", &a.Style},
+	}
+}
+
 func init() {
 	f := func() reflect.Value {
 		o := NewAttFill()

groot/rbase/attline.go

@@ -67,6 +67,14 @@ func (a *AttLine) UnmarshalROOT(r *rbytes.RBuffer) error {
 	return r.Err()
 }
 
+func (a *AttLine) RMembers() []rbytes.Member {
+	return []rbytes.Member{
+		{"fLineColor", &a.Color},
+		{"fLineStyle", &a.Style},
+		{"fLineWidth", &a.Width},
+	}
+}
+
 func init() {
 	f := func() reflect.Value {
 		o := NewAttLine()

groot/rbase/attmarker.go

@@ -66,6 +66,14 @@ func (a *AttMarker) UnmarshalROOT(r *rbytes.RBuffer) error {
 	return r.Err()
 }
 
+func (a *AttMarker) RMembers() []rbytes.Member {
+	return []rbytes.Member{
+		{"fMarkerColor", &a.Color},
+		{"fMarkerStyle", &a.Style},
+		{"fMarkerSize", &a.Width},
+	}
+}
+
 func init() {
 	f := func() reflect.Value {
 		o := NewAttMarker()

groot/rbase/named.go

@@ -102,6 +102,14 @@ func (n *Named) MarshalROOT(w *rbytes.WBuffer) (int, error) {
 	return w.SetHeader(hdr)
 }
 
+func (n *Named) RMembers() []rbytes.Member {
+	o := n.obj.RMembers()
+	return append(o, []rbytes.Member{
+		{"fName", &n.name},
+		{"fTitle", &n.title},
+	}...)
+}
+
 func init() {
 	f := func() reflect.Value {
 		o := NewNamed("", "")

groot/rbase/object.go

@@ -69,6 +69,13 @@ func (obj *Object) MarshalROOT(w *rbytes.WBuffer) (int, error) {
 	return int(w.Pos() - n), w.Err()
 }
 
+func (obj *Object) RMembers() []rbytes.Member {
+	return []rbytes.Member{
+		{"fUniqueID", &obj.ID},
+		{"fBits", &obj.Bits},
+	}
+}
+
 func init() {
 	f := func() reflect.Value {
 		o := &Object{}

groot/rcont/list.go

@@ -124,6 +124,24 @@ func (li *List) UnmarshalROOT(r *rbytes.RBuffer) error {
 	return r.Err()
 }
 
+func (l *List) RMembers() (mbrs []rbytes.Member) {
+	var (
+		arr  []root.Object
+		opts []string
+	)
+	if len(l.objs) > 0 {
+		arr = l.objs
+		opts = l.opts
+	}
+	mbrs = append(mbrs, []rbytes.Member{
+		{"name", &l.name},
+		{"arr", &arr},
+		{"opt", &opts},
+	}...)
+
+	return mbrs
+}
+
 type HashList struct {
 	List
 }

groot/rhist/axis.go

@@ -176,6 +176,25 @@ func (a *taxis) UnmarshalROOT(r *rbytes.RBuffer) error {
 	return r.Err()
 }
 
+func (a *taxis) RMembers() (mbrs []rbytes.Member) {
+	mbrs = append(mbrs, a.Named.RMembers()...)
+	mbrs = append(mbrs, a.attaxis.RMembers()...)
+	mbrs = append(mbrs, []rbytes.Member{
+		{"fNbins", &a.nbins},
+		{"fXmin", &a.xmin},
+		{"fXmax", &a.xmax},
+		{"fXbins", &a.xbins.Data},
+		{"fFirst", &a.first},
+		{"fLast", &a.last},
+		{"fBits2", &a.bits2},
+		{"fTimeDisplay", &a.time},
+		{"fTimeFormat", &a.tfmt},
+		{"fLabels", &a.labels},
+		{"fModLabs", &a.modlabs},
+	}...)
+	return mbrs
+}
+
 func init() {
 	{
 		f := func() reflect.Value {

groot/rhist/h1_gen.go

@@ -115,6 +115,14 @@ func (h *H1F) UnmarshalROOT(r *rbytes.RBuffer) error {
 	return r.Err()
 }
 
+func (h *H1F) RMembers() (mbrs []rbytes.Member) {
+	mbrs = append(mbrs, h.th1.RMembers()...)
+	mbrs = append(mbrs, rbytes.Member{
+		"fArray", &h.arr.Data,
+	})
+	return mbrs
+}
+
 func (h *H1F) Array() rcont.ArrayF {
 	return h.arr
 }
@@ -294,6 +302,7 @@ var (
 	_ H1                 = (*H1F)(nil)
 	_ rbytes.Marshaler   = (*H1F)(nil)
 	_ rbytes.Unmarshaler = (*H1F)(nil)
+	_ rbytes.RSlicer     = (*H1F)(nil)
 )
 
 // H1D implements ROOT TH1D
@@ -392,6 +401,14 @@ func (h *H1D) UnmarshalROOT(r *rbytes.RBuffer) error {
 	return r.Err()
 }
 
+func (h *H1D) RMembers() (mbrs []rbytes.Member) {
+	mbrs = append(mbrs, h.th1.RMembers()...)
+	mbrs = append(mbrs, rbytes.Member{
+		"fArray", &h.arr.Data,
+	})
+	return mbrs
+}
+
 func (h *H1D) Array() rcont.ArrayD {
 	return h.arr
 }
@@ -571,6 +588,7 @@ var (
 	_ H1                 = (*H1D)(nil)
 	_ rbytes.Marshaler   = (*H1D)(nil)
 	_ rbytes.Unmarshaler = (*H1D)(nil)
+	_ rbytes.RSlicer     = (*H1D)(nil)
 )
 
 // H1I implements ROOT TH1I
@@ -669,6 +687,14 @@ func (h *H1I) UnmarshalROOT(r *rbytes.RBuffer) error {
 	return r.Err()
 }
 
+func (h *H1I) RMembers() (mbrs []rbytes.Member) {
+	mbrs = append(mbrs, h.th1.RMembers()...)
+	mbrs = append(mbrs, rbytes.Member{
+		"fArray", &h.arr.Data,
+	})
+	return mbrs
+}
+
 func (h *H1I) Array() rcont.ArrayI {
 	return h.arr
 }
@@ -848,4 +874,5 @@ var (
 	_ H1                 = (*H1I)(nil)
 	_ rbytes.Marshaler   = (*H1I)(nil)
 	_ rbytes.Unmarshaler = (*H1I)(nil)
+	_ rbytes.RSlicer     = (*H1I)(nil)
 )

groot/rhist/h2_gen.go

@@ -388,6 +388,14 @@ func (h *H2F) UnmarshalROOT(r *rbytes.RBuffer) error {
 	return r.Err()
 }
 
+func (h *H2F) RMembers() (mbrs []rbytes.Member) {
+	mbrs = append(mbrs, h.th2.RMembers()...)
+	mbrs = append(mbrs, rbytes.Member{
+		"fArray", &h.arr.Data,
+	})
+	return mbrs
+}
+
 func init() {
 	f := func() reflect.Value {
 		o := newH2F()
@@ -402,6 +410,7 @@ var (
 	_ H2                 = (*H2F)(nil)
 	_ rbytes.Marshaler   = (*H2F)(nil)
 	_ rbytes.Unmarshaler = (*H2F)(nil)
+	_ rbytes.RSlicer     = (*H2F)(nil)
 )
 
 // H2D implements ROOT TH2D
@@ -773,6 +782,14 @@ func (h *H2D) UnmarshalROOT(r *rbytes.RBuffer) error {
 	return r.Err()
 }
 
+func (h *H2D) RMembers() (mbrs []rbytes.Member) {
+	mbrs = append(mbrs, h.th2.RMembers()...)
+	mbrs = append(mbrs, rbytes.Member{
+		"fArray", &h.arr.Data,
+	})
+	return mbrs
+}
+
 func init() {
 	f := func() reflect.Value {
 		o := newH2D()
@@ -787,6 +804,7 @@ var (
 	_ H2                 = (*H2D)(nil)
 	_ rbytes.Marshaler   = (*H2D)(nil)
 	_ rbytes.Unmarshaler = (*H2D)(nil)
+	_ rbytes.RSlicer     = (*H2D)(nil)
 )
 
 // H2I implements ROOT TH2I
@@ -1158,6 +1176,14 @@ func (h *H2I) UnmarshalROOT(r *rbytes.RBuffer) error {
 	return r.Err()
 }
 
+func (h *H2I) RMembers() (mbrs []rbytes.Member) {
+	mbrs = append(mbrs, h.th2.RMembers()...)
+	mbrs = append(mbrs, rbytes.Member{
+		"fArray", &h.arr.Data,
+	})
+	return mbrs
+}
+
 func init() {
 	f := func() reflect.Value {
 		o := newH2I()
@@ -1172,4 +1198,5 @@ var (
 	_ H2                 = (*H2I)(nil)
 	_ rbytes.Marshaler   = (*H2I)(nil)
 	_ rbytes.Unmarshaler = (*H2I)(nil)
+	_ rbytes.RSlicer     = (*H2I)(nil)
 )

groot/rhist/hist.go

@@ -204,6 +204,39 @@ func (h *th1) UnmarshalROOT(r *rbytes.RBuffer) error {
 	return r.Err()
 }
 
+func (h *th1) RMembers() (mbrs []rbytes.Member) {
+	mbrs = append(mbrs, h.Named.RMembers()...)
+	mbrs = append(mbrs, h.attline.RMembers()...)
+	mbrs = append(mbrs, h.attfill.RMembers()...)
+	mbrs = append(mbrs, h.attmarker.RMembers()...)
+	mbrs = append(mbrs, []rbytes.Member{
+		{"fNcells", &h.ncells},
+		{"fXaxis", &h.xaxis},
+		{"fYaxis", &h.yaxis},
+		{"fZaxis", &h.zaxis},
+		{"fBarOffset", &h.boffset},
+		{"fBarWidth", &h.bwidth},
+		{"fEntries", &h.entries},
+		{"fTsumw", &h.tsumw},
+		{"fTsumw2", &h.tsumw2},
+		{"fTsumwx", &h.tsumwx},
+		{"fTsumwx2", &h.tsumwx2},
+		{"fMaximum", &h.max},
+		{"fMinimum", &h.min},
+		{"fNormFactor", &h.norm},
+		{"fContour", &h.contour.Data},
+		{"fSumw2", &h.sumw2.Data},
+		{"fOption", &h.opt},
+		{"fFunctions", &h.funcs},
+		{"fBufferSize", len(h.buffer)}, // FIXME(sbinet)
+		{"fBuffer", &h.buffer},
+		{"fBinStatErrOpt", &h.erropt},
+		{"fStatOverflows", &h.oflow},
+	}...)
+
+	return mbrs
+}
+
 type th2 struct {
 	th1
 	scale   float64 // scale factor
@@ -265,6 +298,18 @@ func (h *th2) UnmarshalROOT(r *rbytes.RBuffer) error {
 	return r.Err()
 }
 
+func (h *th2) RMembers() (mbrs []rbytes.Member) {
+	mbrs = append(mbrs, h.th1.RMembers()...)
+	mbrs = append(mbrs, []rbytes.Member{
+		{"fScalefactor", &h.scale},
+		{"fTsumwy", &h.tsumwy},
+		{"fTsumwy2", &h.tsumwy2},
+		{"fTsumwxy", &h.tsumwxy},
+	}...)
+
+	return mbrs
+}
+
 // SumWY returns the total sum of weights*y
 func (h *th2) SumWY() float64 {
 	return h.tsumwy
@@ -302,6 +347,7 @@ var (
 	_ root.Named         = (*th1)(nil)
 	_ rbytes.Marshaler   = (*th1)(nil)
 	_ rbytes.Unmarshaler = (*th1)(nil)
+	_ rbytes.RSlicer     = (*th1)(nil)
 
 	_ root.Object        = (*th2)(nil)
 	_ root.Named         = (*th2)(nil)