groot/rhist: add write support to TF1 and TFormula

groot/rhist/formula.go

@@ -53,6 +53,31 @@ func (f *Formula) Title() string {
 	return f.named.Title()
 }
 
+// MarshalROOT implements rbytes.Marshaler
+func (f *Formula) MarshalROOT(w *rbytes.WBuffer) (int, error) {
+	if w.Err() != nil {
+		return 0, w.Err()
+	}
+
+	pos := w.WriteVersion(f.RVersion())
+	if n, err := f.named.MarshalROOT(w); err != nil {
+		return n, err
+	}
+	w.WriteStdVectorF64(f.clingParams)
+	w.WriteBool(f.allParamsSet)
+	if n, err := writeMapStringInt(w, f.params); err != nil {
+		return n, err
+	}
+	w.WriteString(f.formula)
+	w.WriteI32(f.ndim)
+	if n, err := writeStdVectorObjP(w, f.linearParts); err != nil {
+		return n, err
+	}
+	w.WriteBool(f.vectorized)
+
+	return w.SetByteCount(pos, f.Class())
+}
+
 func (f *Formula) UnmarshalROOT(r *rbytes.RBuffer) error {
 	if r.Err() != nil {
 		return r.Err()
@@ -79,53 +104,11 @@ func (f *Formula) UnmarshalROOT(r *rbytes.RBuffer) error {
 
 	r.ReadStdVectorF64(&f.clingParams)
 	f.allParamsSet = r.ReadBool()
-	f.params = func() map[string]int32 {
-		if r.Err() != nil {
-			return nil
-		}
-		const typename = "map<TString,int,TFormulaParamOrder>"
-		beg := r.Pos()
-		vers, pos, bcnt := r.ReadVersion(typename)
-		if vers != rvers.StreamerInfo {
-			r.SetErr(fmt.Errorf("rbytes: invalid %s version: got=%d, want=%d",
-				typename, vers, rvers.StreamerInfo,
-			))
-			return nil
-		}
-		n := int(r.ReadI32())
-		o := make(map[string]int32, n)
-		for i := 0; i < n; i++ {
-			k := r.ReadString()
-			v := r.ReadI32()
-			o[k] = v
-		}
-		r.CheckByteCount(pos, bcnt, beg, typename)
-		return o
-	}()
+	f.params = readMapStringInt(r)
 	f.formula = r.ReadString()
 	f.ndim = r.ReadI32()
 
-	f.linearParts = func() []root.Object {
-		if r.Err() != nil {
-			return nil
-		}
-		const typename = "vector<TObject*>"
-		beg := r.Pos()
-		vers, pos, bcnt := r.ReadVersion(typename)
-		if vers != rvers.StreamerInfo {
-			r.SetErr(fmt.Errorf("rbytes: invalid %s version: got=%d, want=%d",
-				typename, vers, rvers.StreamerInfo,
-			))
-			return nil
-		}
-		n := int(r.ReadI32())
-		o := make([]root.Object, n)
-		for i := range o {
-			o[i] = r.ReadObjectAny()
-		}
-		r.CheckByteCount(pos, bcnt, beg, typename)
-		return o
-	}()
+	f.linearParts = readStdVectorObjP(r)
 	f.vectorized = r.ReadBool()
 
 	r.CheckByteCount(pos, bcnt, beg, f.Class())
@@ -136,6 +119,83 @@ func (f *Formula) String() string {
 	return fmt.Sprintf("TFormula{%s}", f.formula)
 }
 
+func readMapStringInt(r *rbytes.RBuffer) map[string]int32 {
+	if r.Err() != nil {
+		return nil
+	}
+	const typename = "map<TString,int,TFormulaParamOrder>"
+	beg := r.Pos()
+	vers, pos, bcnt := r.ReadVersion(typename)
+	if vers != rvers.StreamerInfo {
+		r.SetErr(fmt.Errorf("rbytes: invalid %s version: got=%d, want=%d",
+			typename, vers, rvers.StreamerInfo,
+		))
+		return nil
+	}
+	n := int(r.ReadI32())
+	o := make(map[string]int32, n)
+	for i := 0; i < n; i++ {
+		k := r.ReadString()
+		v := r.ReadI32()
+		o[k] = v
+	}
+	r.CheckByteCount(pos, bcnt, beg, typename)
+	return o
+}
+
+func readStdVectorObjP(r *rbytes.RBuffer) []root.Object {
+	if r.Err() != nil {
+		return nil
+	}
+	const typename = "vector<TObject*>"
+	beg := r.Pos()
+	vers, pos, bcnt := r.ReadVersion(typename)
+	if vers != rvers.StreamerInfo {
+		r.SetErr(fmt.Errorf("rbytes: invalid %s version: got=%d, want=%d",
+			typename, vers, rvers.StreamerInfo,
+		))
+		return nil
+	}
+	n := int(r.ReadI32())
+	o := make([]root.Object, n)
+	for i := range o {
+		o[i] = r.ReadObjectAny()
+	}
+	r.CheckByteCount(pos, bcnt, beg, typename)
+	return o
+}
+
+func writeMapStringInt(w *rbytes.WBuffer, m map[string]int32) (int, error) {
+	if w.Err() != nil {
+		return 0, w.Err()
+	}
+	const typename = "map<TString,int,TFormulaParamOrder>"
+	pos := w.WriteVersion(rvers.StreamerInfo)
+	w.WriteI32(int32(len(m)))
+	// FIXME(sbinet): write in correct order?
+	for k, v := range m {
+		w.WriteString(k)
+		w.WriteI32(v)
+	}
+	return w.SetByteCount(pos, typename)
+}
+
+func writeStdVectorObjP(w *rbytes.WBuffer, vs []root.Object) (int, error) {
+	if w.Err() != nil {
+		return 0, w.Err()
+	}
+	const typename = "vector<TObject*>"
+	pos := w.WriteVersion(rvers.StreamerInfo)
+	w.WriteI32(int32(len(vs)))
+	for i := range vs {
+		err := w.WriteObjectAny(vs[i])
+		if err != nil {
+			return 0, err
+		}
+	}
+	return w.SetByteCount(pos, typename)
+}
+
 func init() {
 	{
 		f := func() reflect.Value {
@@ -149,5 +209,6 @@ func init() {
 var (
 	_ root.Object        = (*Formula)(nil)
 	_ root.Named         = (*Formula)(nil)
+	_ rbytes.Marshaler   = (*Formula)(nil)
 	_ rbytes.Unmarshaler = (*Formula)(nil)
 )

groot/rhist/func1.go

@@ -77,6 +77,55 @@ func (f *F1) Title() string {
 	return f.named.Title()
 }
 
+// MarshalROOT implements rbytes.Marshaler
+func (f *F1) MarshalROOT(w *rbytes.WBuffer) (int, error) {
+	if w.Err() != nil {
+		return 0, w.Err()
+	}
+
+	pos := w.WriteVersion(f.RVersion())
+	for _, v := range []rbytes.Marshaler{
+		&f.named, &f.attline, &f.attfill, &f.attmark,
+	} {
+		n, err := v.MarshalROOT(w)
+		if err != nil {
+			return n, err
+		}
+	}
+
+	w.WriteF64(f.xmin)
+	w.WriteF64(f.xmax)
+	w.WriteI32(f.npar)
+	w.WriteI32(f.ndim)
+	w.WriteI32(f.npx)
+	w.WriteI32(f.typ)
+	w.WriteI32(f.npfits)
+	w.WriteI32(f.ndf)
+	w.WriteF64(f.chi2)
+	w.WriteF64(f.fmin)
+	w.WriteF64(f.fmax)
+
+	w.WriteStdVectorF64(f.parErrs)
+	w.WriteStdVectorF64(f.parMin)
+	w.WriteStdVectorF64(f.parMax)
+	w.WriteStdVectorF64(f.save)
+
+	w.WriteBool(f.normalized)
+	w.WriteF64(f.normIntegral)
+
+	if err := w.WriteObjectAny(f.formula); err != nil {
+		return 0, err
+	}
+	if err := w.WriteObjectAny(f.params); err != nil {
+		return 0, err
+	}
+	if err := w.WriteObjectAny(f.compos); err != nil {
+		return 0, err
+	}
+
+	return w.SetByteCount(pos, f.Class())
+}
+
 func (f *F1) UnmarshalROOT(r *rbytes.RBuffer) error {
 	if r.Err() != nil {
 		return r.Err()
@@ -467,6 +516,7 @@ func init() {
 var (
 	_ root.Object        = (*F1)(nil)
 	_ root.Named         = (*F1)(nil)
+	_ rbytes.Marshaler   = (*F1)(nil)
 	_ rbytes.Unmarshaler = (*F1)(nil)
 
 	_ root.Object        = (*F1Parameters)(nil)