go-hep.org/x/hep@v0.38.1/groot/rbytes/wbuffer_gen.go (about)

     1  // Copyright ©2022 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  	"math"
    12  
    13  	"go-hep.org/x/hep/groot/rvers"
    14  )
    15  
    16  func (w *WBuffer) WriteArrayU16(sli []uint16) {
    17  	if w.err != nil {
    18  		return
    19  	}
    20  	w.w.grow(len(sli) * 2)
    21  
    22  	cur := w.w.c
    23  	for _, v := range sli {
    24  		beg := cur
    25  		end := cur + 2
    26  		cur = end
    27  		binary.BigEndian.PutUint16(w.w.p[beg:end], v)
    28  
    29  	}
    30  	w.w.c += 2 * len(sli)
    31  }
    32  
    33  func (w *WBuffer) WriteU16(v uint16) {
    34  	if w.err != nil {
    35  		return
    36  	}
    37  	w.w.grow(2)
    38  	beg := w.w.c
    39  	end := w.w.c + 2
    40  	binary.BigEndian.PutUint16(w.w.p[beg:end], v)
    41  
    42  	w.w.c += 2
    43  }
    44  
    45  func (w *WBuffer) WriteStdVectorU16(sli []uint16) {
    46  	if w.err != nil {
    47  		return
    48  	}
    49  
    50  	hdr := w.WriteHeader("vector<uint16>", rvers.StreamerBaseSTL)
    51  	w.WriteI32(int32(len(sli)))
    52  	w.w.grow(len(sli) * 2)
    53  
    54  	cur := w.w.c
    55  	for _, v := range sli {
    56  		beg := cur
    57  		end := cur + 2
    58  		cur = end
    59  		binary.BigEndian.PutUint16(w.w.p[beg:end], v)
    60  
    61  	}
    62  	w.w.c += 2 * len(sli)
    63  
    64  	if w.err != nil {
    65  		return
    66  	}
    67  	_, w.err = w.SetHeader(hdr)
    68  }
    69  
    70  func (w *WBuffer) WriteArrayU32(sli []uint32) {
    71  	if w.err != nil {
    72  		return
    73  	}
    74  	w.w.grow(len(sli) * 4)
    75  
    76  	cur := w.w.c
    77  	for _, v := range sli {
    78  		beg := cur
    79  		end := cur + 4
    80  		cur = end
    81  		binary.BigEndian.PutUint32(w.w.p[beg:end], v)
    82  
    83  	}
    84  	w.w.c += 4 * len(sli)
    85  }
    86  
    87  func (w *WBuffer) WriteU32(v uint32) {
    88  	if w.err != nil {
    89  		return
    90  	}
    91  	w.w.grow(4)
    92  	beg := w.w.c
    93  	end := w.w.c + 4
    94  	binary.BigEndian.PutUint32(w.w.p[beg:end], v)
    95  
    96  	w.w.c += 4
    97  }
    98  
    99  func (w *WBuffer) WriteStdVectorU32(sli []uint32) {
   100  	if w.err != nil {
   101  		return
   102  	}
   103  
   104  	hdr := w.WriteHeader("vector<uint32>", rvers.StreamerBaseSTL)
   105  	w.WriteI32(int32(len(sli)))
   106  	w.w.grow(len(sli) * 4)
   107  
   108  	cur := w.w.c
   109  	for _, v := range sli {
   110  		beg := cur
   111  		end := cur + 4
   112  		cur = end
   113  		binary.BigEndian.PutUint32(w.w.p[beg:end], v)
   114  
   115  	}
   116  	w.w.c += 4 * len(sli)
   117  
   118  	if w.err != nil {
   119  		return
   120  	}
   121  	_, w.err = w.SetHeader(hdr)
   122  }
   123  
   124  func (w *WBuffer) WriteArrayU64(sli []uint64) {
   125  	if w.err != nil {
   126  		return
   127  	}
   128  	w.w.grow(len(sli) * 8)
   129  
   130  	cur := w.w.c
   131  	for _, v := range sli {
   132  		beg := cur
   133  		end := cur + 8
   134  		cur = end
   135  		binary.BigEndian.PutUint64(w.w.p[beg:end], v)
   136  
   137  	}
   138  	w.w.c += 8 * len(sli)
   139  }
   140  
   141  func (w *WBuffer) WriteU64(v uint64) {
   142  	if w.err != nil {
   143  		return
   144  	}
   145  	w.w.grow(8)
   146  	beg := w.w.c
   147  	end := w.w.c + 8
   148  	binary.BigEndian.PutUint64(w.w.p[beg:end], v)
   149  
   150  	w.w.c += 8
   151  }
   152  
   153  func (w *WBuffer) WriteStdVectorU64(sli []uint64) {
   154  	if w.err != nil {
   155  		return
   156  	}
   157  
   158  	hdr := w.WriteHeader("vector<uint64>", rvers.StreamerBaseSTL)
   159  	w.WriteI32(int32(len(sli)))
   160  	w.w.grow(len(sli) * 8)
   161  
   162  	cur := w.w.c
   163  	for _, v := range sli {
   164  		beg := cur
   165  		end := cur + 8
   166  		cur = end
   167  		binary.BigEndian.PutUint64(w.w.p[beg:end], v)
   168  
   169  	}
   170  	w.w.c += 8 * len(sli)
   171  
   172  	if w.err != nil {
   173  		return
   174  	}
   175  	_, w.err = w.SetHeader(hdr)
   176  }
   177  
   178  func (w *WBuffer) WriteArrayI16(sli []int16) {
   179  	if w.err != nil {
   180  		return
   181  	}
   182  	w.w.grow(len(sli) * 2)
   183  
   184  	cur := w.w.c
   185  	for _, v := range sli {
   186  		beg := cur
   187  		end := cur + 2
   188  		cur = end
   189  		binary.BigEndian.PutUint16(w.w.p[beg:end], uint16(v))
   190  	}
   191  	w.w.c += 2 * len(sli)
   192  }
   193  
   194  func (w *WBuffer) WriteI16(v int16) {
   195  	if w.err != nil {
   196  		return
   197  	}
   198  	w.w.grow(2)
   199  	beg := w.w.c
   200  	end := w.w.c + 2
   201  	binary.BigEndian.PutUint16(w.w.p[beg:end], uint16(v))
   202  	w.w.c += 2
   203  }
   204  
   205  func (w *WBuffer) WriteStdVectorI16(sli []int16) {
   206  	if w.err != nil {
   207  		return
   208  	}
   209  
   210  	hdr := w.WriteHeader("vector<int16>", rvers.StreamerBaseSTL)
   211  	w.WriteI32(int32(len(sli)))
   212  	w.w.grow(len(sli) * 2)
   213  
   214  	cur := w.w.c
   215  	for _, v := range sli {
   216  		beg := cur
   217  		end := cur + 2
   218  		cur = end
   219  		binary.BigEndian.PutUint16(w.w.p[beg:end], uint16(v))
   220  	}
   221  	w.w.c += 2 * len(sli)
   222  
   223  	if w.err != nil {
   224  		return
   225  	}
   226  	_, w.err = w.SetHeader(hdr)
   227  }
   228  
   229  func (w *WBuffer) WriteArrayI32(sli []int32) {
   230  	if w.err != nil {
   231  		return
   232  	}
   233  	w.w.grow(len(sli) * 4)
   234  
   235  	cur := w.w.c
   236  	for _, v := range sli {
   237  		beg := cur
   238  		end := cur + 4
   239  		cur = end
   240  		binary.BigEndian.PutUint32(w.w.p[beg:end], uint32(v))
   241  	}
   242  	w.w.c += 4 * len(sli)
   243  }
   244  
   245  func (w *WBuffer) WriteI32(v int32) {
   246  	if w.err != nil {
   247  		return
   248  	}
   249  	w.w.grow(4)
   250  	beg := w.w.c
   251  	end := w.w.c + 4
   252  	binary.BigEndian.PutUint32(w.w.p[beg:end], uint32(v))
   253  	w.w.c += 4
   254  }
   255  
   256  func (w *WBuffer) WriteStdVectorI32(sli []int32) {
   257  	if w.err != nil {
   258  		return
   259  	}
   260  
   261  	hdr := w.WriteHeader("vector<int32>", rvers.StreamerBaseSTL)
   262  	w.WriteI32(int32(len(sli)))
   263  	w.w.grow(len(sli) * 4)
   264  
   265  	cur := w.w.c
   266  	for _, v := range sli {
   267  		beg := cur
   268  		end := cur + 4
   269  		cur = end
   270  		binary.BigEndian.PutUint32(w.w.p[beg:end], uint32(v))
   271  	}
   272  	w.w.c += 4 * len(sli)
   273  
   274  	if w.err != nil {
   275  		return
   276  	}
   277  	_, w.err = w.SetHeader(hdr)
   278  }
   279  
   280  func (w *WBuffer) WriteArrayI64(sli []int64) {
   281  	if w.err != nil {
   282  		return
   283  	}
   284  	w.w.grow(len(sli) * 8)
   285  
   286  	cur := w.w.c
   287  	for _, v := range sli {
   288  		beg := cur
   289  		end := cur + 8
   290  		cur = end
   291  		binary.BigEndian.PutUint64(w.w.p[beg:end], uint64(v))
   292  	}
   293  	w.w.c += 8 * len(sli)
   294  }
   295  
   296  func (w *WBuffer) WriteI64(v int64) {
   297  	if w.err != nil {
   298  		return
   299  	}
   300  	w.w.grow(8)
   301  	beg := w.w.c
   302  	end := w.w.c + 8
   303  	binary.BigEndian.PutUint64(w.w.p[beg:end], uint64(v))
   304  	w.w.c += 8
   305  }
   306  
   307  func (w *WBuffer) WriteStdVectorI64(sli []int64) {
   308  	if w.err != nil {
   309  		return
   310  	}
   311  
   312  	hdr := w.WriteHeader("vector<int64>", rvers.StreamerBaseSTL)
   313  	w.WriteI32(int32(len(sli)))
   314  	w.w.grow(len(sli) * 8)
   315  
   316  	cur := w.w.c
   317  	for _, v := range sli {
   318  		beg := cur
   319  		end := cur + 8
   320  		cur = end
   321  		binary.BigEndian.PutUint64(w.w.p[beg:end], uint64(v))
   322  	}
   323  	w.w.c += 8 * len(sli)
   324  
   325  	if w.err != nil {
   326  		return
   327  	}
   328  	_, w.err = w.SetHeader(hdr)
   329  }
   330  
   331  func (w *WBuffer) WriteArrayF32(sli []float32) {
   332  	if w.err != nil {
   333  		return
   334  	}
   335  	w.w.grow(len(sli) * 4)
   336  
   337  	cur := w.w.c
   338  	for _, v := range sli {
   339  		beg := cur
   340  		end := cur + 4
   341  		cur = end
   342  		binary.BigEndian.PutUint32(w.w.p[beg:end], math.Float32bits(v))
   343  	}
   344  	w.w.c += 4 * len(sli)
   345  }
   346  
   347  func (w *WBuffer) WriteF32(v float32) {
   348  	if w.err != nil {
   349  		return
   350  	}
   351  	w.w.grow(4)
   352  	beg := w.w.c
   353  	end := w.w.c + 4
   354  	binary.BigEndian.PutUint32(w.w.p[beg:end], math.Float32bits(v))
   355  	w.w.c += 4
   356  }
   357  
   358  func (w *WBuffer) WriteStdVectorF32(sli []float32) {
   359  	if w.err != nil {
   360  		return
   361  	}
   362  
   363  	hdr := w.WriteHeader("vector<float32>", rvers.StreamerBaseSTL)
   364  	w.WriteI32(int32(len(sli)))
   365  	w.w.grow(len(sli) * 4)
   366  
   367  	cur := w.w.c
   368  	for _, v := range sli {
   369  		beg := cur
   370  		end := cur + 4
   371  		cur = end
   372  		binary.BigEndian.PutUint32(w.w.p[beg:end], math.Float32bits(v))
   373  	}
   374  	w.w.c += 4 * len(sli)
   375  
   376  	if w.err != nil {
   377  		return
   378  	}
   379  	_, w.err = w.SetHeader(hdr)
   380  }
   381  
   382  func (w *WBuffer) WriteArrayF64(sli []float64) {
   383  	if w.err != nil {
   384  		return
   385  	}
   386  	w.w.grow(len(sli) * 8)
   387  
   388  	cur := w.w.c
   389  	for _, v := range sli {
   390  		beg := cur
   391  		end := cur + 8
   392  		cur = end
   393  		binary.BigEndian.PutUint64(w.w.p[beg:end], math.Float64bits(v))
   394  	}
   395  	w.w.c += 8 * len(sli)
   396  }
   397  
   398  func (w *WBuffer) WriteF64(v float64) {
   399  	if w.err != nil {
   400  		return
   401  	}
   402  	w.w.grow(8)
   403  	beg := w.w.c
   404  	end := w.w.c + 8
   405  	binary.BigEndian.PutUint64(w.w.p[beg:end], math.Float64bits(v))
   406  	w.w.c += 8
   407  }
   408  
   409  func (w *WBuffer) WriteStdVectorF64(sli []float64) {
   410  	if w.err != nil {
   411  		return
   412  	}
   413  
   414  	hdr := w.WriteHeader("vector<float64>", rvers.StreamerBaseSTL)
   415  	w.WriteI32(int32(len(sli)))
   416  	w.w.grow(len(sli) * 8)
   417  
   418  	cur := w.w.c
   419  	for _, v := range sli {
   420  		beg := cur
   421  		end := cur + 8
   422  		cur = end
   423  		binary.BigEndian.PutUint64(w.w.p[beg:end], math.Float64bits(v))
   424  	}
   425  	w.w.c += 8 * len(sli)
   426  
   427  	if w.err != nil {
   428  		return
   429  	}
   430  	_, w.err = w.SetHeader(hdr)
   431  }