go-hep.org/x/hep@v0.38.1/groot/rbytes/rbuffer_gen.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  // Automatically generated. DO NOT EDIT.
     6  
     7  package rbytes
     8  
     9  import (
    10  	"encoding/binary"
    11  	"fmt"
    12  	"math"
    13  
    14  	"go-hep.org/x/hep/groot/rvers"
    15  )
    16  
    17  func (r *RBuffer) ReadArrayU16(sli []uint16) {
    18  	if r.err != nil {
    19  		return
    20  	}
    21  	n := len(sli)
    22  	if n <= 0 || int64(n) > r.Len() {
    23  		return
    24  	}
    25  
    26  	cur := r.r.c
    27  	end := r.r.c + 2*len(sli)
    28  	sub := r.r.p[cur:end]
    29  	cur = 0
    30  	for i := range sli {
    31  		beg := cur
    32  		end := cur + 2
    33  		cur = end
    34  		v := binary.BigEndian.Uint16(sub[beg:end])
    35  		sli[i] = v
    36  
    37  	}
    38  	r.r.c = end
    39  }
    40  
    41  func (r *RBuffer) ReadU16() uint16 {
    42  	if r.err != nil {
    43  		return 0
    44  	}
    45  	beg := r.r.c
    46  	r.r.c += 2
    47  	v := binary.BigEndian.Uint16(r.r.p[beg:r.r.c])
    48  	return v
    49  
    50  }
    51  
    52  func (r *RBuffer) ReadStdVectorU16(sli *[]uint16) {
    53  	if r.err != nil {
    54  		return
    55  	}
    56  
    57  	hdr := r.ReadHeader("vector<uint16>", rvers.StreamerBaseSTL)
    58  	if hdr.Vers > rvers.StreamerBaseSTL {
    59  		r.err = fmt.Errorf(
    60  			"rbytes: invalid %s version: got=%d, want=%d",
    61  			hdr.Name, hdr.Vers, rvers.StreamerBaseSTL,
    62  		)
    63  		return
    64  	}
    65  	n := int(r.ReadI32())
    66  	*sli = ResizeU16(*sli, n)
    67  	for i := range *sli {
    68  		(*sli)[i] = r.ReadU16()
    69  	}
    70  
    71  	r.CheckHeader(hdr)
    72  }
    73  
    74  func (r *RBuffer) ReadArrayU32(sli []uint32) {
    75  	if r.err != nil {
    76  		return
    77  	}
    78  	n := len(sli)
    79  	if n <= 0 || int64(n) > r.Len() {
    80  		return
    81  	}
    82  
    83  	cur := r.r.c
    84  	end := r.r.c + 4*len(sli)
    85  	sub := r.r.p[cur:end]
    86  	cur = 0
    87  	for i := range sli {
    88  		beg := cur
    89  		end := cur + 4
    90  		cur = end
    91  		v := binary.BigEndian.Uint32(sub[beg:end])
    92  		sli[i] = v
    93  
    94  	}
    95  	r.r.c = end
    96  }
    97  
    98  func (r *RBuffer) ReadU32() uint32 {
    99  	if r.err != nil {
   100  		return 0
   101  	}
   102  	beg := r.r.c
   103  	r.r.c += 4
   104  	v := binary.BigEndian.Uint32(r.r.p[beg:r.r.c])
   105  	return v
   106  
   107  }
   108  
   109  func (r *RBuffer) ReadStdVectorU32(sli *[]uint32) {
   110  	if r.err != nil {
   111  		return
   112  	}
   113  
   114  	hdr := r.ReadHeader("vector<uint32>", rvers.StreamerBaseSTL)
   115  	if hdr.Vers > rvers.StreamerBaseSTL {
   116  		r.err = fmt.Errorf(
   117  			"rbytes: invalid %s version: got=%d, want=%d",
   118  			hdr.Name, hdr.Vers, rvers.StreamerBaseSTL,
   119  		)
   120  		return
   121  	}
   122  	n := int(r.ReadI32())
   123  	*sli = ResizeU32(*sli, n)
   124  	for i := range *sli {
   125  		(*sli)[i] = r.ReadU32()
   126  	}
   127  
   128  	r.CheckHeader(hdr)
   129  }
   130  
   131  func (r *RBuffer) ReadArrayU64(sli []uint64) {
   132  	if r.err != nil {
   133  		return
   134  	}
   135  	n := len(sli)
   136  	if n <= 0 || int64(n) > r.Len() {
   137  		return
   138  	}
   139  
   140  	cur := r.r.c
   141  	end := r.r.c + 8*len(sli)
   142  	sub := r.r.p[cur:end]
   143  	cur = 0
   144  	for i := range sli {
   145  		beg := cur
   146  		end := cur + 8
   147  		cur = end
   148  		v := binary.BigEndian.Uint64(sub[beg:end])
   149  		sli[i] = v
   150  
   151  	}
   152  	r.r.c = end
   153  }
   154  
   155  func (r *RBuffer) ReadU64() uint64 {
   156  	if r.err != nil {
   157  		return 0
   158  	}
   159  	beg := r.r.c
   160  	r.r.c += 8
   161  	v := binary.BigEndian.Uint64(r.r.p[beg:r.r.c])
   162  	return v
   163  
   164  }
   165  
   166  func (r *RBuffer) ReadStdVectorU64(sli *[]uint64) {
   167  	if r.err != nil {
   168  		return
   169  	}
   170  
   171  	hdr := r.ReadHeader("vector<uint64>", rvers.StreamerBaseSTL)
   172  	if hdr.Vers > rvers.StreamerBaseSTL {
   173  		r.err = fmt.Errorf(
   174  			"rbytes: invalid %s version: got=%d, want=%d",
   175  			hdr.Name, hdr.Vers, rvers.StreamerBaseSTL,
   176  		)
   177  		return
   178  	}
   179  	n := int(r.ReadI32())
   180  	*sli = ResizeU64(*sli, n)
   181  	for i := range *sli {
   182  		(*sli)[i] = r.ReadU64()
   183  	}
   184  
   185  	r.CheckHeader(hdr)
   186  }
   187  
   188  func (r *RBuffer) ReadArrayI16(sli []int16) {
   189  	if r.err != nil {
   190  		return
   191  	}
   192  	n := len(sli)
   193  	if n <= 0 || int64(n) > r.Len() {
   194  		return
   195  	}
   196  
   197  	cur := r.r.c
   198  	end := r.r.c + 2*len(sli)
   199  	sub := r.r.p[cur:end]
   200  	cur = 0
   201  	for i := range sli {
   202  		beg := cur
   203  		end := cur + 2
   204  		cur = end
   205  		v := binary.BigEndian.Uint16(sub[beg:end])
   206  		sli[i] = int16(v)
   207  	}
   208  	r.r.c = end
   209  }
   210  
   211  func (r *RBuffer) ReadI16() int16 {
   212  	if r.err != nil {
   213  		return 0
   214  	}
   215  	beg := r.r.c
   216  	r.r.c += 2
   217  	v := binary.BigEndian.Uint16(r.r.p[beg:r.r.c])
   218  	return int16(v)
   219  }
   220  
   221  func (r *RBuffer) ReadStdVectorI16(sli *[]int16) {
   222  	if r.err != nil {
   223  		return
   224  	}
   225  
   226  	hdr := r.ReadHeader("vector<int16>", rvers.StreamerBaseSTL)
   227  	if hdr.Vers > rvers.StreamerBaseSTL {
   228  		r.err = fmt.Errorf(
   229  			"rbytes: invalid %s version: got=%d, want=%d",
   230  			hdr.Name, hdr.Vers, rvers.StreamerBaseSTL,
   231  		)
   232  		return
   233  	}
   234  	n := int(r.ReadI32())
   235  	*sli = ResizeI16(*sli, n)
   236  	for i := range *sli {
   237  		(*sli)[i] = r.ReadI16()
   238  	}
   239  
   240  	r.CheckHeader(hdr)
   241  }
   242  
   243  func (r *RBuffer) ReadArrayI32(sli []int32) {
   244  	if r.err != nil {
   245  		return
   246  	}
   247  	n := len(sli)
   248  	if n <= 0 || int64(n) > r.Len() {
   249  		return
   250  	}
   251  
   252  	cur := r.r.c
   253  	end := r.r.c + 4*len(sli)
   254  	sub := r.r.p[cur:end]
   255  	cur = 0
   256  	for i := range sli {
   257  		beg := cur
   258  		end := cur + 4
   259  		cur = end
   260  		v := binary.BigEndian.Uint32(sub[beg:end])
   261  		sli[i] = int32(v)
   262  	}
   263  	r.r.c = end
   264  }
   265  
   266  func (r *RBuffer) ReadI32() int32 {
   267  	if r.err != nil {
   268  		return 0
   269  	}
   270  	beg := r.r.c
   271  	r.r.c += 4
   272  	v := binary.BigEndian.Uint32(r.r.p[beg:r.r.c])
   273  	return int32(v)
   274  }
   275  
   276  func (r *RBuffer) ReadStdVectorI32(sli *[]int32) {
   277  	if r.err != nil {
   278  		return
   279  	}
   280  
   281  	hdr := r.ReadHeader("vector<int32>", rvers.StreamerBaseSTL)
   282  	if hdr.Vers > rvers.StreamerBaseSTL {
   283  		r.err = fmt.Errorf(
   284  			"rbytes: invalid %s version: got=%d, want=%d",
   285  			hdr.Name, hdr.Vers, rvers.StreamerBaseSTL,
   286  		)
   287  		return
   288  	}
   289  	n := int(r.ReadI32())
   290  	*sli = ResizeI32(*sli, n)
   291  	for i := range *sli {
   292  		(*sli)[i] = r.ReadI32()
   293  	}
   294  
   295  	r.CheckHeader(hdr)
   296  }
   297  
   298  func (r *RBuffer) ReadArrayI64(sli []int64) {
   299  	if r.err != nil {
   300  		return
   301  	}
   302  	n := len(sli)
   303  	if n <= 0 || int64(n) > r.Len() {
   304  		return
   305  	}
   306  
   307  	cur := r.r.c
   308  	end := r.r.c + 8*len(sli)
   309  	sub := r.r.p[cur:end]
   310  	cur = 0
   311  	for i := range sli {
   312  		beg := cur
   313  		end := cur + 8
   314  		cur = end
   315  		v := binary.BigEndian.Uint64(sub[beg:end])
   316  		sli[i] = int64(v)
   317  	}
   318  	r.r.c = end
   319  }
   320  
   321  func (r *RBuffer) ReadI64() int64 {
   322  	if r.err != nil {
   323  		return 0
   324  	}
   325  	beg := r.r.c
   326  	r.r.c += 8
   327  	v := binary.BigEndian.Uint64(r.r.p[beg:r.r.c])
   328  	return int64(v)
   329  }
   330  
   331  func (r *RBuffer) ReadStdVectorI64(sli *[]int64) {
   332  	if r.err != nil {
   333  		return
   334  	}
   335  
   336  	hdr := r.ReadHeader("vector<int64>", rvers.StreamerBaseSTL)
   337  	if hdr.Vers > rvers.StreamerBaseSTL {
   338  		r.err = fmt.Errorf(
   339  			"rbytes: invalid %s version: got=%d, want=%d",
   340  			hdr.Name, hdr.Vers, rvers.StreamerBaseSTL,
   341  		)
   342  		return
   343  	}
   344  	n := int(r.ReadI32())
   345  	*sli = ResizeI64(*sli, n)
   346  	for i := range *sli {
   347  		(*sli)[i] = r.ReadI64()
   348  	}
   349  
   350  	r.CheckHeader(hdr)
   351  }
   352  
   353  func (r *RBuffer) ReadArrayF32(sli []float32) {
   354  	if r.err != nil {
   355  		return
   356  	}
   357  	n := len(sli)
   358  	if n <= 0 || int64(n) > r.Len() {
   359  		return
   360  	}
   361  
   362  	cur := r.r.c
   363  	end := r.r.c + 4*len(sli)
   364  	sub := r.r.p[cur:end]
   365  	cur = 0
   366  	for i := range sli {
   367  		beg := cur
   368  		end := cur + 4
   369  		cur = end
   370  		v := binary.BigEndian.Uint32(sub[beg:end])
   371  		sli[i] = math.Float32frombits(v)
   372  	}
   373  	r.r.c = end
   374  }
   375  
   376  func (r *RBuffer) ReadF32() float32 {
   377  	if r.err != nil {
   378  		return 0
   379  	}
   380  	beg := r.r.c
   381  	r.r.c += 4
   382  	v := binary.BigEndian.Uint32(r.r.p[beg:r.r.c])
   383  	return math.Float32frombits(v)
   384  }
   385  
   386  func (r *RBuffer) ReadStdVectorF32(sli *[]float32) {
   387  	if r.err != nil {
   388  		return
   389  	}
   390  
   391  	hdr := r.ReadHeader("vector<float32>", rvers.StreamerBaseSTL)
   392  	if hdr.Vers > rvers.StreamerBaseSTL {
   393  		r.err = fmt.Errorf(
   394  			"rbytes: invalid %s version: got=%d, want=%d",
   395  			hdr.Name, hdr.Vers, rvers.StreamerBaseSTL,
   396  		)
   397  		return
   398  	}
   399  	n := int(r.ReadI32())
   400  	*sli = ResizeF32(*sli, n)
   401  	for i := range *sli {
   402  		(*sli)[i] = r.ReadF32()
   403  	}
   404  
   405  	r.CheckHeader(hdr)
   406  }
   407  
   408  func (r *RBuffer) ReadArrayF64(sli []float64) {
   409  	if r.err != nil {
   410  		return
   411  	}
   412  	n := len(sli)
   413  	if n <= 0 || int64(n) > r.Len() {
   414  		return
   415  	}
   416  
   417  	cur := r.r.c
   418  	end := r.r.c + 8*len(sli)
   419  	sub := r.r.p[cur:end]
   420  	cur = 0
   421  	for i := range sli {
   422  		beg := cur
   423  		end := cur + 8
   424  		cur = end
   425  		v := binary.BigEndian.Uint64(sub[beg:end])
   426  		sli[i] = math.Float64frombits(v)
   427  	}
   428  	r.r.c = end
   429  }
   430  
   431  func (r *RBuffer) ReadF64() float64 {
   432  	if r.err != nil {
   433  		return 0
   434  	}
   435  	beg := r.r.c
   436  	r.r.c += 8
   437  	v := binary.BigEndian.Uint64(r.r.p[beg:r.r.c])
   438  	return math.Float64frombits(v)
   439  }
   440  
   441  func (r *RBuffer) ReadStdVectorF64(sli *[]float64) {
   442  	if r.err != nil {
   443  		return
   444  	}
   445  
   446  	hdr := r.ReadHeader("vector<float64>", rvers.StreamerBaseSTL)
   447  	if hdr.Vers > rvers.StreamerBaseSTL {
   448  		r.err = fmt.Errorf(
   449  			"rbytes: invalid %s version: got=%d, want=%d",
   450  			hdr.Name, hdr.Vers, rvers.StreamerBaseSTL,
   451  		)
   452  		return
   453  	}
   454  	n := int(r.ReadI32())
   455  	*sli = ResizeF64(*sli, n)
   456  	for i := range *sli {
   457  		(*sli)[i] = r.ReadF64()
   458  	}
   459  
   460  	r.CheckHeader(hdr)
   461  }