Anonymous avatar Anonymous committed 9ae748d

implemented more streamers

Comments (0)

Files changed (6)

pkg/groot/base_leaf.go

 		base.leaf_count = obj.(ibaseLeaf).toBaseLeaf()
 	}
 
-	b.check_byte_count(pos, bcnt, spos, "TLeaf")
 	if base.length == 0 {
 		//FIXME: ??? really ??? (check with Guy)
 		base.length = 1
 	}
+
+	b.check_byte_count(pos, bcnt, spos, "TLeaf")
 	return
 }
 

pkg/groot/buffer.go

 		return nil
 	}
 	bb.buf.Next(b.Pos())
-	//bb.read_nbytes(b.Pos())
 	return bb
 }
 
 }
 
 func (b *Buffer) read_nbytes(nbytes int) (o []byte) {
-	// o = make([]byte, nbytes)
-	// err := binary.Read(b.buf, b.order, o)
-	// if err != nil {
-	// 	panic(err)
-	// }
-	// return
 	o = make([]byte, nbytes)
 	_, err := b.buf.Read(o)
 	if err != nil {
 	return
 }
 
+func (b *Buffer) read_bool() (o bool) {
+	v := b.ntobyte()
+	if v == 0 {
+		o = false
+	} else {
+		o = true
+	}
+	return
+}
+
 func (b *Buffer) read_array_F() (o []float32) {
 	n := int(b.ntou4())
 	o = make([]float32, n)
 	
 	if diff < lenbuf {
 		err := fmt.Errorf(
-			"buffer.check_count: object of class [%s] read too few bytes (%d missing)",
-			cls, lenbuf-diff)
-		printf("**error** %s\n", err.Error())
-		//panic(err)
+			"buffer.check_count: object of class [%s] read too few bytes (%d missing. expected %d, got %d)",
+			cls, lenbuf-diff, lenbuf, diff)
+		panic(err)
 
-		b.read_nbytes(int(lenbuf-diff))
+		//printf("**error** %s\n", err.Error())
+		//b.read_nbytes(int(lenbuf-diff))
 		return true
 	}
 	if diff > lenbuf {
 		err := fmt.Errorf(
-			"buffer.check_count: object of class [%s] read too many bytes (%d in excess)",
-			cls, diff-lenbuf)
-		printf("**error** %s\n", err.Error())
+			"buffer.check_count: object of class [%s] read too many bytes (%d in excess. expected %d, got %d)",
+			cls, diff-lenbuf, lenbuf, diff)
 
-		//panic(err)
-		b.rewind_nbytes(int(diff -lenbuf))
+		panic(err)
+
+		//printf("**error** %s\n", err.Error())
+		//b.rewind_nbytes(int(diff -lenbuf))
 		return true
 	}
 	return false

pkg/groot/leaf.go

 
 type LeafB struct {
 	base baseLeaf
-	min int32
-	max int32
+	min byte
+	max byte
 	data []byte
 }
 
 	if err != nil {
 		return err
 	}
