go-hep.org/x/hep@v0.38.1/groot/rdict/type_test.go (about)

     1  // Copyright ©2020 The go-hep Authors. All rights reserved.
     2  // Use of this source code is governed by a BSD-style
     3  // license that can be found in the LICENSE file.
     4  
     5  package rdict_test
     6  
     7  import (
     8  	"reflect"
     9  	"testing"
    10  
    11  	"go-hep.org/x/hep/groot/rbase"
    12  	"go-hep.org/x/hep/groot/rbytes"
    13  	"go-hep.org/x/hep/groot/rcont"
    14  	"go-hep.org/x/hep/groot/rdict"
    15  	"go-hep.org/x/hep/groot/rmeta"
    16  	"go-hep.org/x/hep/groot/root"
    17  	"go-hep.org/x/hep/groot/rtypes"
    18  	"go-hep.org/x/hep/groot/rvers"
    19  )
    20  
    21  func TestTypeFromSI(t *testing.T) {
    22  	rdict.StreamerInfos.Add(rdict.NewCxxStreamerInfo("TypeFromSI_Pos1", 1, 0, []rbytes.StreamerElement{
    23  		&rdict.StreamerBasicType{
    24  			StreamerElement: rdict.Element{
    25  				Name:   *rbase.NewNamed("px", ""),
    26  				Type:   rmeta.Float32,
    27  				Size:   4,
    28  				MaxIdx: [5]int32{0, 0, 0, 0, 0},
    29  				EName:  "float32",
    30  			}.New(),
    31  		},
    32  		&rdict.StreamerBasicType{
    33  			StreamerElement: rdict.Element{
    34  				Name:   *rbase.NewNamed("py", ""),
    35  				Type:   rmeta.Float64,
    36  				Size:   8,
    37  				MaxIdx: [5]int32{0, 0, 0, 0, 0},
    38  				EName:  "float64",
    39  			}.New(),
    40  		},
    41  	}))
    42  
    43  	rdict.StreamerInfos.Add(rdict.NewCxxStreamerInfo("TypeFromSI_Pos2", 1, 0, []rbytes.StreamerElement{
    44  		&rdict.StreamerBasicType{
    45  			StreamerElement: rdict.Element{
    46  				Name:   *rbase.NewNamed("px", ""),
    47  				Type:   rmeta.Float32,
    48  				Size:   4,
    49  				MaxIdx: [5]int32{0, 0, 0, 0, 0},
    50  				EName:  "float32",
    51  			}.New(),
    52  		},
    53  		&rdict.StreamerBasicType{
    54  			StreamerElement: rdict.Element{
    55  				Name:   *rbase.NewNamed("py", ""),
    56  				Type:   rmeta.Float64,
    57  				Size:   8,
    58  				MaxIdx: [5]int32{0, 0, 0, 0, 0},
    59  				EName:  "float64",
    60  			}.New(),
    61  		},
    62  	}))
    63  	type TypeFromSI_Pos2 struct {
    64  		Px float32 `groot:"px"`
    65  		Py float64 `groot:"py"`
    66  	}
    67  	rtypes.Factory.Add("TypeFromSI_Pos2", func() reflect.Value {
    68  		return reflect.ValueOf(&TypeFromSI_Pos2{})
    69  	})
    70  
    71  	for _, tc := range []struct {
    72  		name string
    73  		si   rbytes.StreamerInfo
    74  		want reflect.Type
    75  	}{
    76  		{
    77  			name: "TObject",
    78  			si: func() rbytes.StreamerInfo {
    79  				const name = "TObject"
    80  				si, ok := rdict.StreamerInfos.Get(name, -1)
    81  				if !ok {
    82  					t.Fatalf("could not load streamer for %q", name)
    83  				}
    84  				return si
    85  			}(),
    86  			want: reflect.TypeOf((*rbase.Object)(nil)).Elem(),
    87  		},
    88  		{
    89  			name: "TString",
    90  			si: func() rbytes.StreamerInfo {
    91  				const name = "TString"
    92  				si, ok := rdict.StreamerInfos.Get(name, -1)
    93  				if !ok {
    94  					t.Fatalf("could not load streamer for %q", name)
    95  				}
    96  				return si
    97  			}(),
    98  			want: reflect.TypeOf((*string)(nil)).Elem(),
    99  		},
   100  		{
   101  			name: "TNamed",
   102  			si: func() rbytes.StreamerInfo {
   103  				const name = "TNamed"
   104  				si, ok := rdict.StreamerInfos.Get(name, -1)
   105  				if !ok {
   106  					t.Fatalf("could not load streamer for %q", name)
   107  				}
   108  				return si
   109  			}(),
   110  			want: reflect.TypeOf((*rbase.Named)(nil)).Elem(),
   111  		},
   112  		{
   113  			name: "TObjString",
   114  			si: func() rbytes.StreamerInfo {
   115  				const name = "TObjString"
   116  				si, ok := rdict.StreamerInfos.Get(name, -1)
   117  				if !ok {
   118  					t.Fatalf("could not load streamer for %q", name)
   119  				}
   120  				return si
   121  			}(),
   122  			want: reflect.TypeOf((*rbase.ObjString)(nil)).Elem(),
   123  		},
   124  		{
   125  			name: "TObjArray",
   126  			si: func() rbytes.StreamerInfo {
   127  				const name = "TObjArray"
   128  				si, ok := rdict.StreamerInfos.Get(name, -1)
   129  				if !ok {
   130  					t.Fatalf("could not load streamer for %q", name)
   131  				}
   132  				return si
   133  			}(),
   134  			want: reflect.TypeOf((*rcont.ObjArray)(nil)).Elem(),
   135  		},
   136  		{
   137  			name: "TArrayD",
   138  			si: func() rbytes.StreamerInfo {
   139  				const name = "TArrayD"
   140  				si, ok := rdict.StreamerInfos.Get(name, -1)
   141  				if !ok {
   142  					t.Fatalf("could not load streamer for %q", name)
   143  				}
   144  				return si
   145  			}(),
   146  			want: reflect.TypeOf((*rcont.ArrayD)(nil)).Elem(),
   147  		},
   148  		{
   149  			name: "MyArrayD",
   150  			si: rdict.NewCxxStreamerInfo("MyArrayD", 1, 0, []rbytes.StreamerElement{
   151  				&rdict.StreamerSTLstring{
   152  					StreamerSTL: *rdict.NewCxxStreamerSTL(
   153  						rdict.Element{
   154  							Name:  *rbase.NewNamed("Name", ""),
   155  							Type:  rmeta.Streamer,
   156  							Size:  32,
   157  							EName: "string",
   158  						}.New(),
   159  						rmeta.ESTLType(rmeta.STLstring),
   160  						rmeta.STLstring,
   161  					),
   162  				},
   163  				&rdict.StreamerObject{
   164  					StreamerElement: rdict.Element{
   165  						Name:  *rbase.NewNamed("Array", ""),
   166  						Type:  rmeta.Object,
   167  						Size:  40,
   168  						EName: "TArrayD",
   169  					}.New(),
   170  				},
   171  			}),
   172  			want: func() reflect.Type {
   173  				return reflect.TypeOf((*struct {
   174  					ROOT_Name  string       `groot:"Name"`
   175  					ROOT_Array rcont.ArrayD `groot:"Array"`
   176  				})(nil)).Elem()
   177  			}(),
   178  		},
   179  		{
   180  			name: "string-old-streamer-v2",
   181  			si:   rdict.NewCxxStreamerInfo("string", 2, 0, nil),
   182  			want: reflect.TypeOf(""),
   183  		},
   184  		{
   185  			name: "vector<double>-old-streamer-v6",
   186  			si: rdict.NewCxxStreamerInfo("vector<double>", 6, 0, []rbytes.StreamerElement{
   187  				rdict.NewCxxStreamerSTL(rdict.Element{
   188  					Name:  *rbase.NewNamed("vector<double>", ""),
   189  					Type:  rmeta.Streamer,
   190  					Size:  24,
   191  					EName: "vector<double>",
   192  				}.New(), rmeta.STLvector, rmeta.Float64),
   193  			}),
   194  			want: reflect.TypeOf((*[]float64)(nil)).Elem(),
   195  		},
   196  		{
   197  			name: "pair<int,float>",
   198  			si: rdict.NewCxxStreamerInfo("pair<int,float>", 1, 0, []rbytes.StreamerElement{
   199  				&rdict.StreamerBasicType{
   200  					StreamerElement: rdict.Element{
   201  						Name:  *rbase.NewNamed("first", ""),
   202  						Type:  rmeta.Int32,
   203  						EName: "int32_t",
   204  					}.New(),
   205  				},
   206  				&rdict.StreamerBasicType{
   207  					StreamerElement: rdict.Element{
   208  						Name:  *rbase.NewNamed("second", ""),
   209  						Type:  rmeta.Float32,
   210  						EName: "float32_t",
   211  					}.New(),
   212  				},
   213  			}),
   214  			want: reflect.TypeOf((*struct {
   215  				ROOT_first  int32   `groot:"first"`
   216  				ROOT_second float32 `groot:"second"`
   217  			})(nil)).Elem(),
   218  		},
   219  		{
   220  			name: "vector<int>",
   221  			si: rdict.NewCxxStreamerInfo("vector<int>", 1, 0, []rbytes.StreamerElement{
   222  				rdict.NewCxxStreamerSTL(rdict.Element{
   223  					Name:  *rbase.NewNamed("This", "<int> Used to call the proper TStreamerInfo case"),
   224  					Type:  rmeta.Streamer,
   225  					Size:  48,
   226  					EName: "vector<int>",
   227  				}.New(), rmeta.STLvector, rmeta.Object),
   228  			}),
   229  			want: reflect.TypeOf((*[]int32)(nil)).Elem(),
   230  		},
   231  		{
   232  			name: "list<int>",
   233  			si: rdict.NewCxxStreamerInfo("list<int>", 1, 0, []rbytes.StreamerElement{
   234  				rdict.NewCxxStreamerSTL(rdict.Element{
   235  					Name:  *rbase.NewNamed("This", "<int> Used to call the proper TStreamerInfo case"),
   236  					Type:  rmeta.Streamer,
   237  					Size:  48,
   238  					EName: "list<int>",
   239  				}.New(), rmeta.STLlist, rmeta.Object),
   240  			}),
   241  			want: reflect.TypeOf((*[]int32)(nil)).Elem(),
   242  		},
   243  		{
   244  			name: "deque<int>",
   245  			si: rdict.NewCxxStreamerInfo("deque<int>", 1, 0, []rbytes.StreamerElement{
   246  				rdict.NewCxxStreamerSTL(rdict.Element{
   247  					Name:  *rbase.NewNamed("This", "<int> Used to call the proper TStreamerInfo case"),
   248  					Type:  rmeta.Streamer,
   249  					Size:  48,
   250  					EName: "deque<int>",
   251  				}.New(), rmeta.STLdeque, rmeta.Object),
   252  			}),
   253  			want: reflect.TypeOf((*[]int32)(nil)).Elem(),
   254  		},
   255  		{
   256  			name: "set<int>",
   257  			si: rdict.NewCxxStreamerInfo("set<int>", 1, 0, []rbytes.StreamerElement{
   258  				rdict.NewCxxStreamerSTL(rdict.Element{
   259  					Name:  *rbase.NewNamed("This", "<int> Used to call the proper TStreamerInfo case"),
   260  					Type:  rmeta.Streamer,
   261  					Size:  48,
   262  					EName: "set<int>",
   263  				}.New(), rmeta.STLset, rmeta.Object),
   264  			}),
   265  			want: reflect.TypeOf((*[]int32)(nil)).Elem(),
   266  		},
   267  		{
   268  			name: "multiset<int>",
   269  			si: rdict.NewCxxStreamerInfo("multiset<int>", 1, 0, []rbytes.StreamerElement{
   270  				rdict.NewCxxStreamerSTL(rdict.Element{
   271  					Name:  *rbase.NewNamed("This", "<int> Used to call the proper TStreamerInfo case"),
   272  					Type:  rmeta.Streamer,
   273  					Size:  48,
   274  					EName: "set<int>",
   275  				}.New(), rmeta.STLmultiset, rmeta.Object),
   276  			}),
   277  			want: reflect.TypeOf((*[]int32)(nil)).Elem(),
   278  		},
   279  		{
   280  			name: "unordered_set<int>",
   281  			si: rdict.NewCxxStreamerInfo("unordered_set<int>", 1, 0, []rbytes.StreamerElement{
   282  				rdict.NewCxxStreamerSTL(rdict.Element{
   283  					Name:  *rbase.NewNamed("This", "<int> Used to call the proper TStreamerInfo case"),
   284  					Type:  rmeta.Streamer,
   285  					Size:  48,
   286  					EName: "unordered_set<int>",
   287  				}.New(), rmeta.STLunorderedset, rmeta.Object),
   288  			}),
   289  			want: reflect.TypeOf((*[]int32)(nil)).Elem(),
   290  		},
   291  		{
   292  			name: "unordered_multiset<int>",
   293  			si: rdict.NewCxxStreamerInfo("unordered_multiset<int>", 1, 0, []rbytes.StreamerElement{
   294  				rdict.NewCxxStreamerSTL(rdict.Element{
   295  					Name:  *rbase.NewNamed("This", "<int> Used to call the proper TStreamerInfo case"),
   296  					Type:  rmeta.Streamer,
   297  					Size:  48,
   298  					EName: "unordered_multiset<int>",
   299  				}.New(), rmeta.STLunorderedmultiset, rmeta.Object),
   300  			}),
   301  			want: reflect.TypeOf((*[]int32)(nil)).Elem(),
   302  		},
   303  		{
   304  			name: "map<int,float>",
   305  			si: rdict.NewCxxStreamerInfo("map<int,float>", 1, 0, []rbytes.StreamerElement{
   306  				rdict.NewCxxStreamerSTL(rdict.Element{
   307  					Name:  *rbase.NewNamed("This", "<pair<int,float>> Used to call the proper TStreamerInfo case"),
   308  					Type:  rmeta.Streamer,
   309  					Size:  48,
   310  					EName: "map<int,float>",
   311  				}.New(), rmeta.STLmap, rmeta.Object),
   312  			}),
   313  			want: reflect.TypeOf((*map[int32]float32)(nil)).Elem(),
   314  		},
   315  		{
   316  			name: "multimap<int,float>",
   317  			si: rdict.NewCxxStreamerInfo("multimap<int,float>", 1, 0, []rbytes.StreamerElement{
   318  				rdict.NewCxxStreamerSTL(rdict.Element{
   319  					Name:  *rbase.NewNamed("This", "<pair<int,float>> Used to call the proper TStreamerInfo case"),
   320  					Type:  rmeta.Streamer,
   321  					Size:  48,
   322  					EName: "multimap<int,float>",
   323  				}.New(), rmeta.STLmultimap, rmeta.Object),
   324  			}),
   325  			want: reflect.TypeOf((*map[int32]float32)(nil)).Elem(),
   326  		},
   327  		{
   328  			name: "unordered_map<int,float>",
   329  			si: rdict.NewCxxStreamerInfo("unordered_map<int,float>", 1, 0, []rbytes.StreamerElement{
   330  				rdict.NewCxxStreamerSTL(rdict.Element{
   331  					Name:  *rbase.NewNamed("This", "<pair<int,float>> Used to call the proper TStreamerInfo case"),
   332  					Type:  rmeta.Streamer,
   333  					Size:  48,
   334  					EName: "unordered_map<int,float>",
   335  				}.New(), rmeta.STLunorderedmap, rmeta.Object),
   336  			}),
   337  			want: reflect.TypeOf((*map[int32]float32)(nil)).Elem(),
   338  		},
   339  		{
   340  			name: "unordered_multimap<int,float>",
   341  			si: rdict.NewCxxStreamerInfo("unordered_multimap<int,float>", 1, 0, []rbytes.StreamerElement{
   342  				rdict.NewCxxStreamerSTL(rdict.Element{
   343  					Name:  *rbase.NewNamed("This", "<pair<int,float>> Used to call the proper TStreamerInfo case"),
   344  					Type:  rmeta.Streamer,
   345  					Size:  48,
   346  					EName: "unordered_multimap<int,float>",
   347  				}.New(), rmeta.STLunorderedmultimap, rmeta.Object),
   348  			}),
   349  			want: reflect.TypeOf((*map[int32]float32)(nil)).Elem(),
   350  		},
   351  		{
   352  			name: "map<int,string>",
   353  			si: rdict.NewCxxStreamerInfo("map<int,string>", 1, 0, []rbytes.StreamerElement{
   354  				rdict.NewCxxStreamerSTL(rdict.Element{
   355  					Name:  *rbase.NewNamed("This", "<pair<int,string>> Used to call the proper TStreamerInfo case"),
   356  					Type:  rmeta.Streamer,
   357  					Size:  48,
   358  					EName: "map<int,string>",
   359  				}.New(), rmeta.STLmap, rmeta.Object),
   360  			}),
   361  			want: reflect.TypeOf((*map[int32]string)(nil)).Elem(),
   362  		},
   363  		{
   364  			name: "map<int,TNamed>",
   365  			si: rdict.NewCxxStreamerInfo("map<int,TNamed>", 1, 0, []rbytes.StreamerElement{
   366  				rdict.NewCxxStreamerSTL(rdict.Element{
   367  					Name:  *rbase.NewNamed("This", "<pair<int,TNamed>> Used to call the proper TStreamerInfo case"),
   368  					Type:  rmeta.Streamer,
   369  					Size:  48,
   370  					EName: "map<int,TNamed>",
   371  				}.New(), rmeta.STLmap, rmeta.Object),
   372  			}),
   373  			want: reflect.TypeOf((*map[int32]rbase.Named)(nil)).Elem(),
   374  		},
   375  		{
   376  			name: "map<TNamed,int>",
   377  			si: rdict.NewCxxStreamerInfo("map<TNamed,int>", 1, 0, []rbytes.StreamerElement{
   378  				rdict.NewCxxStreamerSTL(rdict.Element{
   379  					Name:  *rbase.NewNamed("This", "<pair<TNamed,int>> Used to call the proper TStreamerInfo case"),
   380  					Type:  rmeta.Streamer,
   381  					Size:  48,
   382  					EName: "map<TNamed,int>",
   383  				}.New(), rmeta.STLmap, rmeta.Object),
   384  			}),
   385  			want: reflect.TypeOf((*map[rbase.Named]int32)(nil)).Elem(),
   386  		},
   387  		{
   388  			name: "map<int,vector<TNamed> >",
   389  			si: rdict.NewCxxStreamerInfo("map<int,vector<TNamed> >", 1, 0, []rbytes.StreamerElement{
   390  				rdict.NewCxxStreamerSTL(rdict.Element{
   391  					Name:  *rbase.NewNamed("This", "<pair<int,vector<TNamed> >> Used to call the proper TStreamerInfo case"),
   392  					Type:  rmeta.Streamer,
   393  					Size:  48,
   394  					EName: "map<int,vector<TNamed> >",
   395  				}.New(), rmeta.STLmap, rmeta.Object),
   396  			}),
   397  			want: reflect.TypeOf((*map[int32][]rbase.Named)(nil)).Elem(),
   398  		},
   399  		{
   400  			name: "map<int,vector<string> >",
   401  			si: rdict.NewCxxStreamerInfo("map<int,vector<string> >", 1, 0, []rbytes.StreamerElement{
   402  				rdict.NewCxxStreamerSTL(rdict.Element{
   403  					Name:  *rbase.NewNamed("This", "<pair<int,vector<string> >> Used to call the proper TStreamerInfo case"),
   404  					Type:  rmeta.Streamer,
   405  					Size:  48,
   406  					EName: "map<int,vector<string> >",
   407  				}.New(), rmeta.STLmap, rmeta.Object),
   408  			}),
   409  			want: reflect.TypeOf((*map[int32][]string)(nil)).Elem(),
   410  		},
   411  		{
   412  			name: "map<int,map<int,vector<string> > >",
   413  			si: rdict.NewCxxStreamerInfo("map<int,map<int,vector<string> > >", 1, 0, []rbytes.StreamerElement{
   414  				rdict.NewCxxStreamerSTL(rdict.Element{
   415  					Name:  *rbase.NewNamed("This", "<pair<int,map<int,vector<string> > >> Used to call the proper TStreamerInfo case"),
   416  					Type:  rmeta.Streamer,
   417  					Size:  48,
   418  					EName: "map<int,map<int,vector<string> > >",
   419  				}.New(), rmeta.STLmap, rmeta.Object),
   420  			}),
   421  			want: reflect.TypeOf((*map[int32]map[int32][]string)(nil)).Elem(),
   422  		},
   423  		{
   424  			name: "map<int,string>-with-pair-dict",
   425  			si: rdict.NewCxxStreamerInfo("MyEvent", 1, 0, []rbytes.StreamerElement{
   426  				rdict.NewCxxStreamerSTL(rdict.Element{
   427  					Name:  *rbase.NewNamed("mapI32Str", " (pair<int,string>)"),
   428  					Type:  rmeta.Streamer,
   429  					Size:  48,
   430  					EName: "map<int,string>",
   431  				}.New(), rmeta.STLmap, rmeta.Object),
   432  			}),
   433  			want: reflect.TypeOf((*struct {
   434  				ROOT_mapI32Str map[int32]string `groot:"mapI32Str"`
   435  			})(nil)).Elem(),
   436  		},
   437  		{
   438  			name: "vector<TObject>",
   439  			si: rdict.NewCxxStreamerInfo("vector<TObject>", rvers.StreamerBaseSTL, 0, []rbytes.StreamerElement{
   440  				rdict.NewCxxStreamerSTL(rdict.Element{
   441  					Name:  *rbase.NewNamed("vector<TObject>", ""),
   442  					Type:  rmeta.Streamer,
   443  					Size:  24,
   444  					EName: "vector<TObject>",
   445  				}.New(), rmeta.STLvector, rmeta.TObject),
   446  			}),
   447  			want: reflect.TypeOf((*[]rbase.Object)(nil)).Elem(),
   448  		},
   449  		{
   450  			name: "vector<TNamed>",
   451  			si: rdict.NewCxxStreamerInfo("vector<TNamed>", rvers.StreamerBaseSTL, 0, []rbytes.StreamerElement{
   452  				rdict.NewCxxStreamerSTL(rdict.Element{
   453  					Name:  *rbase.NewNamed("vector<TNamed>", ""),
   454  					Type:  rmeta.Streamer,
   455  					Size:  24,
   456  					EName: "vector<TNamed>",
   457  				}.New(), rmeta.STLvector, rmeta.TNamed),
   458  			}),
   459  			want: reflect.TypeOf((*[]rbase.Named)(nil)).Elem(),
   460  		},
   461  		{
   462  			name: "vector<TObjString>",
   463  			si: rdict.NewCxxStreamerInfo("vector<TObjString>", rvers.StreamerBaseSTL, 0, []rbytes.StreamerElement{
   464  				rdict.NewCxxStreamerSTL(rdict.Element{
   465  					Name:  *rbase.NewNamed("vector<TObjString>", ""),
   466  					Type:  rmeta.Streamer,
   467  					Size:  24,
   468  					EName: "vector<TObjString>",
   469  				}.New(), rmeta.STLvector, rmeta.Object),
   470  			}),
   471  			want: reflect.TypeOf((*[]rbase.ObjString)(nil)).Elem(),
   472  		},
   473  		{
   474  			name: "bitset<256>",
   475  			si: rdict.NewCxxStreamerInfo("MyBitset", rvers.StreamerBaseSTL, 0, []rbytes.StreamerElement{
   476  				rdict.NewCxxStreamerSTL(rdict.Element{
   477  					Name:  *rbase.NewNamed("bs", ""),
   478  					Type:  rmeta.Streamer,
   479  					Size:  24,
   480  					EName: "bitset<256>",
   481  				}.New(), rmeta.STLbitset, 0),
   482  			}),
   483  			want: reflect.TypeOf((*struct {
   484  				ROOT_bs []uint8 `groot:"bs"`
   485  			})(nil)).Elem(),
   486  		},
   487  		{
   488  			name: "vector<bitset<256> >",
   489  			si: rdict.NewCxxStreamerInfo("MyBitsets", rvers.StreamerBaseSTL, 0, []rbytes.StreamerElement{
   490  				rdict.NewCxxStreamerSTL(rdict.Element{
   491  					Name:  *rbase.NewNamed("bs", ""),
   492  					Type:  rmeta.Streamer,
   493  					Size:  24,
   494  					EName: "vector<bitset<256> >",
   495  				}.New(), rmeta.STLvector, 0),
   496  			}),
   497  			want: reflect.TypeOf((*struct {
   498  				ROOT_bs [][]uint8 `groot:"bs"`
   499  			})(nil)).Elem(),
   500  		},
   501  		{
   502  			name: "event",
   503  			si: rdict.NewCxxStreamerInfo("event", 1, 0, []rbytes.StreamerElement{
   504  				rdict.NewStreamerBase(
   505  					rdict.Element{
   506  						Name:  *rbase.NewNamed("TObject", ""),
   507  						Type:  rmeta.Base,
   508  						EName: "BASE",
   509  					}.New(),
   510  					rvers.Named,
   511  				),
   512  				&rdict.StreamerBasicType{
   513  					StreamerElement: rdict.Element{
   514  						Name:  *rbase.NewNamed("b", ""),
   515  						Type:  rmeta.Bool,
   516  						EName: "bool",
   517  					}.New(),
   518  				},
   519  				&rdict.StreamerBasicType{
   520  					StreamerElement: rdict.Element{
   521  						Name:  *rbase.NewNamed("i8", ""),
   522  						Type:  rmeta.Int8,
   523  						EName: "int8_t",
   524  					}.New(),
   525  				},
   526  				&rdict.StreamerBasicType{
   527  					StreamerElement: rdict.Element{
   528  						Name:  *rbase.NewNamed("i16", ""),
   529  						Type:  rmeta.Int16,
   530  						EName: "int16_t",
   531  					}.New(),
   532  				},
   533  				&rdict.StreamerBasicType{
   534  					StreamerElement: rdict.Element{
   535  						Name:  *rbase.NewNamed("i32", ""),
   536  						Type:  rmeta.Int32,
   537  						EName: "int32_t",
   538  					}.New(),
   539  				},
   540  				&rdict.StreamerBasicType{
   541  					StreamerElement: rdict.Element{
   542  						Name:  *rbase.NewNamed("i64", ""),
   543  						Type:  rmeta.Int64,
   544  						EName: "int64_t",
   545  					}.New(),
   546  				},
   547  				&rdict.StreamerBasicType{
   548  					StreamerElement: rdict.Element{
   549  						Name:  *rbase.NewNamed("u8", ""),
   550  						Type:  rmeta.Uint8,
   551  						EName: "uint8_t",
   552  					}.New(),
   553  				},
   554  				&rdict.StreamerBasicType{
   555  					StreamerElement: rdict.Element{
   556  						Name:  *rbase.NewNamed("u16", ""),
   557  						Type:  rmeta.Uint16,
   558  						EName: "uint16_t",
   559  					}.New(),
   560  				},
   561  				&rdict.StreamerBasicType{
   562  					StreamerElement: rdict.Element{
   563  						Name:  *rbase.NewNamed("u32", ""),
   564  						Type:  rmeta.Uint32,
   565  						EName: "uint32_t",
   566  					}.New(),
   567  				},
   568  				&rdict.StreamerBasicType{
   569  					StreamerElement: rdict.Element{
   570  						Name:  *rbase.NewNamed("u64", ""),
   571  						Type:  rmeta.Uint64,
   572  						EName: "uint64_t",
   573  					}.New(),
   574  				},
   575  				&rdict.StreamerBasicType{
   576  					StreamerElement: rdict.Element{
   577  						Name:  *rbase.NewNamed("N", ""),
   578  						Type:  rmeta.Counter,
   579  						Size:  4,
   580  						EName: "int32_t",
   581  					}.New(),
   582  				},
   583  				&rdict.StreamerBasicType{
   584  					StreamerElement: rdict.Element{
   585  						Name:  *rbase.NewNamed("NN", ""),
   586  						Type:  rmeta.Counter,
   587  						Size:  8,
   588  						EName: "int64_t",
   589  					}.New(),
   590  				},
   591  				&rdict.StreamerBasicType{
   592  					StreamerElement: rdict.Element{
   593  						Name:  *rbase.NewNamed("bits", ""),
   594  						Type:  rmeta.Bits,
   595  						Size:  4,
   596  						EName: "Bits_t",
   597  					}.New(),
   598  				},
   599  				&rdict.StreamerBasicType{
   600  					StreamerElement: rdict.Element{
   601  						Name:  *rbase.NewNamed("f32", ""),
   602  						Type:  rmeta.Float32,
   603  						EName: "float32_t",
   604  					}.New(),
   605  				},
   606  				&rdict.StreamerBasicType{
   607  					StreamerElement: rdict.Element{
   608  						Name:  *rbase.NewNamed("f64", ""),
   609  						Type:  rmeta.Float64,
   610  						EName: "float64_t",
   611  					}.New(),
   612  				},
   613  				&rdict.StreamerBasicType{
   614  					StreamerElement: rdict.Element{
   615  						Name:  *rbase.NewNamed("f16", ""),
   616  						Type:  rmeta.Float16,
   617  						EName: "Float16_t",
   618  					}.New(),
   619  				},
   620  				&rdict.StreamerBasicType{
   621  					StreamerElement: rdict.Element{
   622  						Name:  *rbase.NewNamed("d32", ""),
   623  						Type:  rmeta.Double32,
   624  						EName: "Double32_t",
   625  					}.New(),
   626  				},
   627  				&rdict.StreamerBasicType{
   628  					StreamerElement: rdict.Element{
   629  						Name:  *rbase.NewNamed("str", ""),
   630  						Type:  rmeta.TString,
   631  						EName: "TString",
   632  					}.New(),
   633  				},
   634  				&rdict.StreamerBasicType{
   635  					StreamerElement: rdict.Element{
   636  						Name:  *rbase.NewNamed("cstr", ""),
   637  						Type:  rmeta.CharStar,
   638  						EName: "char*",
   639  					}.New(),
   640  				},
   641  
   642  				// arrays
   643  				&rdict.StreamerBasicType{
   644  					StreamerElement: rdict.Element{
   645  						Name:   *rbase.NewNamed("arrB", ""),
   646  						Type:   rmeta.OffsetL + rmeta.Bool,
   647  						Size:   3 * 1,
   648  						ArrLen: 3,
   649  						ArrDim: 1,
   650  						MaxIdx: [5]int32{3, 0, 0, 0, 0},
   651  						EName:  "bool*",
   652  					}.New(),
   653  				},
   654  				&rdict.StreamerBasicType{
   655  					StreamerElement: rdict.Element{
   656  						Name:   *rbase.NewNamed("arrI8", ""),
   657  						Type:   rmeta.OffsetL + rmeta.Int8,
   658  						Size:   3 * 1,
   659  						ArrLen: 3,
   660  						ArrDim: 1,
   661  						MaxIdx: [5]int32{3, 0, 0, 0, 0},
   662  						EName:  "int8_t*",
   663  					}.New(),
   664  				},
   665  				&rdict.StreamerBasicType{
   666  					StreamerElement: rdict.Element{
   667  						Name:   *rbase.NewNamed("arrI16", ""),
   668  						Type:   rmeta.OffsetL + rmeta.Int16,
   669  						Size:   3 * 2,
   670  						ArrLen: 3,
   671  						ArrDim: 1,
   672  						MaxIdx: [5]int32{3, 0, 0, 0, 0},
   673  						EName:  "int16_t*",
   674  					}.New(),
   675  				},
   676  				&rdict.StreamerBasicType{
   677  					StreamerElement: rdict.Element{
   678  						Name:   *rbase.NewNamed("arrI32", ""),
   679  						Type:   rmeta.OffsetL + rmeta.Int32,
   680  						Size:   3 * 4,
   681  						ArrLen: 3,
   682  						ArrDim: 1,
   683  						MaxIdx: [5]int32{3, 0, 0, 0, 0},
   684  						EName:  "int32_t*",
   685  					}.New(),
   686  				},
   687  				&rdict.StreamerBasicType{
   688  					StreamerElement: rdict.Element{
   689  						Name:   *rbase.NewNamed("arrI64", ""),
   690  						Type:   rmeta.OffsetL + rmeta.Int64,
   691  						Size:   3 * 8,
   692  						ArrLen: 3,
   693  						ArrDim: 1,
   694  						MaxIdx: [5]int32{3, 0, 0, 0, 0},
   695  						EName:  "int64_t*",
   696  					}.New(),
   697  				},
   698  				&rdict.StreamerBasicType{
   699  					StreamerElement: rdict.Element{
   700  						Name:   *rbase.NewNamed("arrU8", ""),
   701  						Type:   rmeta.OffsetL + rmeta.Uint8,
   702  						Size:   3 * 1,
   703  						ArrLen: 3,
   704  						ArrDim: 1,
   705  						MaxIdx: [5]int32{3, 0, 0, 0, 0},
   706  						EName:  "uint8_t*",
   707  					}.New(),
   708  				},
   709  				&rdict.StreamerBasicType{
   710  					StreamerElement: rdict.Element{
   711  						Name:   *rbase.NewNamed("arrU16", ""),
   712  						Type:   rmeta.OffsetL + rmeta.Uint16,
   713  						Size:   3 * 2,
   714  						ArrLen: 3,
   715  						ArrDim: 1,
   716  						MaxIdx: [5]int32{3, 0, 0, 0, 0},
   717  						EName:  "uint16_t*",
   718  					}.New(),
   719  				},
   720  				&rdict.StreamerBasicType{
   721  					StreamerElement: rdict.Element{
   722  						Name:   *rbase.NewNamed("arrU32", ""),
   723  						Type:   rmeta.OffsetL + rmeta.Uint32,
   724  						Size:   3 * 4,
   725  						ArrLen: 3,
   726  						ArrDim: 1,
   727  						MaxIdx: [5]int32{3, 0, 0, 0, 0},
   728  						EName:  "uint32_t*",
   729  					}.New(),
   730  				},
   731  				&rdict.StreamerBasicType{
   732  					StreamerElement: rdict.Element{
   733  						Name:   *rbase.NewNamed("arrU64", ""),
   734  						Type:   rmeta.OffsetL + rmeta.Uint64,
   735  						Size:   3 * 8,
   736  						ArrLen: 3,
   737  						ArrDim: 1,
   738  						MaxIdx: [5]int32{3, 0, 0, 0, 0},
   739  						EName:  "uint64_t*",
   740  					}.New(),
   741  				},
   742  				&rdict.StreamerBasicType{
   743  					StreamerElement: rdict.Element{
   744  						Name:   *rbase.NewNamed("arrF32", ""),
   745  						Type:   rmeta.OffsetL + rmeta.Float32,
   746  						Size:   3 * 4,
   747  						ArrLen: 3,
   748  						ArrDim: 1,
   749  						MaxIdx: [5]int32{3, 0, 0, 0, 0},
   750  						EName:  "float32_t*",
   751  					}.New(),
   752  				},
   753  				&rdict.StreamerBasicType{
   754  					StreamerElement: rdict.Element{
   755  						Name:   *rbase.NewNamed("arrF64", ""),
   756  						Type:   rmeta.OffsetL + rmeta.Float64,
   757  						Size:   3 * 8,
   758  						ArrLen: 3,
   759  						ArrDim: 1,
   760  						MaxIdx: [5]int32{3, 0, 0, 0, 0},
   761  						EName:  "float64_t*",
   762  					}.New(),
   763  				},
   764  				&rdict.StreamerBasicType{
   765  					StreamerElement: rdict.Element{
   766  						Name:   *rbase.NewNamed("arrF16", ""),
   767  						Type:   rmeta.OffsetL + rmeta.Float16,
   768  						Size:   3 * 4,
   769  						ArrLen: 3,
   770  						ArrDim: 1,
   771  						MaxIdx: [5]int32{3, 0, 0, 0, 0},
   772  						EName:  "Float16_t*",
   773  					}.New(),
   774  				},
   775  				&rdict.StreamerBasicType{
   776  					StreamerElement: rdict.Element{
   777  						Name:   *rbase.NewNamed("arrD32", ""),
   778  						Type:   rmeta.OffsetL + rmeta.Double32,
   779  						Size:   3 * 4,
   780  						ArrLen: 3,
   781  						ArrDim: 1,
   782  						MaxIdx: [5]int32{3, 0, 0, 0, 0},
   783  						EName:  "Double32_t*",
   784  					}.New(),
   785  				},
   786  				&rdict.StreamerBasicType{
   787  					StreamerElement: rdict.Element{
   788  						Name:   *rbase.NewNamed("arrStr", ""),
   789  						Type:   rmeta.OffsetL + rmeta.TString,
   790  						Size:   3 * 24,
   791  						ArrLen: 3,
   792  						ArrDim: 1,
   793  						MaxIdx: [5]int32{3, 0, 0, 0, 0},
   794  						EName:  "TString*",
   795  					}.New(),
   796  				},
   797  				&rdict.StreamerBasicType{
   798  					StreamerElement: rdict.Element{
   799  						Name:   *rbase.NewNamed("arrCstr", ""),
   800  						Type:   rmeta.OffsetL + rmeta.CharStar,
   801  						Size:   3 * 8,
   802  						ArrLen: 3,
   803  						ArrDim: 1,
   804  						MaxIdx: [5]int32{3, 0, 0, 0, 0},
   805  						EName:  "char**",
   806  					}.New(),
   807  				},
   808  				//	&rdict.StreamerBasicType{
   809  				//		StreamerElement: rdict.Element{
   810  				//			Name:   *rbase.NewNamed("arrN32", ""),
   811  				//			Type:   rmeta.OffsetL + rmeta.Counter,
   812  				//			Size:   3 * 4,
   813  				//			ArrLen: 3,
   814  				//			ArrDim: 1,
   815  				//		MaxIdx: [5]int32{1, 0, 0, 0, 0},
   816  				//			EName:  "Counter_t",
   817  				//		}.New(),
   818  				//	},
   819  				//	&rdict.StreamerBasicType{
   820  				//		StreamerElement: rdict.Element{
   821  				//			Name:   *rbase.NewNamed("arrN64", ""),
   822  				//			Type:   rmeta.OffsetL + rmeta.Counter,
   823  				//			Size:   3 * 8,
   824  				//			ArrLen: 3,
   825  				//			ArrDim: 1,
   826  				//		MaxIdx: [5]int32{1, 0, 0, 0, 0},
   827  				//			EName:  "Counter_t",
   828  				//		}.New(),
   829  				//	},
   830  
   831  				&rdict.StreamerObjectPointer{
   832  					StreamerElement: rdict.Element{
   833  						Name:   *rbase.NewNamed("arrTObj", ""),
   834  						Type:   rmeta.OffsetL + rmeta.TObject,
   835  						Size:   3 * 16,
   836  						ArrLen: 3,
   837  						ArrDim: 1,
   838  						MaxIdx: [5]int32{3, 0, 0, 0, 0},
   839  						EName:  "TObject*",
   840  					}.New(),
   841  				},
   842  
   843  				//	var-len arrays
   844  				rdict.NewStreamerBasicPointer(
   845  					rdict.Element{
   846  						Name:  *rbase.NewNamed("sliB", "[N]"),
   847  						Type:  rmeta.OffsetP + rmeta.Bool,
   848  						Size:  1,
   849  						EName: "bool*",
   850  					}.New(), 1, "N", "event",
   851  				),
   852  				rdict.NewStreamerBasicPointer(
   853  					rdict.Element{
   854  						Name:  *rbase.NewNamed("sliI8", "[N]"),
   855  						Type:  rmeta.OffsetP + rmeta.Int8,
   856  						Size:  1,
   857  						EName: "int8_t*",
   858  					}.New(), 1, "N", "event",
   859  				),
   860  				rdict.NewStreamerBasicPointer(
   861  					rdict.Element{
   862  						Name:  *rbase.NewNamed("sliI16", "[N]"),
   863  						Type:  rmeta.OffsetP + rmeta.Int16,
   864  						Size:  2,
   865  						EName: "int16_t*",
   866  					}.New(), 1, "N", "event",
   867  				),
   868  				rdict.NewStreamerBasicPointer(
   869  					rdict.Element{
   870  						Name:  *rbase.NewNamed("sliI32", "[N]"),
   871  						Type:  rmeta.OffsetP + rmeta.Int32,
   872  						Size:  4,
   873  						EName: "int32_t*",
   874  					}.New(), 1, "N", "event",
   875  				),
   876  				rdict.NewStreamerBasicPointer(
   877  					rdict.Element{
   878  						Name:  *rbase.NewNamed("sliI64", "[N]"),
   879  						Type:  rmeta.OffsetP + rmeta.Int64,
   880  						Size:  8,
   881  						EName: "int64_t*",
   882  					}.New(), 1, "N", "event",
   883  				),
   884  				rdict.NewStreamerBasicPointer(
   885  					rdict.Element{
   886  						Name:  *rbase.NewNamed("sliU8", "[N]"),
   887  						Type:  rmeta.OffsetP + rmeta.Uint8,
   888  						Size:  1,
   889  						EName: "uint8_t*",
   890  					}.New(), 1, "N", "event",
   891  				),
   892  				rdict.NewStreamerBasicPointer(
   893  					rdict.Element{
   894  						Name:  *rbase.NewNamed("sliU16", "[N]"),
   895  						Type:  rmeta.OffsetP + rmeta.Uint16,
   896  						Size:  2,
   897  						EName: "uint16_t*",
   898  					}.New(), 1, "N", "event",
   899  				),
   900  				rdict.NewStreamerBasicPointer(
   901  					rdict.Element{
   902  						Name:  *rbase.NewNamed("sliU32", "[N]"),
   903  						Type:  rmeta.OffsetP + rmeta.Uint32,
   904  						Size:  4,
   905  						EName: "uint32_t*",
   906  					}.New(), 1, "N", "event",
   907  				),
   908  				rdict.NewStreamerBasicPointer(
   909  					rdict.Element{
   910  						Name:  *rbase.NewNamed("sliU64", "[N]"),
   911  						Type:  rmeta.OffsetP + rmeta.Uint64,
   912  						Size:  8,
   913  						EName: "uint64_t*",
   914  					}.New(), 1, "N", "event",
   915  				),
   916  				rdict.NewStreamerBasicPointer(
   917  					rdict.Element{
   918  						Name:  *rbase.NewNamed("sliF32", "[N]"),
   919  						Type:  rmeta.OffsetP + rmeta.Float32,
   920  						Size:  4,
   921  						EName: "float32_t*",
   922  					}.New(), 1, "N", "event",
   923  				),
   924  				rdict.NewStreamerBasicPointer(
   925  					rdict.Element{
   926  						Name:  *rbase.NewNamed("sliF64", "[N]"),
   927  						Type:  rmeta.OffsetP + rmeta.Float64,
   928  						Size:  8,
   929  						EName: "float64_t*",
   930  					}.New(), 1, "N", "event",
   931  				),
   932  				rdict.NewStreamerBasicPointer(
   933  					rdict.Element{
   934  						Name:  *rbase.NewNamed("sliF16", "[N]"),
   935  						Type:  rmeta.OffsetP + rmeta.Float16,
   936  						Size:  4,
   937  						EName: "Float16_t*",
   938  					}.New(), 1, "N", "event",
   939  				),
   940  				rdict.NewStreamerBasicPointer(
   941  					rdict.Element{
   942  						Name:  *rbase.NewNamed("sliD32", "[N]"),
   943  						Type:  rmeta.OffsetP + rmeta.Double32,
   944  						Size:  8,
   945  						EName: "Double32_t*",
   946  					}.New(), 1, "N", "event",
   947  				),
   948  				rdict.NewStreamerLoop(
   949  					rdict.Element{
   950  						Name:  *rbase.NewNamed("sliStr", "[N]"),
   951  						Size:  4,
   952  						EName: "TString*",
   953  					}.New(), 1, "N", "event",
   954  				),
   955  				rdict.NewStreamerBasicPointer(
   956  					rdict.Element{
   957  						Name:  *rbase.NewNamed("sliCstr", "[N]"),
   958  						Type:  rmeta.OffsetP + rmeta.CharStar,
   959  						Size:  1,
   960  						EName: "char**",
   961  					}.New(), 1, "N", "event",
   962  				),
   963  
   964  				// std-vector
   965  				rdict.NewCxxStreamerSTL(rdict.Element{
   966  					Name:   *rbase.NewNamed("stdVecB", ""),
   967  					Type:   rmeta.Streamer,
   968  					Size:   24,
   969  					MaxIdx: [5]int32{0, 0, 0, 0, 0},
   970  					EName:  "vector<bool>",
   971  				}.New(), rmeta.STLvector, rmeta.Bool),
   972  				rdict.NewCxxStreamerSTL(rdict.Element{
   973  					Name:   *rbase.NewNamed("stdVecI8", ""),
   974  					Type:   rmeta.Streamer,
   975  					Size:   24,
   976  					MaxIdx: [5]int32{0, 0, 0, 0, 0},
   977  					EName:  "vector<int8_t>",
   978  				}.New(), rmeta.STLvector, rmeta.Int8),
   979  				rdict.NewCxxStreamerSTL(rdict.Element{
   980  					Name:   *rbase.NewNamed("stdVecI16", ""),
   981  					Type:   rmeta.Streamer,
   982  					Size:   24,
   983  					MaxIdx: [5]int32{0, 0, 0, 0, 0},
   984  					EName:  "vector<int16_t>",
   985  				}.New(), rmeta.STLvector, rmeta.Int16),
   986  				rdict.NewCxxStreamerSTL(rdict.Element{
   987  					Name:   *rbase.NewNamed("stdVecI32", ""),
   988  					Type:   rmeta.Streamer,
   989  					Size:   24,
   990  					MaxIdx: [5]int32{0, 0, 0, 0, 0},
   991  					EName:  "vector<int32_t>",
   992  				}.New(), rmeta.STLvector, rmeta.Int32),
   993  				rdict.NewCxxStreamerSTL(rdict.Element{
   994  					Name:   *rbase.NewNamed("stdVecI64", ""),
   995  					Type:   rmeta.Streamer,
   996  					Size:   24,
   997  					MaxIdx: [5]int32{0, 0, 0, 0, 0},
   998  					EName:  "vector<int64_t>",
   999  				}.New(), rmeta.STLvector, rmeta.Int64),
  1000  				rdict.NewCxxStreamerSTL(rdict.Element{
  1001  					Name:   *rbase.NewNamed("stdVecU8", ""),
  1002  					Type:   rmeta.Streamer,
  1003  					Size:   24,
  1004  					MaxIdx: [5]int32{0, 0, 0, 0, 0},
  1005  					EName:  "vector<uint8_t>",
  1006  				}.New(), rmeta.STLvector, rmeta.Uint8),
  1007  				rdict.NewCxxStreamerSTL(rdict.Element{
  1008  					Name:   *rbase.NewNamed("stdVecU16", ""),
  1009  					Type:   rmeta.Streamer,
  1010  					Size:   24,
  1011  					MaxIdx: [5]int32{0, 0, 0, 0, 0},
  1012  					EName:  "vector<uint16_t>",
  1013  				}.New(), rmeta.STLvector, rmeta.Uint16),
  1014  				rdict.NewCxxStreamerSTL(rdict.Element{
  1015  					Name:   *rbase.NewNamed("stdVecU32", ""),
  1016  					Type:   rmeta.Streamer,
  1017  					Size:   24,
  1018  					MaxIdx: [5]int32{0, 0, 0, 0, 0},
  1019  					EName:  "vector<uint32_t>",
  1020  				}.New(), rmeta.STLvector, rmeta.Uint32),
  1021  				rdict.NewCxxStreamerSTL(rdict.Element{
  1022  					Name:   *rbase.NewNamed("stdVecU64", ""),
  1023  					Type:   rmeta.Streamer,
  1024  					Size:   24,
  1025  					MaxIdx: [5]int32{0, 0, 0, 0, 0},
  1026  					EName:  "vector<uint64_t>",
  1027  				}.New(), rmeta.STLvector, rmeta.Uint64),
  1028  				rdict.NewCxxStreamerSTL(rdict.Element{
  1029  					Name:   *rbase.NewNamed("stdVecF32", ""),
  1030  					Type:   rmeta.Streamer,
  1031  					Size:   24,
  1032  					MaxIdx: [5]int32{0, 0, 0, 0, 0},
  1033  					EName:  "vector<float32_t>",
  1034  				}.New(), rmeta.STLvector, rmeta.Float32),
  1035  				rdict.NewCxxStreamerSTL(rdict.Element{
  1036  					Name:   *rbase.NewNamed("stdVecF64", ""),
  1037  					Type:   rmeta.Streamer,
  1038  					Size:   24,
  1039  					MaxIdx: [5]int32{0, 0, 0, 0, 0},
  1040  					EName:  "vector<float64_t>",
  1041  				}.New(), rmeta.STLvector, rmeta.Float64),
  1042  				rdict.NewCxxStreamerSTL(rdict.Element{
  1043  					Name:   *rbase.NewNamed("stdVecF16", ""),
  1044  					Type:   rmeta.Streamer,
  1045  					Size:   24,
  1046  					MaxIdx: [5]int32{0, 0, 0, 0, 0},
  1047  					EName:  "vector<Float16_t>",
  1048  				}.New(), rmeta.STLvector, rmeta.Float16),
  1049  				rdict.NewCxxStreamerSTL(rdict.Element{
  1050  					Name:   *rbase.NewNamed("stdVecD32", ""),
  1051  					Type:   rmeta.Streamer,
  1052  					Size:   24,
  1053  					MaxIdx: [5]int32{0, 0, 0, 0, 0},
  1054  					EName:  "vector<Double32_t>",
  1055  				}.New(), rmeta.STLvector, rmeta.Double32),
  1056  				rdict.NewCxxStreamerSTL(rdict.Element{
  1057  					Name:   *rbase.NewNamed("stdVecStr", ""),
  1058  					Type:   rmeta.Streamer,
  1059  					Size:   24,
  1060  					MaxIdx: [5]int32{0, 0, 0, 0, 0},
  1061  					EName:  "vector<string>",
  1062  				}.New(), rmeta.STLvector, rmeta.STLstring),
  1063  				rdict.NewCxxStreamerSTL(rdict.Element{
  1064  					Name:   *rbase.NewNamed("stdVecCstr", ""),
  1065  					Type:   rmeta.Streamer,
  1066  					Size:   24,
  1067  					MaxIdx: [5]int32{0, 0, 0, 0, 0},
  1068  					EName:  "vector<char*>",
  1069  				}.New(), rmeta.STLvector, rmeta.CharStar),
  1070  				rdict.NewCxxStreamerSTL(rdict.Element{
  1071  					Name:   *rbase.NewNamed("stdVecNamed1", ""),
  1072  					Type:   rmeta.Streamer,
  1073  					Size:   24,
  1074  					MaxIdx: [5]int32{0, 0, 0, 0, 0},
  1075  					EName:  "vector<TNamed>",
  1076  				}.New(), rmeta.STLvector, rmeta.Object),
  1077  				rdict.NewCxxStreamerSTL(rdict.Element{
  1078  					Name:   *rbase.NewNamed("stdVecNamed2", ""),
  1079  					Type:   rmeta.Streamer,
  1080  					Size:   24,
  1081  					MaxIdx: [5]int32{0, 0, 0, 0, 0},
  1082  					EName:  "vector<TNamed>",
  1083  				}.New(), rmeta.STLvector, rmeta.TNamed),
  1084  
  1085  				// obj-ptr
  1086  				&rdict.StreamerObjectPointer{
  1087  					StreamerElement: rdict.Element{
  1088  						Name:  *rbase.NewNamed("ptrObj", ""),
  1089  						Type:  rmeta.ObjectP,
  1090  						Size:  8,
  1091  						EName: "TObject*",
  1092  					}.New(),
  1093  				},
  1094  				&rdict.StreamerObjectAnyPointer{
  1095  					StreamerElement: rdict.Element{
  1096  						Name:  *rbase.NewNamed("ptrPos1", ""),
  1097  						Type:  rmeta.AnyP,
  1098  						Size:  8,
  1099  						EName: "TypeFromSI_Pos1*",
  1100  					}.New(),
  1101  				},
  1102  				&rdict.StreamerObjectAnyPointer{
  1103  					StreamerElement: rdict.Element{
  1104  						Name:  *rbase.NewNamed("ptrPos2", ""),
  1105  						Type:  rmeta.AnyP,
  1106  						Size:  8,
  1107  						EName: "TypeFromSI_Pos2*",
  1108  					}.New(),
  1109  				},
  1110  				&rdict.StreamerObjectAnyPointer{
  1111  					StreamerElement: rdict.Element{
  1112  						Name:  *rbase.NewNamed("ptrArrF", ""),
  1113  						Type:  rmeta.AnyP,
  1114  						Size:  8,
  1115  						EName: "TArrayF*",
  1116  					}.New(),
  1117  				},
  1118  			}),
  1119  			want: reflect.TypeOf((*struct {
  1120  				ROOT_TObject rbase.Object  `groot:"TObject"`
  1121  				ROOT_b       bool          `groot:"b"`
  1122  				ROOT_i8      int8          `groot:"i8"`
  1123  				ROOT_i16     int16         `groot:"i16"`
  1124  				ROOT_i32     int32         `groot:"i32"`
  1125  				ROOT_i64     int64         `groot:"i64"`
  1126  				ROOT_u8      uint8         `groot:"u8"`
  1127  				ROOT_u16     uint16        `groot:"u16"`
  1128  				ROOT_u32     uint32        `groot:"u32"`
  1129  				ROOT_u64     uint64        `groot:"u64"`
  1130  				ROOT_N       int32         `groot:"N"`
  1131  				ROOT_NN      int64         `groot:"NN"`
  1132  				ROOT_bits    uint32        `groot:"bits"`
  1133  				ROOT_f32     float32       `groot:"f32"`
  1134  				ROOT_f64     float64       `groot:"f64"`
  1135  				ROOT_f16     root.Float16  `groot:"f16"`
  1136  				ROOT_d32     root.Double32 `groot:"d32"`
  1137  				ROOT_str     string        `groot:"str"`
  1138  				ROOT_cstr    string        `groot:"cstr"`
  1139  				// arrays
  1140  				ROOT_arrB    [3]bool          `groot:"arrB[3]"`
  1141  				ROOT_arrI8   [3]int8          `groot:"arrI8[3]"`
  1142  				ROOT_arrI16  [3]int16         `groot:"arrI16[3]"`
  1143  				ROOT_arrI32  [3]int32         `groot:"arrI32[3]"`
  1144  				ROOT_arrI64  [3]int64         `groot:"arrI64[3]"`
  1145  				ROOT_arrU8   [3]uint8         `groot:"arrU8[3]"`
  1146  				ROOT_arrU16  [3]uint16        `groot:"arrU16[3]"`
  1147  				ROOT_arrU32  [3]uint32        `groot:"arrU32[3]"`
  1148  				ROOT_arrU64  [3]uint64        `groot:"arrU64[3]"`
  1149  				ROOT_arrF32  [3]float32       `groot:"arrF32[3]"`
  1150  				ROOT_arrF64  [3]float64       `groot:"arrF64[3]"`
  1151  				ROOT_arrF16  [3]root.Float16  `groot:"arrF16[3]"`
  1152  				ROOT_arrD32  [3]root.Double32 `groot:"arrD32[3]"`
  1153  				ROOT_arrStr  [3]string        `groot:"arrStr[3]"`
  1154  				ROOT_arrCstr [3]string        `groot:"arrCstr[3]"`
  1155  				//	ROOT_arrN32  [3]int32         `groot:"arrN32[3]"`
  1156  				//	ROOT_arrN64  [3]int64         `groot:"arrN64[3]"`
  1157  				ROOT_arrTObj [3]rbase.Object `groot:"arrTObj[3]"`
  1158  
  1159  				// slices
  1160  				ROOT_sliB    []bool          `groot:"sliB[N]"`
  1161  				ROOT_sliI8   []int8          `groot:"sliI8[N]"`
  1162  				ROOT_sliI16  []int16         `groot:"sliI16[N]"`
  1163  				ROOT_sliI32  []int32         `groot:"sliI32[N]"`
  1164  				ROOT_sliI64  []int64         `groot:"sliI64[N]"`
  1165  				ROOT_sliU8   []uint8         `groot:"sliU8[N]"`
  1166  				ROOT_sliU16  []uint16        `groot:"sliU16[N]"`
  1167  				ROOT_sliU32  []uint32        `groot:"sliU32[N]"`
  1168  				ROOT_sliU64  []uint64        `groot:"sliU64[N]"`
  1169  				ROOT_sliF32  []float32       `groot:"sliF32[N]"`
  1170  				ROOT_sliF64  []float64       `groot:"sliF64[N]"`
  1171  				ROOT_sliF16  []root.Float16  `groot:"sliF16[N]"`
  1172  				ROOT_sliD32  []root.Double32 `groot:"sliD32[N]"`
  1173  				ROOT_sliStr  []string        `groot:"sliStr[N]"`
  1174  				ROOT_sliCstr []string        `groot:"sliCstr[N]"`
  1175  
  1176  				// std::vectors
  1177  				ROOT_stdVecB      []bool          `groot:"stdVecB"`
  1178  				ROOT_stdVecI8     []int8          `groot:"stdVecI8"`
  1179  				ROOT_stdVecI16    []int16         `groot:"stdVecI16"`
  1180  				ROOT_stdVecI32    []int32         `groot:"stdVecI32"`
  1181  				ROOT_stdVecI64    []int64         `groot:"stdVecI64"`
  1182  				ROOT_stdVecU8     []uint8         `groot:"stdVecU8"`
  1183  				ROOT_stdVecU16    []uint16        `groot:"stdVecU16"`
  1184  				ROOT_stdVecU32    []uint32        `groot:"stdVecU32"`
  1185  				ROOT_stdVecU64    []uint64        `groot:"stdVecU64"`
  1186  				ROOT_stdVecF32    []float32       `groot:"stdVecF32"`
  1187  				ROOT_stdVecF64    []float64       `groot:"stdVecF64"`
  1188  				ROOT_stdVecF16    []root.Float16  `groot:"stdVecF16"`
  1189  				ROOT_stdVecD32    []root.Double32 `groot:"stdVecD32"`
  1190  				ROOT_stdVecStr    []string        `groot:"stdVecStr"`
  1191  				ROOT_stdVecCstr   []string        `groot:"stdVecCstr"`
  1192  				ROOT_stdVecNamed1 []rbase.Named   `groot:"stdVecNamed1"`
  1193  				ROOT_stdVecNamed2 []rbase.Named   `groot:"stdVecNamed2"`
  1194  
  1195  				// obj-ptr
  1196  				ROOT_ptrObj  *rbase.Object `groot:"ptrObj"`
  1197  				ROOT_ptrPos1 *struct {
  1198  					ROOT_px float32 `groot:"px"`
  1199  					ROOT_py float64 `groot:"py"`
  1200  				} `groot:"ptrPos1"`
  1201  				ROOT_ptrPos2 *TypeFromSI_Pos2 `groot:"ptrPos2"`
  1202  				ROOT_ptrArrF *rcont.ArrayF    `groot:"ptrArrF"`
  1203  			})(nil)).Elem(),
  1204  		},
  1205  		{
  1206  			name: "event-ndim",
  1207  			si: rdict.NewCxxStreamerInfo("event", 1, 0, []rbytes.StreamerElement{
  1208  				// arrays
  1209  				&rdict.StreamerBasicType{
  1210  					StreamerElement: rdict.Element{
  1211  						Name:   *rbase.NewNamed("arrB", ""),
  1212  						Type:   rmeta.OffsetL + rmeta.Bool,
  1213  						Size:   2 * 3 * 4 * 5 * 1,
  1214  						ArrLen: 2 * 3 * 4 * 5,
  1215  						ArrDim: 4,
  1216  						MaxIdx: [5]int32{2, 3, 4, 5, 0},
  1217  						EName:  "bool*",
  1218  					}.New(),
  1219  				},
  1220  				&rdict.StreamerBasicType{
  1221  					StreamerElement: rdict.Element{
  1222  						Name:   *rbase.NewNamed("arrI8", ""),
  1223  						Type:   rmeta.OffsetL + rmeta.Int8,
  1224  						Size:   2 * 3 * 4 * 5 * 1,
  1225  						ArrLen: 2 * 3 * 4 * 5,
  1226  						ArrDim: 4,
  1227  						MaxIdx: [5]int32{2, 3, 4, 5, 0},
  1228  						EName:  "int8_t*",
  1229  					}.New(),
  1230  				},
  1231  				&rdict.StreamerBasicType{
  1232  					StreamerElement: rdict.Element{
  1233  						Name:   *rbase.NewNamed("arrI16", ""),
  1234  						Type:   rmeta.OffsetL + rmeta.Int16,
  1235  						Size:   2 * 3 * 4 * 5 * 2,
  1236  						ArrLen: 2 * 3 * 4 * 5,
  1237  						ArrDim: 4,
  1238  						MaxIdx: [5]int32{2, 3, 4, 5, 0},
  1239  						EName:  "int16_t*",
  1240  					}.New(),
  1241  				},
  1242  				&rdict.StreamerBasicType{
  1243  					StreamerElement: rdict.Element{
  1244  						Name:   *rbase.NewNamed("arrI32", ""),
  1245  						Type:   rmeta.OffsetL + rmeta.Int32,
  1246  						Size:   2 * 3 * 4 * 5 * 4,
  1247  						ArrLen: 2 * 3 * 4 * 5,
  1248  						ArrDim: 4,
  1249  						MaxIdx: [5]int32{2, 3, 4, 5, 0},
  1250  						EName:  "int32_t*",
  1251  					}.New(),
  1252  				},
  1253  				&rdict.StreamerBasicType{
  1254  					StreamerElement: rdict.Element{
  1255  						Name:   *rbase.NewNamed("arrI64", ""),
  1256  						Type:   rmeta.OffsetL + rmeta.Int64,
  1257  						Size:   2 * 3 * 4 * 5 * 8,
  1258  						ArrLen: 2 * 3 * 4 * 5,
  1259  						ArrDim: 4,
  1260  						MaxIdx: [5]int32{2, 3, 4, 5, 0},
  1261  						EName:  "int64_t*",
  1262  					}.New(),
  1263  				},
  1264  				&rdict.StreamerBasicType{
  1265  					StreamerElement: rdict.Element{
  1266  						Name:   *rbase.NewNamed("arrU8", ""),
  1267  						Type:   rmeta.OffsetL + rmeta.Uint8,
  1268  						Size:   2 * 3 * 4 * 5 * 1,
  1269  						ArrLen: 2 * 3 * 4 * 5,
  1270  						ArrDim: 4,
  1271  						MaxIdx: [5]int32{2, 3, 4, 5, 0},
  1272  						EName:  "uint8_t*",
  1273  					}.New(),
  1274  				},
  1275  				&rdict.StreamerBasicType{
  1276  					StreamerElement: rdict.Element{
  1277  						Name:   *rbase.NewNamed("arrU16", ""),
  1278  						Type:   rmeta.OffsetL + rmeta.Uint16,
  1279  						Size:   2 * 3 * 4 * 5 * 2,
  1280  						ArrLen: 2 * 3 * 4 * 5,
  1281  						ArrDim: 4,
  1282  						MaxIdx: [5]int32{2, 3, 4, 5, 0},
  1283  						EName:  "uint16_t*",
  1284  					}.New(),
  1285  				},
  1286  				&rdict.StreamerBasicType{
  1287  					StreamerElement: rdict.Element{
  1288  						Name:   *rbase.NewNamed("arrU32", ""),
  1289  						Type:   rmeta.OffsetL + rmeta.Uint32,
  1290  						Size:   2 * 3 * 4 * 5 * 4,
  1291  						ArrLen: 2 * 3 * 4 * 5,
  1292  						ArrDim: 4,
  1293  						MaxIdx: [5]int32{2, 3, 4, 5, 0},
  1294  						EName:  "uint32_t*",
  1295  					}.New(),
  1296  				},
  1297  				&rdict.StreamerBasicType{
  1298  					StreamerElement: rdict.Element{
  1299  						Name:   *rbase.NewNamed("arrU64", ""),
  1300  						Type:   rmeta.OffsetL + rmeta.Uint64,
  1301  						Size:   2 * 3 * 4 * 5 * 8,
  1302  						ArrLen: 2 * 3 * 4 * 5,
  1303  						ArrDim: 4,
  1304  						MaxIdx: [5]int32{2, 3, 4, 5, 0},
  1305  						EName:  "uint64_t*",
  1306  					}.New(),
  1307  				},
  1308  				&rdict.StreamerBasicType{
  1309  					StreamerElement: rdict.Element{
  1310  						Name:   *rbase.NewNamed("arrF32", ""),
  1311  						Type:   rmeta.OffsetL + rmeta.Float32,
  1312  						Size:   2 * 3 * 4 * 5 * 4,
  1313  						ArrLen: 2 * 3 * 4 * 5,
  1314  						ArrDim: 4,
  1315  						MaxIdx: [5]int32{2, 3, 4, 5, 0},
  1316  						EName:  "float32_t*",
  1317  					}.New(),
  1318  				},
  1319  				&rdict.StreamerBasicType{
  1320  					StreamerElement: rdict.Element{
  1321  						Name:   *rbase.NewNamed("arrF64", ""),
  1322  						Type:   rmeta.OffsetL + rmeta.Float64,
  1323  						Size:   2 * 3 * 4 * 5 * 8,
  1324  						ArrLen: 2 * 3 * 4 * 5,
  1325  						ArrDim: 4,
  1326  						MaxIdx: [5]int32{2, 3, 4, 5, 0},
  1327  						EName:  "float64_t*",
  1328  					}.New(),
  1329  				},
  1330  				&rdict.StreamerBasicType{
  1331  					StreamerElement: rdict.Element{
  1332  						Name:   *rbase.NewNamed("arrF16", ""),
  1333  						Type:   rmeta.OffsetL + rmeta.Float16,
  1334  						Size:   2 * 3 * 4 * 5 * 4,
  1335  						ArrLen: 2 * 3 * 4 * 5,
  1336  						ArrDim: 4,
  1337  						MaxIdx: [5]int32{2, 3, 4, 5, 0},
  1338  						EName:  "Float16_t*",
  1339  					}.New(),
  1340  				},
  1341  				&rdict.StreamerBasicType{
  1342  					StreamerElement: rdict.Element{
  1343  						Name:   *rbase.NewNamed("arrD32", ""),
  1344  						Type:   rmeta.OffsetL + rmeta.Double32,
  1345  						Size:   2 * 3 * 4 * 5 * 4,
  1346  						ArrLen: 2 * 3 * 4 * 5,
  1347  						ArrDim: 4,
  1348  						MaxIdx: [5]int32{2, 3, 4, 5, 0},
  1349  						EName:  "Double32_t*",
  1350  					}.New(),
  1351  				},
  1352  				&rdict.StreamerBasicType{
  1353  					StreamerElement: rdict.Element{
  1354  						Name:   *rbase.NewNamed("arrStr", ""),
  1355  						Type:   rmeta.OffsetL + rmeta.TString,
  1356  						Size:   2 * 3 * 4 * 5 * 24,
  1357  						ArrLen: 2 * 3 * 4 * 5,
  1358  						ArrDim: 4,
  1359  						MaxIdx: [5]int32{2, 3, 4, 5, 0},
  1360  						EName:  "TString*",
  1361  					}.New(),
  1362  				},
  1363  				&rdict.StreamerBasicType{
  1364  					StreamerElement: rdict.Element{
  1365  						Name:   *rbase.NewNamed("arrCstr", ""),
  1366  						Type:   rmeta.OffsetL + rmeta.CharStar,
  1367  						Size:   2 * 3 * 4 * 5 * 8,
  1368  						ArrLen: 2 * 3 * 4 * 5,
  1369  						ArrDim: 4,
  1370  						MaxIdx: [5]int32{2, 3, 4, 5, 0},
  1371  						EName:  "char**",
  1372  					}.New(),
  1373  				},
  1374  			}),
  1375  			want: reflect.TypeOf((*struct {
  1376  				ROOT_arrB    [2][3][4][5]bool          `groot:"arrB[2][3][4][5]"`
  1377  				ROOT_arrI8   [2][3][4][5]int8          `groot:"arrI8[2][3][4][5]"`
  1378  				ROOT_arrI16  [2][3][4][5]int16         `groot:"arrI16[2][3][4][5]"`
  1379  				ROOT_arrI32  [2][3][4][5]int32         `groot:"arrI32[2][3][4][5]"`
  1380  				ROOT_arrI64  [2][3][4][5]int64         `groot:"arrI64[2][3][4][5]"`
  1381  				ROOT_arrU8   [2][3][4][5]uint8         `groot:"arrU8[2][3][4][5]"`
  1382  				ROOT_arrU16  [2][3][4][5]uint16        `groot:"arrU16[2][3][4][5]"`
  1383  				ROOT_arrU32  [2][3][4][5]uint32        `groot:"arrU32[2][3][4][5]"`
  1384  				ROOT_arrU64  [2][3][4][5]uint64        `groot:"arrU64[2][3][4][5]"`
  1385  				ROOT_arrF32  [2][3][4][5]float32       `groot:"arrF32[2][3][4][5]"`
  1386  				ROOT_arrF64  [2][3][4][5]float64       `groot:"arrF64[2][3][4][5]"`
  1387  				ROOT_arrF16  [2][3][4][5]root.Float16  `groot:"arrF16[2][3][4][5]"`
  1388  				ROOT_arrD32  [2][3][4][5]root.Double32 `groot:"arrD32[2][3][4][5]"`
  1389  				ROOT_arrStr  [2][3][4][5]string        `groot:"arrStr[2][3][4][5]"`
  1390  				ROOT_arrCstr [2][3][4][5]string        `groot:"arrCstr[2][3][4][5]"`
  1391  			})(nil)).Elem(),
  1392  		},
  1393  	} {
  1394  		t.Run(tc.name, func(t *testing.T) {
  1395  			err := tc.si.BuildStreamers()
  1396  			if err != nil {
  1397  				t.Fatalf("could not build streamers: %+v", err)
  1398  			}
  1399  
  1400  			got, err := rdict.TypeFromSI(rdict.StreamerInfos, tc.si)
  1401  			if err != nil {
  1402  				t.Fatalf("could not load type: %+v", err)
  1403  			}
  1404  
  1405  			if got != tc.want {
  1406  				t.Fatalf("invalid Go type:\ngot= %T\nwant=%T",
  1407  					reflect.New(got).Elem().Interface(),
  1408  					reflect.New(tc.want).Elem().Interface(),
  1409  				)
  1410  			}
  1411  		})
  1412  	}
  1413  }