go-hep.org/x/hep@v0.38.1/hbook/binning_brio.go (about)

     1  // Code generated by brio-gen; DO NOT EDIT.
     2  
     3  package hbook
     4  
     5  import (
     6  	"encoding/binary"
     7  	"math"
     8  )
     9  
    10  // MarshalBinary implements encoding.BinaryMarshaler
    11  func (o *Range) MarshalBinary() (data []byte, err error) {
    12  	var buf [8]byte
    13  	binary.LittleEndian.PutUint64(buf[:8], math.Float64bits(o.Min))
    14  	data = append(data, buf[:8]...)
    15  	binary.LittleEndian.PutUint64(buf[:8], math.Float64bits(o.Max))
    16  	data = append(data, buf[:8]...)
    17  	return data, err
    18  }
    19  
    20  // UnmarshalBinary implements encoding.BinaryUnmarshaler
    21  func (o *Range) UnmarshalBinary(data []byte) (err error) {
    22  	o.Min = float64(math.Float64frombits(binary.LittleEndian.Uint64(data[:8])))
    23  	data = data[8:]
    24  	o.Max = float64(math.Float64frombits(binary.LittleEndian.Uint64(data[:8])))
    25  	data = data[8:]
    26  	_ = data
    27  	return err
    28  }
    29  
    30  // MarshalBinary implements encoding.BinaryMarshaler
    31  func (o *Binning1D) MarshalBinary() (data []byte, err error) {
    32  	var buf [8]byte
    33  	binary.LittleEndian.PutUint64(buf[:8], uint64(len(o.Bins)))
    34  	data = append(data, buf[:8]...)
    35  	for i := range o.Bins {
    36  		o := &o.Bins[i]
    37  		{
    38  			sub, err := o.MarshalBinary()
    39  			if err != nil {
    40  				return nil, err
    41  			}
    42  			binary.LittleEndian.PutUint64(buf[:8], uint64(len(sub)))
    43  			data = append(data, buf[:8]...)
    44  			data = append(data, sub...)
    45  		}
    46  	}
    47  	{
    48  		sub, err := o.Dist.MarshalBinary()
    49  		if err != nil {
    50  			return nil, err
    51  		}
    52  		binary.LittleEndian.PutUint64(buf[:8], uint64(len(sub)))
    53  		data = append(data, buf[:8]...)
    54  		data = append(data, sub...)
    55  	}
    56  	for i := range o.Outflows {
    57  		o := &o.Outflows[i]
    58  		{
    59  			sub, err := o.MarshalBinary()
    60  			if err != nil {
    61  				return nil, err
    62  			}
    63  			binary.LittleEndian.PutUint64(buf[:8], uint64(len(sub)))
    64  			data = append(data, buf[:8]...)
    65  			data = append(data, sub...)
    66  		}
    67  	}
    68  	{
    69  		sub, err := o.XRange.MarshalBinary()
    70  		if err != nil {
    71  			return nil, err
    72  		}
    73  		binary.LittleEndian.PutUint64(buf[:8], uint64(len(sub)))
    74  		data = append(data, buf[:8]...)
    75  		data = append(data, sub...)
    76  	}
    77  	return data, err
    78  }
    79  
    80  // UnmarshalBinary implements encoding.BinaryUnmarshaler
    81  func (o *Binning1D) UnmarshalBinary(data []byte) (err error) {
    82  	{
    83  		n := int(binary.LittleEndian.Uint64(data[:8]))
    84  		o.Bins = make([]Bin1D, n)
    85  		data = data[8:]
    86  		for i := range o.Bins {
    87  			oi := &o.Bins[i]
    88  			{
    89  				n := int(binary.LittleEndian.Uint64(data[:8]))
    90  				data = data[8:]
    91  				err = oi.UnmarshalBinary(data[:n])
    92  				if err != nil {
    93  					return err
    94  				}
    95  				data = data[n:]
    96  			}
    97  		}
    98  	}
    99  	{
   100  		n := int(binary.LittleEndian.Uint64(data[:8]))
   101  		data = data[8:]
   102  		err = o.Dist.UnmarshalBinary(data[:n])
   103  		if err != nil {
   104  			return err
   105  		}
   106  		data = data[n:]
   107  	}
   108  	for i := range o.Outflows {
   109  		oi := &o.Outflows[i]
   110  		{
   111  			n := int(binary.LittleEndian.Uint64(data[:8]))
   112  			data = data[8:]
   113  			err = oi.UnmarshalBinary(data[:n])
   114  			if err != nil {
   115  				return err
   116  			}
   117  			data = data[n:]
   118  		}
   119  	}
   120  	{
   121  		n := int(binary.LittleEndian.Uint64(data[:8]))
   122  		data = data[8:]
   123  		err = o.XRange.UnmarshalBinary(data[:n])
   124  		if err != nil {
   125  			return err
   126  		}
   127  		data = data[n:]
   128  	}
   129  	_ = data
   130  	return err
   131  }
   132  
   133  // MarshalBinary implements encoding.BinaryMarshaler
   134  func (o *binningP1D) MarshalBinary() (data []byte, err error) {
   135  	var buf [8]byte
   136  	binary.LittleEndian.PutUint64(buf[:8], uint64(len(o.bins)))
   137  	data = append(data, buf[:8]...)
   138  	for i := range o.bins {
   139  		o := &o.bins[i]
   140  		{
   141  			sub, err := o.MarshalBinary()
   142  			if err != nil {
   143  				return nil, err
   144  			}
   145  			binary.LittleEndian.PutUint64(buf[:8], uint64(len(sub)))
   146  			data = append(data, buf[:8]...)
   147  			data = append(data, sub...)
   148  		}
   149  	}
   150  	{
   151  		sub, err := o.dist.MarshalBinary()
   152  		if err != nil {
   153  			return nil, err
   154  		}
   155  		binary.LittleEndian.PutUint64(buf[:8], uint64(len(sub)))
   156  		data = append(data, buf[:8]...)
   157  		data = append(data, sub...)
   158  	}
   159  	for i := range o.outflows {
   160  		o := &o.outflows[i]
   161  		{
   162  			sub, err := o.MarshalBinary()
   163  			if err != nil {
   164  				return nil, err
   165  			}
   166  			binary.LittleEndian.PutUint64(buf[:8], uint64(len(sub)))
   167  			data = append(data, buf[:8]...)
   168  			data = append(data, sub...)
   169  		}
   170  	}
   171  	{
   172  		sub, err := o.xrange.MarshalBinary()
   173  		if err != nil {
   174  			return nil, err
   175  		}
   176  		binary.LittleEndian.PutUint64(buf[:8], uint64(len(sub)))
   177  		data = append(data, buf[:8]...)
   178  		data = append(data, sub...)
   179  	}
   180  	binary.LittleEndian.PutUint64(buf[:8], math.Float64bits(o.xstep))
   181  	data = append(data, buf[:8]...)
   182  	return data, err
   183  }
   184  
   185  // UnmarshalBinary implements encoding.BinaryUnmarshaler
   186  func (o *binningP1D) UnmarshalBinary(data []byte) (err error) {
   187  	{
   188  		n := int(binary.LittleEndian.Uint64(data[:8]))
   189  		o.bins = make([]BinP1D, n)
   190  		data = data[8:]
   191  		for i := range o.bins {
   192  			oi := &o.bins[i]
   193  			{
   194  				n := int(binary.LittleEndian.Uint64(data[:8]))
   195  				data = data[8:]
   196  				err = oi.UnmarshalBinary(data[:n])
   197  				if err != nil {
   198  					return err
   199  				}
   200  				data = data[n:]
   201  			}
   202  		}
   203  	}
   204  	{
   205  		n := int(binary.LittleEndian.Uint64(data[:8]))
   206  		data = data[8:]
   207  		err = o.dist.UnmarshalBinary(data[:n])
   208  		if err != nil {
   209  			return err
   210  		}
   211  		data = data[n:]
   212  	}
   213  	for i := range o.outflows {
   214  		oi := &o.outflows[i]
   215  		{
   216  			n := int(binary.LittleEndian.Uint64(data[:8]))
   217  			data = data[8:]
   218  			err = oi.UnmarshalBinary(data[:n])
   219  			if err != nil {
   220  				return err
   221  			}
   222  			data = data[n:]
   223  		}
   224  	}
   225  	{
   226  		n := int(binary.LittleEndian.Uint64(data[:8]))
   227  		data = data[8:]
   228  		err = o.xrange.UnmarshalBinary(data[:n])
   229  		if err != nil {
   230  			return err
   231  		}
   232  		data = data[n:]
   233  	}
   234  	o.xstep = float64(math.Float64frombits(binary.LittleEndian.Uint64(data[:8])))
   235  	data = data[8:]
   236  	_ = data
   237  	return err
   238  }
   239  
   240  // MarshalBinary implements encoding.BinaryMarshaler
   241  func (o *Bin1D) MarshalBinary() (data []byte, err error) {
   242  	var buf [8]byte
   243  	{
   244  		sub, err := o.Range.MarshalBinary()
   245  		if err != nil {
   246  			return nil, err
   247  		}
   248  		binary.LittleEndian.PutUint64(buf[:8], uint64(len(sub)))
   249  		data = append(data, buf[:8]...)
   250  		data = append(data, sub...)
   251  	}
   252  	{
   253  		sub, err := o.Dist.MarshalBinary()
   254  		if err != nil {
   255  			return nil, err
   256  		}
   257  		binary.LittleEndian.PutUint64(buf[:8], uint64(len(sub)))
   258  		data = append(data, buf[:8]...)
   259  		data = append(data, sub...)
   260  	}
   261  	return data, err
   262  }
   263  
   264  // UnmarshalBinary implements encoding.BinaryUnmarshaler
   265  func (o *Bin1D) UnmarshalBinary(data []byte) (err error) {
   266  	{
   267  		n := int(binary.LittleEndian.Uint64(data[:8]))
   268  		data = data[8:]
   269  		err = o.Range.UnmarshalBinary(data[:n])
   270  		if err != nil {
   271  			return err
   272  		}
   273  		data = data[n:]
   274  	}
   275  	{
   276  		n := int(binary.LittleEndian.Uint64(data[:8]))
   277  		data = data[8:]
   278  		err = o.Dist.UnmarshalBinary(data[:n])
   279  		if err != nil {
   280  			return err
   281  		}
   282  		data = data[n:]
   283  	}
   284  	_ = data
   285  	return err
   286  }
   287  
   288  // MarshalBinary implements encoding.BinaryMarshaler
   289  func (o *BinP1D) MarshalBinary() (data []byte, err error) {
   290  	var buf [8]byte
   291  	{
   292  		sub, err := o.xrange.MarshalBinary()
   293  		if err != nil {
   294  			return nil, err
   295  		}
   296  		binary.LittleEndian.PutUint64(buf[:8], uint64(len(sub)))
   297  		data = append(data, buf[:8]...)
   298  		data = append(data, sub...)
   299  	}
   300  	{
   301  		sub, err := o.dist.MarshalBinary()
   302  		if err != nil {
   303  			return nil, err
   304  		}
   305  		binary.LittleEndian.PutUint64(buf[:8], uint64(len(sub)))
   306  		data = append(data, buf[:8]...)
   307  		data = append(data, sub...)
   308  	}
   309  	return data, err
   310  }
   311  
   312  // UnmarshalBinary implements encoding.BinaryUnmarshaler
   313  func (o *BinP1D) UnmarshalBinary(data []byte) (err error) {
   314  	{
   315  		n := int(binary.LittleEndian.Uint64(data[:8]))
   316  		data = data[8:]
   317  		err = o.xrange.UnmarshalBinary(data[:n])
   318  		if err != nil {
   319  			return err
   320  		}
   321  		data = data[n:]
   322  	}
   323  	{
   324  		n := int(binary.LittleEndian.Uint64(data[:8]))
   325  		data = data[8:]
   326  		err = o.dist.UnmarshalBinary(data[:n])
   327  		if err != nil {
   328  			return err
   329  		}
   330  		data = data[n:]
   331  	}
   332  	_ = data
   333  	return err
   334  }
   335  
   336  // MarshalBinary implements encoding.BinaryMarshaler
   337  func (o *Binning2D) MarshalBinary() (data []byte, err error) {
   338  	var buf [8]byte
   339  	binary.LittleEndian.PutUint64(buf[:8], uint64(len(o.Bins)))
   340  	data = append(data, buf[:8]...)
   341  	for i := range o.Bins {
   342  		o := &o.Bins[i]
   343  		{
   344  			sub, err := o.MarshalBinary()
   345  			if err != nil {
   346  				return nil, err
   347  			}
   348  			binary.LittleEndian.PutUint64(buf[:8], uint64(len(sub)))
   349  			data = append(data, buf[:8]...)
   350  			data = append(data, sub...)
   351  		}
   352  	}
   353  	{
   354  		sub, err := o.Dist.MarshalBinary()
   355  		if err != nil {
   356  			return nil, err
   357  		}
   358  		binary.LittleEndian.PutUint64(buf[:8], uint64(len(sub)))
   359  		data = append(data, buf[:8]...)
   360  		data = append(data, sub...)
   361  	}
   362  	for i := range o.Outflows {
   363  		o := &o.Outflows[i]
   364  		{
   365  			sub, err := o.MarshalBinary()
   366  			if err != nil {
   367  				return nil, err
   368  			}
   369  			binary.LittleEndian.PutUint64(buf[:8], uint64(len(sub)))
   370  			data = append(data, buf[:8]...)
   371  			data = append(data, sub...)
   372  		}
   373  	}
   374  	{
   375  		sub, err := o.XRange.MarshalBinary()
   376  		if err != nil {
   377  			return nil, err
   378  		}
   379  		binary.LittleEndian.PutUint64(buf[:8], uint64(len(sub)))
   380  		data = append(data, buf[:8]...)
   381  		data = append(data, sub...)
   382  	}
   383  	{
   384  		sub, err := o.YRange.MarshalBinary()
   385  		if err != nil {
   386  			return nil, err
   387  		}
   388  		binary.LittleEndian.PutUint64(buf[:8], uint64(len(sub)))
   389  		data = append(data, buf[:8]...)
   390  		data = append(data, sub...)
   391  	}
   392  	binary.LittleEndian.PutUint64(buf[:8], uint64(o.Nx))
   393  	data = append(data, buf[:8]...)
   394  	binary.LittleEndian.PutUint64(buf[:8], uint64(o.Ny))
   395  	data = append(data, buf[:8]...)
   396  	binary.LittleEndian.PutUint64(buf[:8], uint64(len(o.XEdges)))
   397  	data = append(data, buf[:8]...)
   398  	for i := range o.XEdges {
   399  		o := &o.XEdges[i]
   400  		{
   401  			sub, err := o.MarshalBinary()
   402  			if err != nil {
   403  				return nil, err
   404  			}
   405  			binary.LittleEndian.PutUint64(buf[:8], uint64(len(sub)))
   406  			data = append(data, buf[:8]...)
   407  			data = append(data, sub...)
   408  		}
   409  	}
   410  	binary.LittleEndian.PutUint64(buf[:8], uint64(len(o.YEdges)))
   411  	data = append(data, buf[:8]...)
   412  	for i := range o.YEdges {
   413  		o := &o.YEdges[i]
   414  		{
   415  			sub, err := o.MarshalBinary()
   416  			if err != nil {
   417  				return nil, err
   418  			}
   419  			binary.LittleEndian.PutUint64(buf[:8], uint64(len(sub)))
   420  			data = append(data, buf[:8]...)
   421  			data = append(data, sub...)
   422  		}
   423  	}
   424  	return data, err
   425  }
   426  
   427  // UnmarshalBinary implements encoding.BinaryUnmarshaler
   428  func (o *Binning2D) UnmarshalBinary(data []byte) (err error) {
   429  	{
   430  		n := int(binary.LittleEndian.Uint64(data[:8]))
   431  		o.Bins = make([]Bin2D, n)
   432  		data = data[8:]
   433  		for i := range o.Bins {
   434  			oi := &o.Bins[i]
   435  			{
   436  				n := int(binary.LittleEndian.Uint64(data[:8]))
   437  				data = data[8:]
   438  				err = oi.UnmarshalBinary(data[:n])
   439  				if err != nil {
   440  					return err
   441  				}
   442  				data = data[n:]
   443  			}
   444  		}
   445  	}
   446  	{
   447  		n := int(binary.LittleEndian.Uint64(data[:8]))
   448  		data = data[8:]
   449  		err = o.Dist.UnmarshalBinary(data[:n])
   450  		if err != nil {
   451  			return err
   452  		}
   453  		data = data[n:]
   454  	}
   455  	for i := range o.Outflows {
   456  		oi := &o.Outflows[i]
   457  		{
   458  			n := int(binary.LittleEndian.Uint64(data[:8]))
   459  			data = data[8:]
   460  			err = oi.UnmarshalBinary(data[:n])
   461  			if err != nil {
   462  				return err
   463  			}
   464  			data = data[n:]
   465  		}
   466  	}
   467  	{
   468  		n := int(binary.LittleEndian.Uint64(data[:8]))
   469  		data = data[8:]
   470  		err = o.XRange.UnmarshalBinary(data[:n])
   471  		if err != nil {
   472  			return err
   473  		}
   474  		data = data[n:]
   475  	}
   476  	{
   477  		n := int(binary.LittleEndian.Uint64(data[:8]))
   478  		data = data[8:]
   479  		err = o.YRange.UnmarshalBinary(data[:n])
   480  		if err != nil {
   481  			return err
   482  		}
   483  		data = data[n:]
   484  	}
   485  	o.Nx = int(binary.LittleEndian.Uint64(data[:8]))
   486  	data = data[8:]
   487  	o.Ny = int(binary.LittleEndian.Uint64(data[:8]))
   488  	data = data[8:]
   489  	{
   490  		n := int(binary.LittleEndian.Uint64(data[:8]))
   491  		o.XEdges = make([]Bin1D, n)
   492  		data = data[8:]
   493  		for i := range o.XEdges {
   494  			oi := &o.XEdges[i]
   495  			{
   496  				n := int(binary.LittleEndian.Uint64(data[:8]))
   497  				data = data[8:]
   498  				err = oi.UnmarshalBinary(data[:n])
   499  				if err != nil {
   500  					return err
   501  				}
   502  				data = data[n:]
   503  			}
   504  		}
   505  	}
   506  	{
   507  		n := int(binary.LittleEndian.Uint64(data[:8]))
   508  		o.YEdges = make([]Bin1D, n)
   509  		data = data[8:]
   510  		for i := range o.YEdges {
   511  			oi := &o.YEdges[i]
   512  			{
   513  				n := int(binary.LittleEndian.Uint64(data[:8]))
   514  				data = data[8:]
   515  				err = oi.UnmarshalBinary(data[:n])
   516  				if err != nil {
   517  					return err
   518  				}
   519  				data = data[n:]
   520  			}
   521  		}
   522  	}
   523  	_ = data
   524  	return err
   525  }
   526  
   527  // MarshalBinary implements encoding.BinaryMarshaler
   528  func (o *Bin2D) MarshalBinary() (data []byte, err error) {
   529  	var buf [8]byte
   530  	{
   531  		sub, err := o.XRange.MarshalBinary()
   532  		if err != nil {
   533  			return nil, err
   534  		}
   535  		binary.LittleEndian.PutUint64(buf[:8], uint64(len(sub)))
   536  		data = append(data, buf[:8]...)
   537  		data = append(data, sub...)
   538  	}
   539  	{
   540  		sub, err := o.YRange.MarshalBinary()
   541  		if err != nil {
   542  			return nil, err
   543  		}
   544  		binary.LittleEndian.PutUint64(buf[:8], uint64(len(sub)))
   545  		data = append(data, buf[:8]...)
   546  		data = append(data, sub...)
   547  	}
   548  	{
   549  		sub, err := o.Dist.MarshalBinary()
   550  		if err != nil {
   551  			return nil, err
   552  		}
   553  		binary.LittleEndian.PutUint64(buf[:8], uint64(len(sub)))
   554  		data = append(data, buf[:8]...)
   555  		data = append(data, sub...)
   556  	}
   557  	return data, err
   558  }
   559  
   560  // UnmarshalBinary implements encoding.BinaryUnmarshaler
   561  func (o *Bin2D) UnmarshalBinary(data []byte) (err error) {
   562  	{
   563  		n := int(binary.LittleEndian.Uint64(data[:8]))
   564  		data = data[8:]
   565  		err = o.XRange.UnmarshalBinary(data[:n])
   566  		if err != nil {
   567  			return err
   568  		}
   569  		data = data[n:]
   570  	}
   571  	{
   572  		n := int(binary.LittleEndian.Uint64(data[:8]))
   573  		data = data[8:]
   574  		err = o.YRange.UnmarshalBinary(data[:n])
   575  		if err != nil {
   576  			return err
   577  		}
   578  		data = data[n:]
   579  	}
   580  	{
   581  		n := int(binary.LittleEndian.Uint64(data[:8]))
   582  		data = data[8:]
   583  		err = o.Dist.UnmarshalBinary(data[:n])
   584  		if err != nil {
   585  			return err
   586  		}
   587  		data = data[n:]
   588  	}
   589  	_ = data
   590  	return err
   591  }