-	leaf.min = b.ntoi4()
-	leaf.max = b.ntoi4()
+	leaf.min = b.ntobyte()
+	leaf.max = b.ntobyte()
 	leaf.data = make([]byte, int(leaf.base.length))
 	printf("leafI min=%v max=%v len=%d\n", leaf.min, leaf.max, len(leaf.data))
 	b.check_byte_count(pos,bcnt,spos, "LeafB")
 
 type LeafS struct {
 	base baseLeaf
-	min int32
-	max int32
-	data []int8
+	min int16
+	max int16
+	data []int16
 }
 
 func (leaf *LeafS) toBaseLeaf() *baseLeaf {
 	if err != nil {
 		return err
 	}
-	leaf.min = b.ntoi4()
-	leaf.max = b.ntoi4()
-	leaf.data = make([]int8, int(leaf.base.length))
+	leaf.min = b.ntoi2()
+	leaf.max = b.ntoi2()
+	leaf.data = make([]int16, int(leaf.base.length))
 	printf("leafI min=%v max=%v len=%d\n", leaf.min, leaf.max, len(leaf.data))
 	b.check_byte_count(pos,bcnt,spos, "LeafS")
 	return
 
 type LeafL struct {
 	base baseLeaf
-	min int32
-	max int32
+	min int64
+	max int64
 	data []int64
 }
 
 	if err != nil {
 		return err
 	}
-	leaf.min = b.ntoi4()
-	leaf.max = b.ntoi4()
+	leaf.min = b.ntoi8()
+	leaf.max = b.ntoi8()
 	leaf.data = make([]int64, int(leaf.base.length))
 	printf("leafL min=%v max=%v len=%d\n", leaf.min, leaf.max, len(leaf.data))
 	b.check_byte_count(pos,bcnt,spos, "LeafL")
 
 type LeafF struct {
 	base baseLeaf
-	min int32
-	max int32
+	min float32
+	max float32
 	data []float32
 }
 
 	if err != nil {
 		return err
 	}
-	leaf.min = b.ntoi4()
-	leaf.max = b.ntoi4()
+	leaf.min = b.ntof()
+	leaf.max = b.ntof()
 	leaf.data = make([]float32, int(leaf.base.length))
 	printf("leafF min=%v max=%v len=%d\n", leaf.min, leaf.max, len(leaf.data))
 	b.check_byte_count(pos,bcnt,spos, "LeafF")
 
 type LeafD struct {
 	base baseLeaf
-	min int32
-	max int32
+	min float64
+	max float64
 	data []float64
 }
 
 	if err != nil {
 		return err
 	}
-	leaf.min = b.ntoi4()
-	leaf.max = b.ntoi4()
+	leaf.min = b.ntod()
+	leaf.max = b.ntod()
 	leaf.data = make([]float64, int(leaf.base.length))
 	printf("leafD min=%v max=%v len=%d\n", leaf.min, leaf.max, len(leaf.data))
 	b.check_byte_count(pos,bcnt,spos, "LeafD")
 
 type LeafO struct {
 	base baseLeaf
-	min int32
-	max int32
+	min bool
+	max bool
 	data []bool
 }
 
 	if err != nil {
 		return err
 	}
-	leaf.min = b.ntoi4()
-	leaf.max = b.ntoi4()
+	leaf.min = b.read_bool()
+	leaf.max = b.read_bool()
 	leaf.data= make([]bool, int(leaf.base.length))
 	printf("leafO min=%v max=%v len=%d\n", leaf.min, leaf.max, len(leaf.data))
 	b.check_byte_count(pos,bcnt,spos, "LeafO")

pkg/groot/list.go

 package groot
 
 import (
-	//"reflect"
+	"fmt"
+	"reflect"
 )
 
-// FIXME: make List a struct ?
-
-type List []Object
+type List struct {
+	elmts []Object
+}
 
 func (lst *List) Class() string {
 	return "TList"
 }
 
 func (lst *List) ROOTDecode(b *Buffer) (err error) {
+	spos := b.Pos()
+	lst.elmts = make([]Object, 0)
 
 	vers, pos, bcnt := b.read_version()
+	printf("[list] vers=%v pos=%v bcnt=%v\n", vers, pos, bcnt)
+
+	if vers <= 3 {
+		err = fmt.Errorf("sorry, too old version of TList (%d)", vers)
+		return
+	}
 	id := b.ntou4()
 	bits := b.ntou4()
 	bits |= kIsOnHeap // by definition de-serialized object is on heap
 	if (bits & kIsReferenced) == 0 {
 		_ = b.read_nbytes(2)
 	}
+
 	name := b.read_tstring()
+	nobjs := int(b.ntoi4())
+	lst.elmts = make([]Object, 0, nobjs)
 
-	nobjs := int(b.ntoi4())
-
-	dprintf("vers=%v pos=%v bcnt=%v\n", vers, pos, bcnt)
-	dprintf("id=%v bits=%v\n", id, bits)
-	dprintf("name=%v nobjs=%v\n", name, nobjs)
+	printf("id=%v bits=%v\n", id, bits)
+	printf("name=%v nobjs=%v\n", name, nobjs)
 
 	for i := 0; i < nobjs; i++ {
-		dprintf("---> %v/%v\n", i+1, nobjs)
+		printf("---> %v/%v\n", i+1, nobjs)
 		obj := b.read_object()
+		opt := b.read_tstring()
+
+		// obj can be nil if the class had a custom streamer and we do not
+		// have the shared library nor a streamerinfo.
 		if obj != nil {
+			lst.elmts = append(lst.elmts, obj)
+		}
+		printf("---> %v/%v == opt='%s' obj=%v\n", i+1, nobjs, opt, obj)
+	}
 
-		}
-	}
+	b.check_byte_count(pos, bcnt, spos, "TList")
 	return err
 }
 
 func init() {
 
 	//FIXME...
-	// new_lst := func() reflect.Value {
-	// 	o := make(List, 0)
-	// 	return reflect.ValueOf(&o)
-	// }
-	//Factory.db["TList"] = new_lst
-	//Factory.db["*groot.List"] = new_lst
+	 new_lst := func() reflect.Value {
+	 	o := List{}
+	 	return reflect.ValueOf(&o)
+	 }
+	Factory.db["TList"] = new_lst
+	Factory.db["*groot.List"] = new_lst
 }
 
 // check interfaces

