From c23f8cc97d7f06f5050c4a2c2aa41531e905e9f6 Mon Sep 17 00:00:00 2001 From: Sebastien Binet Date: Fri, 11 Sep 2020 16:08:55 +0200 Subject: [PATCH] groot/rcont: implement TRefTable --- groot/gen.rboot.go | 2 +- groot/rcont/objarray.go | 1 + groot/rcont/reftable.go | 137 ++++++++++++++++++++++++++ groot/rcont/rw_test.go | 54 ++++++++++ groot/rdict/cxx_root_streamers_gen.go | 134 ++++++++++++------------- groot/rvers/versions_gen.go | 2 +- 6 files changed, 261 insertions(+), 69 deletions(-) create mode 100644 groot/rcont/reftable.go diff --git a/groot/gen.rboot.go b/groot/gen.rboot.go index ab09ef2cb..e178296f5 100644 --- a/groot/gen.rboot.go +++ b/groot/gen.rboot.go @@ -45,6 +45,7 @@ var ( "TMap", "TObjArray", "TRefArray", + "TRefTable", "TSeqCollection", // rdict @@ -95,7 +96,6 @@ var ( "TLeafF16", "TLeafD32", "TLeafC", "TNtuple", - "TRefTable", "TTree", } ) diff --git a/groot/rcont/objarray.go b/groot/rcont/objarray.go index 0e2299d7b..e72ca9c8d 100644 --- a/groot/rcont/objarray.go +++ b/groot/rcont/objarray.go @@ -24,6 +24,7 @@ type ObjArray struct { func NewObjArray() *ObjArray { return &ObjArray{ + obj: *rbase.NewObject(), objs: make([]root.Object, 0), } } diff --git a/groot/rcont/reftable.go b/groot/rcont/reftable.go new file mode 100644 index 000000000..27e342d09 --- /dev/null +++ b/groot/rcont/reftable.go @@ -0,0 +1,137 @@ +// Copyright ©2020 The go-hep Authors. All rights reserved. +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file. + +package rcont + +import ( + "fmt" + "reflect" + + "go-hep.org/x/hep/groot/rbase" + "go-hep.org/x/hep/groot/rbytes" + "go-hep.org/x/hep/groot/root" + "go-hep.org/x/hep/groot/rtypes" + "go-hep.org/x/hep/groot/rvers" +) + +type RefTable struct { + obj rbase.Object + size int32 // dummy, for backward compatibility + parents *ObjArray // array of Parent objects (eg TTree branch) holding the referenced objects + owner root.Object // Object owning this TRefTable + guids []string // UUIDs of TProcessIDs used in fParentIDs +} + +func NewRefTable(owner root.Object) *RefTable { + return &RefTable{ + obj: *rbase.NewObject(), + owner: owner, + } +} + +func (*RefTable) RVersion() int16 { + return rvers.RefTable +} + +func (*RefTable) Class() string { + return "TRefTable" +} + +func (tbl *RefTable) UID() uint32 { + return tbl.obj.UID() +} + +func (tbl *RefTable) At(i int) root.Object { + panic("not implemented") +} + +func (tbl *RefTable) UIDs() []string { + return tbl.guids +} + +func (tbl *RefTable) MarshalROOT(w *rbytes.WBuffer) (int, error) { + if w.Err() != nil { + return 0, w.Err() + } + + pos := w.WriteVersion(tbl.RVersion()) + if _, err := tbl.obj.MarshalROOT(w); err != nil { + return 0, err + } + + w.WriteI32(tbl.size) + { + var obj root.Object + if tbl.parents != nil { + obj = tbl.parents + } + if err := w.WriteObjectAny(obj); err != nil { + return 0, err + } + } + { + var obj root.Object + if tbl.owner != nil { + obj = tbl.owner + } + if err := w.WriteObjectAny(obj); err != nil { + return 0, err + } + } + w.WriteStdVectorStrs(tbl.guids) + + return w.SetByteCount(pos, tbl.Class()) +} + +func (tbl *RefTable) UnmarshalROOT(r *rbytes.RBuffer) error { + if r.Err() != nil { + return r.Err() + } + + beg := r.Pos() + + vers, pos, bcnt := r.ReadVersion(tbl.Class()) + + if vers < 3 { + return fmt.Errorf("rcont: TRefTable version too old (%d < 3)", vers) + } + + if err := tbl.obj.UnmarshalROOT(r); err != nil { + return err + } + + tbl.size = r.ReadI32() + { + obj := r.ReadObjectAny() + tbl.parents = nil + if obj != nil { + tbl.parents = obj.(*ObjArray) + } + } + { + obj := r.ReadObjectAny() + tbl.owner = nil + if obj != nil { + tbl.owner = obj + } + } + r.ReadStdVectorStrs(&tbl.guids) + + r.CheckByteCount(pos, bcnt, beg, tbl.Class()) + return r.Err() +} + +func init() { + f := func() reflect.Value { + o := NewRefTable(nil) + return reflect.ValueOf(o) + } + rtypes.Factory.Add("TRefTable", f) +} + +var ( + _ root.Object = (*RefTable)(nil) + _ rbytes.Marshaler = (*RefTable)(nil) + _ rbytes.Unmarshaler = (*RefTable)(nil) +) diff --git a/groot/rcont/rw_test.go b/groot/rcont/rw_test.go index bb52dc518..b5560f9bd 100644 --- a/groot/rcont/rw_test.go +++ b/groot/rcont/rw_test.go @@ -87,6 +87,60 @@ func TestWRBuffer(t *testing.T) { last: 3, }, }, + { + name: "TRefTable", + want: &RefTable{ + obj: rbase.Object{ID: 0x0, Bits: 0x3000000}, + size: 42, + guids: []string{"1", "2", "3ec87674-3aa2-11e9-bb02-0301a8c0beef"}, + }, + }, + { + name: "TRefTable-owner", + want: &RefTable{ + obj: rbase.Object{ID: 0x0, Bits: 0x3000000}, + size: 42, + owner: rbase.NewNamed("n1", "t1"), + guids: []string{"1", "2", "3ec87674-3aa2-11e9-bb02-0301a8c0beef"}, + }, + }, + { + name: "TRefTable-parents", + want: &RefTable{ + obj: rbase.Object{ID: 0x0, Bits: 0x3000000}, + size: 42, + parents: &ObjArray{ + obj: rbase.Object{ID: 0x0, Bits: 0x3000000}, + name: "my-objs", + objs: []root.Object{ + rbase.NewNamed("n0", "t0"), + rbase.NewNamed("n1", "t1"), + rbase.NewNamed("n2", "t2"), + }, + last: 2, + }, + guids: []string{"1", "2", "3ec87674-3aa2-11e9-bb02-0301a8c0beef"}, + }, + }, + { + name: "TRefTable-full", + want: &RefTable{ + obj: rbase.Object{ID: 0x0, Bits: 0x3000000}, + size: 42, + owner: rbase.NewNamed("n1", "t1"), + parents: &ObjArray{ + obj: rbase.Object{ID: 0x0, Bits: 0x3000000}, + name: "my-objs", + objs: []root.Object{ + rbase.NewNamed("n0", "t0"), + rbase.NewNamed("n1", "t1"), + rbase.NewNamed("n2", "t2"), + }, + last: 2, + }, + guids: []string{"1", "2", "3ec87674-3aa2-11e9-bb02-0301a8c0beef"}, + }, + }, { name: "TMap", want: &Map{ diff --git a/groot/rdict/cxx_root_streamers_gen.go b/groot/rdict/cxx_root_streamers_gen.go index 1efca7626..35e021ad5 100644 --- a/groot/rdict/cxx_root_streamers_gen.go +++ b/groot/rdict/cxx_root_streamers_gen.go @@ -1004,6 +1004,73 @@ func init() { Factor: 0.000000, }.New()}, })) + StreamerInfos.Add(NewCxxStreamerInfo("TRefTable", 3, 0x8c895b85, []rbytes.StreamerElement{ + NewStreamerBase(Element{ + Name: *rbase.NewNamed("TObject", "Basic ROOT object"), + Type: rmeta.Base, + Size: 0, + ArrLen: 0, + ArrDim: 0, + MaxIdx: [5]int32{0, -1877229523, 0, 0, 0}, + Offset: 0, + EName: "BASE", + XMin: 0.000000, + XMax: 0.000000, + Factor: 0.000000, + }.New(), 1), + &StreamerBasicType{StreamerElement: Element{ + Name: *rbase.NewNamed("fSize", "dummy for backward compatibility"), + Type: rmeta.Int, + Size: 4, + ArrLen: 0, + ArrDim: 0, + MaxIdx: [5]int32{0, 0, 0, 0, 0}, + Offset: 0, + EName: "int", + XMin: 0.000000, + XMax: 0.000000, + Factor: 0.000000, + }.New()}, + &StreamerObjectPointer{StreamerElement: Element{ + Name: *rbase.NewNamed("fParents", "array of Parent objects (eg TTree branch) holding the referenced objects"), + Type: rmeta.ObjectP, + Size: 8, + ArrLen: 0, + ArrDim: 0, + MaxIdx: [5]int32{0, 0, 0, 0, 0}, + Offset: 0, + EName: "TObjArray*", + XMin: 0.000000, + XMax: 0.000000, + Factor: 0.000000, + }.New()}, + &StreamerObjectPointer{StreamerElement: Element{ + Name: *rbase.NewNamed("fOwner", "Object owning this TRefTable"), + Type: rmeta.ObjectP, + Size: 8, + ArrLen: 0, + ArrDim: 0, + MaxIdx: [5]int32{0, 0, 0, 0, 0}, + Offset: 0, + EName: "TObject*", + XMin: 0.000000, + XMax: 0.000000, + Factor: 0.000000, + }.New()}, + NewCxxStreamerSTL(Element{ + Name: *rbase.NewNamed("fProcessGUIDs", "UUIDs of TProcessIDs used in fParentIDs"), + Type: rmeta.Streamer, + Size: 24, + ArrLen: 0, + ArrDim: 0, + MaxIdx: [5]int32{0, 0, 0, 0, 0}, + Offset: 0, + EName: "vector", + XMin: 0.000000, + XMax: 0.000000, + Factor: 0.000000, + }.New(), 1, 61), + })) StreamerInfos.Add(NewCxxStreamerInfo("TSeqCollection", 0, 0xfc6c3bc6, []rbytes.StreamerElement{ NewStreamerBase(Element{ Name: *rbase.NewNamed("TCollection", "Collection abstract base class"), @@ -5130,73 +5197,6 @@ func init() { Factor: 0.000000, }.New()}, })) - StreamerInfos.Add(NewCxxStreamerInfo("TRefTable", 3, 0x8c895b85, []rbytes.StreamerElement{ - NewStreamerBase(Element{ - Name: *rbase.NewNamed("TObject", "Basic ROOT object"), - Type: rmeta.Base, - Size: 0, - ArrLen: 0, - ArrDim: 0, - MaxIdx: [5]int32{0, -1877229523, 0, 0, 0}, - Offset: 0, - EName: "BASE", - XMin: 0.000000, - XMax: 0.000000, - Factor: 0.000000, - }.New(), 1), - &StreamerBasicType{StreamerElement: Element{ - Name: *rbase.NewNamed("fSize", "dummy for backward compatibility"), - Type: rmeta.Int, - Size: 4, - ArrLen: 0, - ArrDim: 0, - MaxIdx: [5]int32{0, 0, 0, 0, 0}, - Offset: 0, - EName: "int", - XMin: 0.000000, - XMax: 0.000000, - Factor: 0.000000, - }.New()}, - &StreamerObjectPointer{StreamerElement: Element{ - Name: *rbase.NewNamed("fParents", "array of Parent objects (eg TTree branch) holding the referenced objects"), - Type: rmeta.ObjectP, - Size: 8, - ArrLen: 0, - ArrDim: 0, - MaxIdx: [5]int32{0, 0, 0, 0, 0}, - Offset: 0, - EName: "TObjArray*", - XMin: 0.000000, - XMax: 0.000000, - Factor: 0.000000, - }.New()}, - &StreamerObjectPointer{StreamerElement: Element{ - Name: *rbase.NewNamed("fOwner", "Object owning this TRefTable"), - Type: rmeta.ObjectP, - Size: 8, - ArrLen: 0, - ArrDim: 0, - MaxIdx: [5]int32{0, 0, 0, 0, 0}, - Offset: 0, - EName: "TObject*", - XMin: 0.000000, - XMax: 0.000000, - Factor: 0.000000, - }.New()}, - NewCxxStreamerSTL(Element{ - Name: *rbase.NewNamed("fProcessGUIDs", "UUIDs of TProcessIDs used in fParentIDs"), - Type: rmeta.Streamer, - Size: 24, - ArrLen: 0, - ArrDim: 0, - MaxIdx: [5]int32{0, 0, 0, 0, 0}, - Offset: 0, - EName: "vector", - XMin: 0.000000, - XMax: 0.000000, - Factor: 0.000000, - }.New(), 1, 61), - })) StreamerInfos.Add(NewCxxStreamerInfo("TTree", 20, 0x7264e07f, []rbytes.StreamerElement{ NewStreamerBase(Element{ Name: *rbase.NewNamed("TNamed", "The basis for a named object (name, title)"), diff --git a/groot/rvers/versions_gen.go b/groot/rvers/versions_gen.go index 4f34c6aeb..d9fad7416 100644 --- a/groot/rvers/versions_gen.go +++ b/groot/rvers/versions_gen.go @@ -39,6 +39,7 @@ const ( Map = 3 // ROOT version for TMap ObjArray = 3 // ROOT version for TObjArray RefArray = 1 // ROOT version for TRefArray + RefTable = 3 // ROOT version for TRefTable SeqCollection = 0 // ROOT version for TSeqCollection StreamerInfo = 9 // ROOT version for TStreamerInfo StreamerElement = 4 // ROOT version for TStreamerElement @@ -100,6 +101,5 @@ const ( LeafD32 = 1 // ROOT version for TLeafD32 LeafC = 1 // ROOT version for TLeafC Ntuple = 2 // ROOT version for TNtuple - RefTable = 3 // ROOT version for TRefTable Tree = 20 // ROOT version for TTree )