github.com/dolthub/dolt/go@v0.40.5-0.20240520175717-68db7794bea6/gen/fb/serial/prolly.go (about)

     1  // Copyright 2022-2023 Dolthub, Inc.
     2  //
     3  // Licensed under the Apache License, Version 2.0 (the "License");
     4  // you may not use this file except in compliance with the License.
     5  // You may obtain a copy of the License at
     6  //
     7  //     http://www.apache.org/licenses/LICENSE-2.0
     8  //
     9  // Unless required by applicable law or agreed to in writing, software
    10  // distributed under the License is distributed on an "AS IS" BASIS,
    11  // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
    12  // See the License for the specific language governing permissions and
    13  // limitations under the License.
    14  
    15  // Code generated by the FlatBuffers compiler. DO NOT EDIT.
    16  
    17  package serial
    18  
    19  import (
    20  	"strconv"
    21  
    22  	flatbuffers "github.com/dolthub/flatbuffers/v23/go"
    23  )
    24  
    25  type ItemType byte
    26  
    27  const (
    28  	ItemTypeUnknown          ItemType = 0
    29  	ItemTypeTupleFormatAlpha ItemType = 1
    30  )
    31  
    32  var EnumNamesItemType = map[ItemType]string{
    33  	ItemTypeUnknown:          "Unknown",
    34  	ItemTypeTupleFormatAlpha: "TupleFormatAlpha",
    35  }
    36  
    37  var EnumValuesItemType = map[string]ItemType{
    38  	"Unknown":          ItemTypeUnknown,
    39  	"TupleFormatAlpha": ItemTypeTupleFormatAlpha,
    40  }
    41  
    42  func (v ItemType) String() string {
    43  	if s, ok := EnumNamesItemType[v]; ok {
    44  		return s
    45  	}
    46  	return "ItemType(" + strconv.FormatInt(int64(v), 10) + ")"
    47  }
    48  
    49  type ProllyTreeNode struct {
    50  	_tab flatbuffers.Table
    51  }
    52  
    53  func InitProllyTreeNodeRoot(o *ProllyTreeNode, buf []byte, offset flatbuffers.UOffsetT) error {
    54  	n := flatbuffers.GetUOffsetT(buf[offset:])
    55  	return o.Init(buf, n+offset)
    56  }
    57  
    58  func TryGetRootAsProllyTreeNode(buf []byte, offset flatbuffers.UOffsetT) (*ProllyTreeNode, error) {
    59  	x := &ProllyTreeNode{}
    60  	return x, InitProllyTreeNodeRoot(x, buf, offset)
    61  }
    62  
    63  func TryGetSizePrefixedRootAsProllyTreeNode(buf []byte, offset flatbuffers.UOffsetT) (*ProllyTreeNode, error) {
    64  	x := &ProllyTreeNode{}
    65  	return x, InitProllyTreeNodeRoot(x, buf, offset+flatbuffers.SizeUint32)
    66  }
    67  
    68  func (rcv *ProllyTreeNode) Init(buf []byte, i flatbuffers.UOffsetT) error {
    69  	rcv._tab.Bytes = buf
    70  	rcv._tab.Pos = i
    71  	if ProllyTreeNodeNumFields < rcv.Table().NumFields() {
    72  		return flatbuffers.ErrTableHasUnknownFields
    73  	}
    74  	return nil
    75  }
    76  
    77  func (rcv *ProllyTreeNode) Table() flatbuffers.Table {
    78  	return rcv._tab
    79  }
    80  
    81  func (rcv *ProllyTreeNode) KeyItems(j int) byte {
    82  	o := flatbuffers.UOffsetT(rcv._tab.Offset(4))
    83  	if o != 0 {
    84  		a := rcv._tab.Vector(o)
    85  		return rcv._tab.GetByte(a + flatbuffers.UOffsetT(j*1))
    86  	}
    87  	return 0
    88  }
    89  
    90  func (rcv *ProllyTreeNode) KeyItemsLength() int {
    91  	o := flatbuffers.UOffsetT(rcv._tab.Offset(4))
    92  	if o != 0 {
    93  		return rcv._tab.VectorLen(o)
    94  	}
    95  	return 0
    96  }
    97  
    98  func (rcv *ProllyTreeNode) KeyItemsBytes() []byte {
    99  	o := flatbuffers.UOffsetT(rcv._tab.Offset(4))
   100  	if o != 0 {
   101  		return rcv._tab.ByteVector(o + rcv._tab.Pos)
   102  	}
   103  	return nil
   104  }
   105  
   106  func (rcv *ProllyTreeNode) MutateKeyItems(j int, n byte) bool {
   107  	o := flatbuffers.UOffsetT(rcv._tab.Offset(4))
   108  	if o != 0 {
   109  		a := rcv._tab.Vector(o)
   110  		return rcv._tab.MutateByte(a+flatbuffers.UOffsetT(j*1), n)
   111  	}
   112  	return false
   113  }
   114  
   115  func (rcv *ProllyTreeNode) KeyOffsets(j int) uint16 {
   116  	o := flatbuffers.UOffsetT(rcv._tab.Offset(6))
   117  	if o != 0 {
   118  		a := rcv._tab.Vector(o)
   119  		return rcv._tab.GetUint16(a + flatbuffers.UOffsetT(j*2))
   120  	}
   121  	return 0
   122  }
   123  
   124  func (rcv *ProllyTreeNode) KeyOffsetsLength() int {
   125  	o := flatbuffers.UOffsetT(rcv._tab.Offset(6))
   126  	if o != 0 {
   127  		return rcv._tab.VectorLen(o)
   128  	}
   129  	return 0
   130  }
   131  
   132  func (rcv *ProllyTreeNode) MutateKeyOffsets(j int, n uint16) bool {
   133  	o := flatbuffers.UOffsetT(rcv._tab.Offset(6))
   134  	if o != 0 {
   135  		a := rcv._tab.Vector(o)
   136  		return rcv._tab.MutateUint16(a+flatbuffers.UOffsetT(j*2), n)
   137  	}
   138  	return false
   139  }
   140  
   141  func (rcv *ProllyTreeNode) KeyType() ItemType {
   142  	o := flatbuffers.UOffsetT(rcv._tab.Offset(8))
   143  	if o != 0 {
   144  		return ItemType(rcv._tab.GetByte(o + rcv._tab.Pos))
   145  	}
   146  	return 0
   147  }
   148  
   149  func (rcv *ProllyTreeNode) MutateKeyType(n ItemType) bool {
   150  	return rcv._tab.MutateByteSlot(8, byte(n))
   151  }
   152  
   153  func (rcv *ProllyTreeNode) ValueItems(j int) byte {
   154  	o := flatbuffers.UOffsetT(rcv._tab.Offset(10))
   155  	if o != 0 {
   156  		a := rcv._tab.Vector(o)
   157  		return rcv._tab.GetByte(a + flatbuffers.UOffsetT(j*1))
   158  	}
   159  	return 0
   160  }
   161  
   162  func (rcv *ProllyTreeNode) ValueItemsLength() int {
   163  	o := flatbuffers.UOffsetT(rcv._tab.Offset(10))
   164  	if o != 0 {
   165  		return rcv._tab.VectorLen(o)
   166  	}
   167  	return 0
   168  }
   169  
   170  func (rcv *ProllyTreeNode) ValueItemsBytes() []byte {
   171  	o := flatbuffers.UOffsetT(rcv._tab.Offset(10))
   172  	if o != 0 {
   173  		return rcv._tab.ByteVector(o + rcv._tab.Pos)
   174  	}
   175  	return nil
   176  }
   177  
   178  func (rcv *ProllyTreeNode) MutateValueItems(j int, n byte) bool {
   179  	o := flatbuffers.UOffsetT(rcv._tab.Offset(10))
   180  	if o != 0 {
   181  		a := rcv._tab.Vector(o)
   182  		return rcv._tab.MutateByte(a+flatbuffers.UOffsetT(j*1), n)
   183  	}
   184  	return false
   185  }
   186  
   187  func (rcv *ProllyTreeNode) ValueOffsets(j int) uint16 {
   188  	o := flatbuffers.UOffsetT(rcv._tab.Offset(12))
   189  	if o != 0 {
   190  		a := rcv._tab.Vector(o)
   191  		return rcv._tab.GetUint16(a + flatbuffers.UOffsetT(j*2))
   192  	}
   193  	return 0
   194  }
   195  
   196  func (rcv *ProllyTreeNode) ValueOffsetsLength() int {
   197  	o := flatbuffers.UOffsetT(rcv._tab.Offset(12))
   198  	if o != 0 {
   199  		return rcv._tab.VectorLen(o)
   200  	}
   201  	return 0
   202  }
   203  
   204  func (rcv *ProllyTreeNode) MutateValueOffsets(j int, n uint16) bool {
   205  	o := flatbuffers.UOffsetT(rcv._tab.Offset(12))
   206  	if o != 0 {
   207  		a := rcv._tab.Vector(o)
   208  		return rcv._tab.MutateUint16(a+flatbuffers.UOffsetT(j*2), n)
   209  	}
   210  	return false
   211  }
   212  
   213  func (rcv *ProllyTreeNode) ValueType() ItemType {
   214  	o := flatbuffers.UOffsetT(rcv._tab.Offset(14))
   215  	if o != 0 {
   216  		return ItemType(rcv._tab.GetByte(o + rcv._tab.Pos))
   217  	}
   218  	return 0
   219  }
   220  
   221  func (rcv *ProllyTreeNode) MutateValueType(n ItemType) bool {
   222  	return rcv._tab.MutateByteSlot(14, byte(n))
   223  }
   224  
   225  func (rcv *ProllyTreeNode) ValueAddressOffsets(j int) uint16 {
   226  	o := flatbuffers.UOffsetT(rcv._tab.Offset(16))
   227  	if o != 0 {
   228  		a := rcv._tab.Vector(o)
   229  		return rcv._tab.GetUint16(a + flatbuffers.UOffsetT(j*2))
   230  	}
   231  	return 0
   232  }
   233  
   234  func (rcv *ProllyTreeNode) ValueAddressOffsetsLength() int {
   235  	o := flatbuffers.UOffsetT(rcv._tab.Offset(16))
   236  	if o != 0 {
   237  		return rcv._tab.VectorLen(o)
   238  	}
   239  	return 0
   240  }
   241  
   242  func (rcv *ProllyTreeNode) MutateValueAddressOffsets(j int, n uint16) bool {
   243  	o := flatbuffers.UOffsetT(rcv._tab.Offset(16))
   244  	if o != 0 {
   245  		a := rcv._tab.Vector(o)
   246  		return rcv._tab.MutateUint16(a+flatbuffers.UOffsetT(j*2), n)
   247  	}
   248  	return false
   249  }
   250  
   251  func (rcv *ProllyTreeNode) AddressArray(j int) byte {
   252  	o := flatbuffers.UOffsetT(rcv._tab.Offset(18))
   253  	if o != 0 {
   254  		a := rcv._tab.Vector(o)
   255  		return rcv._tab.GetByte(a + flatbuffers.UOffsetT(j*1))
   256  	}
   257  	return 0
   258  }
   259  
   260  func (rcv *ProllyTreeNode) AddressArrayLength() int {
   261  	o := flatbuffers.UOffsetT(rcv._tab.Offset(18))
   262  	if o != 0 {
   263  		return rcv._tab.VectorLen(o)
   264  	}
   265  	return 0
   266  }
   267  
   268  func (rcv *ProllyTreeNode) AddressArrayBytes() []byte {
   269  	o := flatbuffers.UOffsetT(rcv._tab.Offset(18))
   270  	if o != 0 {
   271  		return rcv._tab.ByteVector(o + rcv._tab.Pos)
   272  	}
   273  	return nil
   274  }
   275  
   276  func (rcv *ProllyTreeNode) MutateAddressArray(j int, n byte) bool {
   277  	o := flatbuffers.UOffsetT(rcv._tab.Offset(18))
   278  	if o != 0 {
   279  		a := rcv._tab.Vector(o)
   280  		return rcv._tab.MutateByte(a+flatbuffers.UOffsetT(j*1), n)
   281  	}
   282  	return false
   283  }
   284  
   285  func (rcv *ProllyTreeNode) SubtreeCounts(j int) byte {
   286  	o := flatbuffers.UOffsetT(rcv._tab.Offset(20))
   287  	if o != 0 {
   288  		a := rcv._tab.Vector(o)
   289  		return rcv._tab.GetByte(a + flatbuffers.UOffsetT(j*1))
   290  	}
   291  	return 0
   292  }
   293  
   294  func (rcv *ProllyTreeNode) SubtreeCountsLength() int {
   295  	o := flatbuffers.UOffsetT(rcv._tab.Offset(20))
   296  	if o != 0 {
   297  		return rcv._tab.VectorLen(o)
   298  	}
   299  	return 0
   300  }
   301  
   302  func (rcv *ProllyTreeNode) SubtreeCountsBytes() []byte {
   303  	o := flatbuffers.UOffsetT(rcv._tab.Offset(20))
   304  	if o != 0 {
   305  		return rcv._tab.ByteVector(o + rcv._tab.Pos)
   306  	}
   307  	return nil
   308  }
   309  
   310  func (rcv *ProllyTreeNode) MutateSubtreeCounts(j int, n byte) bool {
   311  	o := flatbuffers.UOffsetT(rcv._tab.Offset(20))
   312  	if o != 0 {
   313  		a := rcv._tab.Vector(o)
   314  		return rcv._tab.MutateByte(a+flatbuffers.UOffsetT(j*1), n)
   315  	}
   316  	return false
   317  }
   318  
   319  func (rcv *ProllyTreeNode) TreeCount() uint64 {
   320  	o := flatbuffers.UOffsetT(rcv._tab.Offset(22))
   321  	if o != 0 {
   322  		return rcv._tab.GetUint64(o + rcv._tab.Pos)
   323  	}
   324  	return 0
   325  }
   326  
   327  func (rcv *ProllyTreeNode) MutateTreeCount(n uint64) bool {
   328  	return rcv._tab.MutateUint64Slot(22, n)
   329  }
   330  
   331  func (rcv *ProllyTreeNode) TreeLevel() byte {
   332  	o := flatbuffers.UOffsetT(rcv._tab.Offset(24))
   333  	if o != 0 {
   334  		return rcv._tab.GetByte(o + rcv._tab.Pos)
   335  	}
   336  	return 0
   337  }
   338  
   339  func (rcv *ProllyTreeNode) MutateTreeLevel(n byte) bool {
   340  	return rcv._tab.MutateByteSlot(24, n)
   341  }
   342  
   343  const ProllyTreeNodeNumFields = 11
   344  
   345  func ProllyTreeNodeStart(builder *flatbuffers.Builder) {
   346  	builder.StartObject(ProllyTreeNodeNumFields)
   347  }
   348  func ProllyTreeNodeAddKeyItems(builder *flatbuffers.Builder, keyItems flatbuffers.UOffsetT) {
   349  	builder.PrependUOffsetTSlot(0, flatbuffers.UOffsetT(keyItems), 0)
   350  }
   351  func ProllyTreeNodeStartKeyItemsVector(builder *flatbuffers.Builder, numElems int) flatbuffers.UOffsetT {
   352  	return builder.StartVector(1, numElems, 1)
   353  }
   354  func ProllyTreeNodeAddKeyOffsets(builder *flatbuffers.Builder, keyOffsets flatbuffers.UOffsetT) {
   355  	builder.PrependUOffsetTSlot(1, flatbuffers.UOffsetT(keyOffsets), 0)
   356  }
   357  func ProllyTreeNodeStartKeyOffsetsVector(builder *flatbuffers.Builder, numElems int) flatbuffers.UOffsetT {
   358  	return builder.StartVector(2, numElems, 2)
   359  }
   360  func ProllyTreeNodeAddKeyType(builder *flatbuffers.Builder, keyType ItemType) {
   361  	builder.PrependByteSlot(2, byte(keyType), 0)
   362  }
   363  func ProllyTreeNodeAddValueItems(builder *flatbuffers.Builder, valueItems flatbuffers.UOffsetT) {
   364  	builder.PrependUOffsetTSlot(3, flatbuffers.UOffsetT(valueItems), 0)
   365  }
   366  func ProllyTreeNodeStartValueItemsVector(builder *flatbuffers.Builder, numElems int) flatbuffers.UOffsetT {
   367  	return builder.StartVector(1, numElems, 1)
   368  }
   369  func ProllyTreeNodeAddValueOffsets(builder *flatbuffers.Builder, valueOffsets flatbuffers.UOffsetT) {
   370  	builder.PrependUOffsetTSlot(4, flatbuffers.UOffsetT(valueOffsets), 0)
   371  }
   372  func ProllyTreeNodeStartValueOffsetsVector(builder *flatbuffers.Builder, numElems int) flatbuffers.UOffsetT {
   373  	return builder.StartVector(2, numElems, 2)
   374  }
   375  func ProllyTreeNodeAddValueType(builder *flatbuffers.Builder, valueType ItemType) {
   376  	builder.PrependByteSlot(5, byte(valueType), 0)
   377  }
   378  func ProllyTreeNodeAddValueAddressOffsets(builder *flatbuffers.Builder, valueAddressOffsets flatbuffers.UOffsetT) {
   379  	builder.PrependUOffsetTSlot(6, flatbuffers.UOffsetT(valueAddressOffsets), 0)
   380  }
   381  func ProllyTreeNodeStartValueAddressOffsetsVector(builder *flatbuffers.Builder, numElems int) flatbuffers.UOffsetT {
   382  	return builder.StartVector(2, numElems, 2)
   383  }
   384  func ProllyTreeNodeAddAddressArray(builder *flatbuffers.Builder, addressArray flatbuffers.UOffsetT) {
   385  	builder.PrependUOffsetTSlot(7, flatbuffers.UOffsetT(addressArray), 0)
   386  }
   387  func ProllyTreeNodeStartAddressArrayVector(builder *flatbuffers.Builder, numElems int) flatbuffers.UOffsetT {
   388  	return builder.StartVector(1, numElems, 1)
   389  }
   390  func ProllyTreeNodeAddSubtreeCounts(builder *flatbuffers.Builder, subtreeCounts flatbuffers.UOffsetT) {
   391  	builder.PrependUOffsetTSlot(8, flatbuffers.UOffsetT(subtreeCounts), 0)
   392  }
   393  func ProllyTreeNodeStartSubtreeCountsVector(builder *flatbuffers.Builder, numElems int) flatbuffers.UOffsetT {
   394  	return builder.StartVector(1, numElems, 1)
   395  }
   396  func ProllyTreeNodeAddTreeCount(builder *flatbuffers.Builder, treeCount uint64) {
   397  	builder.PrependUint64Slot(9, treeCount, 0)
   398  }
   399  func ProllyTreeNodeAddTreeLevel(builder *flatbuffers.Builder, treeLevel byte) {
   400  	builder.PrependByteSlot(10, treeLevel, 0)
   401  }
   402  func ProllyTreeNodeEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT {
   403  	return builder.EndObject()
   404  }