pkg/groot/reader.go

 func (f *File) read_streamer_infos() (err error) {
 
 	//FIXME:
-	return
-
-	lst := make(List, 0)
+	//return
+	printf(":: read_streamer_infos...\n")
+	lst := List{}
 	printf("lst: %v\n", lst)
 
 	var buf []byte
 		if ok {
 			lst = obj
 		}
+
+		for i,v := range lst.elmts {
+			printf("lst[%d]= %s %s\n", i, v.Name(), v.Title())
+		}
 	}
 	printf("buf: %v\n", len(buf))
 
+	printf(":: read_streamer_infos... [done]\n")
 	return err
 }
 

pkg/groot/streamerinfo.go

 package groot
 
 import (
+	"fmt"
 	"reflect"
 )
 
 	title     string
 	checksum  uint32
 	classvers uint32
-	elmts     []Object
+	elmts     []StreamerElement
 }
 
 func (si *StreamerInfo) Class() string {
 
 func (si *StreamerInfo) ROOTDecode(b *Buffer) (err error) {
 
+	spos := b.Pos()
+
 	vers, pos, bcnt := b.read_version()
-	dprintf("vers=%v pos=%v bcnt=%v\n", vers, pos, bcnt)
+	printf("[streamerinfo] vers=%v pos=%v bcnt=%v\n", vers, pos, bcnt)
 	si.name, si.title = b.read_tnamed()
-	dprintf("name='%v' title='%v'\n", si.name, si.title)
+	printf("name='%v' title='%v'\n", si.name, si.title)
+	if vers <= 1 {
+		err = fmt.Errorf("too old version for StreamerInfo (v=%d)", vers)
+		return
+	}
 	si.checksum = b.ntou4()
 	si.classvers = b.ntou4()
-	si.elmts = b.read_elements()
+	elmts := b.read_elements()
+	si.elmts = make([]StreamerElement, 0, len(elmts))
+	for _, v := range elmts {
+		switch vv := v.(type) {
+		case StreamerElement:
+			si.elmts = append(si.elmts, vv)
+		default:
+			si.elmts = append(si.elmts, nil)
+		}
+	}
 
+	b.check_byte_count(pos, bcnt, spos, "TStreamerInfo")
 	return
 }
 
 	return
 }
 
-func init() {
-	f := func() reflect.Value {
-		o := &StreamerInfo{}
-		return reflect.ValueOf(o)
-	}
-	Factory.db["TStreamerInfo"] = f
-	Factory.db["*groot.StreamerInfo"] = f
+type StreamerElement interface {
+	Name() string
+	Title() string
+	Type() int       // element type
+	Size() int       // sizeof element
+	ArrLen() int     // cumulative size of all array dims
+	ArrDim() int     // number of array dimensions
+	MaxIdx() []int32 // maximum array index for array dimension "dim"
+	Offset() int     // element offset in class
+	//IsNewType() int // new element type when reading
+	TypeName() string // data type name of data member
 }
 
-// check interfaces
+type seBase struct {
+	name  string
+	title string
+
+	etype    int    // element type
+	esize    int    // sizeof element
+	arrlen   int    // cumulative size of all array dims
+	arrdim   int    // number of array dimensions
+	maxidx   []int32 // maximum array index for array dimension "dim"
+	offset   int    // element offset in class
+	newtype  int    // new element type when reading
+	typename string // data type name of data member
+}
+
+func (se *seBase) Class() string {
+	return "TStreamerElement"
+}
+
+func (se *seBase) Name() string {
+	return se.name
+}
+
+func (se *seBase) Title() string {
+	return se.title
+}
+
+func (se *seBase) Type() int {
+	return se.etype
+}
+
+func (se *seBase) Size() int {
+	return se.esize
+}
+
+func (se *seBase) ArrLen() int {
+	return se.arrlen
+}
+
+func (se *seBase) ArrDim() int {
+	return se.arrdim
+}
+
+func (se *seBase) MaxIdx() []int32 {
+	return se.maxidx
+}
+
+func (se *seBase) Offset() int {
+	return se.offset
+}
+
+func (se *seBase) TypeName() string {
+	return se.typename
+}
+
+func (se *seBase) ROOTDecode(b *Buffer) (err error) {
+	spos := b.Pos()
+
+	vers, pos, bcnt := b.read_version()
+	printf("[streamerelmt] vers=%v pos=%v bcnt=%v\n", vers, pos, bcnt)
+	if vers < 2 {
+		panic("groot.StreamerElement.ROOTDecode: version<2 is not supported")
+	}
+	se.name, se.title = b.read_tnamed()
+	se.etype = int(b.ntoi4())
+	se.esize = int(b.ntoi4())
+	se.arrlen = int(b.ntoi4())
+	se.arrdim = int(b.ntoi4())
+	se.maxidx = b.read_fast_array_I(5) // FIXME: magic constant
+	se.typename = b.read_tstring()
+
+	b.check_byte_count(pos, bcnt, spos, "TStreamerElement")
+	return
+}
+
+func (se *seBase) ROOTEncode(b *Buffer) (err error) {
+	panic("not implemented")
+	return
+}
+
+// StreamerBase is a streamer element for a base class
+type StreamerBase struct {
+	seBase
+	version int // version number of the base class
+}
+
+func (se *StreamerBase) Class() string {
+	return "TStreamerBase"
+}
+
+func (se *StreamerBase) ROOTDecode(b *Buffer) (err error) {
+	spos := b.Pos()
+
+	vers, pos, bcnt := b.read_version()
+	printf("[streamerbase] vers=%v pos=%v bcnt=%v\n", vers, pos, bcnt)
+	if vers < 2 {
+		panic("groot.StreamerBase.ROOTDecode: version<2 is not supported")
+	}
+	err = se.seBase.ROOTDecode(b)
+	if err != nil {
+		return err
+	}
+	se.version = int(b.ntoi4())
+	b.check_byte_count(pos,bcnt, spos, "TStreamerBase")
+	return
+}
+
+func (se *StreamerBase) ROOTEncode(b *Buffer) (err error) {
+	panic("not implemented")
+	return
+}
+
+// StreamerBasicType is a streamer element for a builtin type
+type StreamerBasicType struct {
+	seBase
+}
+
+func (se *StreamerBasicType) Class() string {
+	return "TStreamerBasicType"
+}
+
+func (se *StreamerBasicType) ROOTDecode(b *Buffer) (err error) {
+	spos := b.Pos()
+
+	vers, pos, bcnt := b.read_version()
+	printf("[streamerbasictype] vers=%v pos=%v bcnt=%v\n", vers, pos, bcnt)
+	if vers < 2 {
+		panic("groot.StreamerBasicType.ROOTDecode: version<2 is not supported")
+	}
+	err = se.seBase.ROOTDecode(b)
+	if err != nil {
+		return err
+	}
+	b.check_byte_count(pos, bcnt, spos, "TStreamerBasicType")
+	return
+}
+
+func (se *StreamerBasicType) ROOTEncode(b *Buffer) (err error) {
+	panic("not implemented")
+	return
+}
+
+// StreamerBasicPointer is a streamer element for a pointer to a builtin type
+type StreamerBasicPointer struct {
+	seBase
+	countvers int // version number of the class with the counter
+	countname string // name of the data member holding the array count
+	countclass string // name of the class with the counter
+}
+
+func (se *StreamerBasicPointer) Class() string {
+	return "TStreamerBasicPointer"
+}
+
+func (se *StreamerBasicPointer) ROOTDecode(b *Buffer) (err error) {
+	spos := b.Pos()
+
+	vers, pos, bcnt := b.read_version()
+	printf("[streamerbasicptr] vers=%v pos=%v bcnt=%v\n", vers, pos, bcnt)
+	if vers < 2 {
+		panic("groot.StreamerBasicPointer.ROOTDecode: version<2 is not supported")
+	}
+	err = se.seBase.ROOTDecode(b)
+	if err != nil {
+		return err
+	}
+
+	se.countvers = int(b.ntoi4())
+	se.countname = b.read_tstring()
+	se.countclass = b.read_tstring()
+	printf("[streamerbasicptr] cntvers=%v name=%v cls=%v\n",
+		se.countvers, se.countname, se.countclass)
+
+	b.check_byte_count(pos, bcnt, spos, "TStreamerBasicPointer")
+	return
+}
+
+func (se *StreamerBasicPointer) ROOTEncode(b *Buffer) (err error) {
+	panic("not implemented")
+	return
+}
+
+// StreamerString is a streamer element for a string
+type StreamerString struct {
+	seBase
+}
+
+func (se *StreamerString) Class() string {
+	return "TStreamerString"
+}
+
+func (se *StreamerString) ROOTDecode(b *Buffer) (err error) {
+	spos := b.Pos()
+
+	vers, pos, bcnt := b.read_version()
+	printf("[streamerstring] vers=%v pos=%v bcnt=%v\n", vers, pos, bcnt)
+	if vers < 2 {
+		panic("groot.StreamerString.ROOTDecode: version<2 is not supported")
+	}
+	err = se.seBase.ROOTDecode(b)
+	if err != nil {
+		return err
+	}
+	b.check_byte_count(pos,bcnt, spos, "TStreamerString")
+	return
+}
+
+func (se *StreamerString) ROOTEncode(b *Buffer) (err error) {
+	panic("not implemented")
+	return
+}
+
+// StreamerObject is a streamer element for an object
+type StreamerObject struct {
+	seBase
+}
+
+func (se *StreamerObject) Class() string {
+	return "TStreamerObject"
+}
+
+func NewStreamerObject(name, title string, offset int, typename string) *StreamerObject {
+	o := &StreamerObject{
+		seBase: seBase{
+			name:     name,
+			title:    title,
+			offset:   offset,
+			etype:    kObject,
+			typename: typename,
+		},
+	}
+	switch name {
+	case "TObject":
+		o.seBase.etype = kTObject
+	case "TNamed":
+		o.seBase.etype = kTNamed
+	}
+	return o
+}
+
+func (se *StreamerObject) ROOTDecode(b *Buffer) (err error) {
+	spos := b.Pos()
+
+	vers, pos, bcnt := b.read_version()
+	printf("[streamerobj] vers=%v pos=%v bcnt=%v\n", vers, pos, bcnt)
+	if vers < 2 {
+		panic("groot.StreamerObject.ROOTDecode: version<2 is not supported")
+	}
+	err = se.seBase.ROOTDecode(b)
+	if err != nil {
+		return err
+	}
+	b.check_byte_count(pos,bcnt, spos, "TStreamerObject")
+	return
+}
+
+func (se *StreamerObject) ROOTEncode(b *Buffer) (err error) {
+	panic("not implemented")
+	return
+}
+
+// StreamerObjectPointer is a streamer element for a pointer to an object
+type StreamerObjectPointer struct {
+	seBase
+}
+
+func (se *StreamerObjectPointer) Class() string {
+	return "TStreamerObjectPointer"
+}
+
+func (se *StreamerObjectPointer) ROOTDecode(b *Buffer) (err error) {
+	spos := b.Pos()
+
+	vers, pos, bcnt := b.read_version()
+	printf("[streamerobjptr] vers=%v pos=%v bcnt=%v\n", vers, pos, bcnt)
+	if vers < 2 {
+		panic("groot.StreamerObjectPointer.ROOTDecode: version<2 is not supported")
+	}
+	err = se.seBase.ROOTDecode(b)
+	if err != nil {
+		return err
+	}
+	b.check_byte_count(pos,bcnt, spos, "TStreamerObjectPointer")
+	return
+}
+
+func (se *StreamerObjectPointer) ROOTEncode(b *Buffer) (err error) {
+	panic("not implemented")
+	return
+}
+
+// StreamerObjectAny is a streamer element for any object
+type StreamerObjectAny struct {
+	seBase
+}
+
+func (se *StreamerObjectAny) Class() string {
+	return "TStreamerObjectAny"
+}
+
+func (se *StreamerObjectAny) ROOTDecode(b *Buffer) (err error) {
+	spos := b.Pos()
+
+	vers, pos, bcnt := b.read_version()
+	printf("[streamerobjany] vers=%v pos=%v bcnt=%v\n", vers, pos, bcnt)
+	if vers < 2 {
+		panic("groot.StreamerObjectAny.ROOTDecode: version<2 is not supported")
+	}
+	err = se.seBase.ROOTDecode(b)
+	if err != nil {
+		return err
+	}
+	b.check_byte_count(pos,bcnt, spos, "TStreamerObjectAny")
+	return
+}
+
+func (se *StreamerObjectAny) ROOTEncode(b *Buffer) (err error) {
+	panic("not implemented")
+	return
+}
+
+// StreamerSTL is a streamer element for STL containers
+type StreamerSTL struct {
+	seBase
+	stltype int // type of STL container
+	ctype int // type of contained object
+}
+
+func (se *StreamerSTL) Class() string {
+	return "TStreamerSTL"
+}
+
+func (se *StreamerSTL) ROOTDecode(b *Buffer) (err error) {
+	spos := b.Pos()
+
+	vers, pos, bcnt := b.read_version()
+ 	printf("[streamerstl] vers=%v pos=%v bcnt=%v\n", vers, pos, bcnt)
+	if vers < 2 {
+		panic("groot.StreamerSTL.ROOTDecode: version<2 is not supported")
+	}
+	err = se.seBase.ROOTDecode(b)
+	if err != nil {
+		return err
+	}
+	se.stltype = int(b.ntoi4())
+	se.ctype = int(b.ntoi4())
+ 	printf("[streamerstl] name='%v' title='%s' type=%d stl=%v ctype=%v\n", 
+		se.Name(), se.Title(), se.Type(), se.stltype, se.ctype)
+	b.check_byte_count(pos,bcnt, spos, "TStreamerSTL")
+	return
+}
+
+func (se *StreamerSTL) ROOTEncode(b *Buffer) (err error) {
+	panic("not implemented")
+	return
+}
+
+// StreamerSTLstring is a streamer element for std::string
+type StreamerSTLstring struct {
+	StreamerSTL
+}
+
+func (se *StreamerSTLstring) Class() string {
+	return "TStreamerSTLstring"
+}
+
+func (se *StreamerSTLstring) ROOTDecode(b *Buffer) (err error) {
+	spos := b.Pos()
+
+	vers, pos, bcnt := b.read_version()
+ 	printf("[streamerstlstr] vers=%v pos=%v bcnt=%v\n", vers, pos, bcnt)
+	if vers < 2 {
+		panic("groot.StreamerSTLstring.ROOTDecode: version<2 is not supported")
+	}
+	err = se.StreamerSTL.ROOTDecode(b)
+	if err != nil {
+		return err
+	}
+ 	printf("[streamerstlstr] name='%v' title='%s' type=%d stl=%v ctype=%v\n", 
+		se.Name(), se.Title(), se.Type(), se.stltype, se.ctype)
+	b.check_byte_count(pos,bcnt, spos, "TStreamerSTLstring")
+	return
+}
+
+func (se *StreamerSTLstring) ROOTEncode(b *Buffer) (err error) {
+	panic("not implemented")
+	return
+}
+
+// register factories ---------------------------------------------------------
+
+func init() {
+
+	{
+		f := func() reflect.Value {
+			o := &StreamerInfo{}
+			return reflect.ValueOf(o)
+		}
+		Factory.db["TStreamerInfo"] = f
+		Factory.db["*groot.StreamerInfo"] = f
+	}
+
+	{
+		f := func() reflect.Value {
+			o := &seBase{}
+			return reflect.ValueOf(o)
+		}
+		Factory.db["TStreamerElement"] = f
+		Factory.db["groot.StreamerElement"] = f
+	}
+
+	{
+		f := func() reflect.Value {
+			o := &StreamerBase{}
+			return reflect.ValueOf(o)
+		}
+		Factory.db["TStreamerBase"] = f
+		Factory.db["*groot.StreamerBase"] = f
+	}
+
+	{
+		f := func() reflect.Value {
+			o := &StreamerBasicType{}
+			return reflect.ValueOf(o)
+		}
+		Factory.db["TStreamerBasicType"] = f
+		Factory.db["*groot.StreamerBasicType"] = f
+	}
+
+	{
+		f := func() reflect.Value {
+			o := &StreamerBasicPointer{}
+			return reflect.ValueOf(o)
+		}
+		Factory.db["TStreamerBasicPointer"] = f
+		Factory.db["*groot.StreamerBasicPointer"] = f
+	}
+
+	{
+		f := func() reflect.Value {
+			o := &StreamerString{}
+			return reflect.ValueOf(o)
+		}
+		Factory.db["TStreamerString"] = f
+		Factory.db["*groot.StreamerString"] = f
+	}
+
+	{
+		f := func() reflect.Value {
+			o := &StreamerObject{}
+			return reflect.ValueOf(o)
+		}
+		Factory.db["TStreamerObject"] = f
+		Factory.db["*groot.StreamerObject"] = f
+	}
+
+	{
+		f := func() reflect.Value {
+			o := &StreamerObjectPointer{}
+			return reflect.ValueOf(o)
+		}
+		Factory.db["TStreamerObjectPointer"] = f
+		Factory.db["*groot.StreamerObjectPointer"] = f
+	}
+
+	{
+		f := func() reflect.Value {
+			o := &StreamerObjectAny{}
+			return reflect.ValueOf(o)
+		}
+		Factory.db["TStreamerObjectAny"] = f
+		Factory.db["*groot.StreamerObjectAny"] = f
+	}
+
+	{
+		f := func() reflect.Value {
+			o := &StreamerSTL{}
+			return reflect.ValueOf(o)
+		}
+		Factory.db["TStreamerSTL"] = f
+		Factory.db["*groot.StreamerSTL"] = f
+	}
+
+	{
+		f := func() reflect.Value {
+			o := &StreamerSTLstring{}
+			return reflect.ValueOf(o)
+		}
+		Factory.db["TStreamerSTLstring"] = f
+		Factory.db["*groot.StreamerSTLstring"] = f
+	}
+}
+
+// check interfaces -----------------------------------------------------------
 var _ Object = (*StreamerInfo)(nil)
 var _ ROOTStreamer = (*StreamerInfo)(nil)
 
+var _ Object = (*seBase)(nil)
+var _ ROOTStreamer = (*seBase)(nil)
+var _ StreamerElement = (*seBase)(nil)
+
+var _ Object = (*StreamerBase)(nil)
+var _ ROOTStreamer = (*StreamerBase)(nil)
+var _ StreamerElement = (*StreamerBase)(nil)
+
+var _ Object = (*StreamerBasicType)(nil)
+var _ ROOTStreamer = (*StreamerBasicType)(nil)
+var _ StreamerElement = (*StreamerBasicType)(nil)
+
+var _ Object = (*StreamerBasicPointer)(nil)
+var _ ROOTStreamer = (*StreamerBasicPointer)(nil)
+var _ StreamerElement = (*StreamerBasicPointer)(nil)
+
+var _ Object = (*StreamerString)(nil)
+var _ ROOTStreamer = (*StreamerString)(nil)
+var _ StreamerElement = (*StreamerString)(nil)
+
+var _ Object = (*StreamerObject)(nil)
+var _ ROOTStreamer = (*StreamerObject)(nil)
+var _ StreamerElement = (*StreamerObject)(nil)
+
+var _ Object = (*StreamerObjectPointer)(nil)
+var _ ROOTStreamer = (*StreamerObjectPointer)(nil)
+var _ StreamerElement = (*StreamerObjectPointer)(nil)
+
+var _ Object = (*StreamerObjectAny)(nil)
+var _ ROOTStreamer = (*StreamerObjectAny)(nil)
+var _ StreamerElement = (*StreamerObjectAny)(nil)
+
+var _ Object = (*StreamerSTL)(nil)
+var _ ROOTStreamer = (*StreamerSTL)(nil)
+var _ StreamerElement = (*StreamerSTL)(nil)
+
+var _ Object = (*StreamerSTLstring)(nil)
+var _ ROOTStreamer = (*StreamerSTLstring)(nil)
+var _ StreamerElement = (*StreamerSTLstring)(nil)
+
 // EOF
Tip: Filter by directory path e.g. /media app.js to search for public/media/app.js.
Tip: Use camelCasing e.g. ProjME to search for ProjectModifiedEvent.java.
Tip: Filter by extension type e.g. /repo .js to search for all .js files in the /repo directory.
Tip: Separate your search with spaces e.g. /ssh pom.xml to search for src/ssh/pom.xml.
Tip: Use ↑ and ↓ arrow keys to navigate and return to view the file.
Tip: You can also navigate files with Ctrl+j (next) and Ctrl+k (previous) and view the file with Ctrl+o.
Tip: You can also navigate files with Alt+j (next) and Alt+k (previous) and view the file with Alt+o.