flatbuf

package
v0.0.1 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Apr 29, 2022 License: Apache-2.0, BSD-2-Clause, BSD-3-Clause, + 8 more Imports: 2 Imported by: 0

Documentation

Index

Constants

This section is empty.

Variables

View Source 
var EnumNamesBodyCompressionMethod = map[BodyCompressionMethod]string{
	BodyCompressionMethodBUFFER: "BUFFER",
}
View Source 
var EnumNamesCompressionType = map[CompressionType]string{
	CompressionTypeLZ4_FRAME: "LZ4_FRAME",
	CompressionTypeZSTD:      "ZSTD",
}
View Source 
var EnumNamesDateUnit = map[DateUnit]string{
	DateUnitDAY:         "DAY",
	DateUnitMILLISECOND: "MILLISECOND",
}
View Source 
var EnumNamesDictionaryKind = map[DictionaryKind]string{
	DictionaryKindDenseArray: "DenseArray",
}
View Source 
var EnumNamesEndianness = map[Endianness]string{
	EndiannessLittle: "Little",
	EndiannessBig:    "Big",
}
View Source 
var EnumNamesFeature = map[Feature]string{
	FeatureUNUSED:                 "UNUSED",
	FeatureDICTIONARY_REPLACEMENT: "DICTIONARY_REPLACEMENT",
	FeatureCOMPRESSED_BODY:        "COMPRESSED_BODY",
}
View Source 
var EnumNamesIntervalUnit = map[IntervalUnit]string{
	IntervalUnitYEAR_MONTH:     "YEAR_MONTH",
	IntervalUnitDAY_TIME:       "DAY_TIME",
	IntervalUnitMONTH_DAY_NANO: "MONTH_DAY_NANO",
}
View Source 
var EnumNamesMessageHeader = map[MessageHeader]string{
	MessageHeaderNONE:            "NONE",
	MessageHeaderSchema:          "Schema",
	MessageHeaderDictionaryBatch: "DictionaryBatch",
	MessageHeaderRecordBatch:     "RecordBatch",
	MessageHeaderTensor:          "Tensor",
	MessageHeaderSparseTensor:    "SparseTensor",
}
View Source 
var EnumNamesMetadataVersion = map[MetadataVersion]string{
	MetadataVersionV1: "V1",
	MetadataVersionV2: "V2",
	MetadataVersionV3: "V3",
	MetadataVersionV4: "V4",
	MetadataVersionV5: "V5",
}
View Source 
var EnumNamesPrecision = map[Precision]string{
	PrecisionHALF:   "HALF",
	PrecisionSINGLE: "SINGLE",
	PrecisionDOUBLE: "DOUBLE",
}
View Source 
var EnumNamesSparseMatrixCompressedAxis = map[SparseMatrixCompressedAxis]string{
	SparseMatrixCompressedAxisRow:    "Row",
	SparseMatrixCompressedAxisColumn: "Column",
}
View Source 
var EnumNamesSparseTensorIndex = map[SparseTensorIndex]string{
	SparseTensorIndexNONE:                 "NONE",
	SparseTensorIndexSparseTensorIndexCOO: "SparseTensorIndexCOO",
	SparseTensorIndexSparseMatrixIndexCSX: "SparseMatrixIndexCSX",
	SparseTensorIndexSparseTensorIndexCSF: "SparseTensorIndexCSF",
}
View Source 
var EnumNamesTimeUnit = map[TimeUnit]string{
	TimeUnitSECOND:      "SECOND",
	TimeUnitMILLISECOND: "MILLISECOND",
	TimeUnitMICROSECOND: "MICROSECOND",
	TimeUnitNANOSECOND:  "NANOSECOND",
}
View Source 
var EnumNamesType = map[Type]string{
	TypeNONE:            "NONE",
	TypeNull:            "Null",
	TypeInt:             "Int",
	TypeFloatingPoint:   "FloatingPoint",
	TypeBinary:          "Binary",
	TypeUtf8:            "Utf8",
	TypeBool:            "Bool",
	TypeDecimal:         "Decimal",
	TypeDate:            "Date",
	TypeTime:            "Time",
	TypeTimestamp:       "Timestamp",
	TypeInterval:        "Interval",
	TypeList:            "List",
	TypeStruct_:         "Struct_",
	TypeUnion:           "Union",
	TypeFixedSizeBinary: "FixedSizeBinary",
	TypeFixedSizeList:   "FixedSizeList",
	TypeMap:             "Map",
	TypeDuration:        "Duration",
	TypeLargeBinary:     "LargeBinary",
	TypeLargeUtf8:       "LargeUtf8",
	TypeLargeList:       "LargeList",
}
View Source 
var EnumNamesUnionMode = map[UnionMode]string{
	UnionModeSparse: "Sparse",
	UnionModeDense:  "Dense",
}
View Source 
var EnumValuesBodyCompressionMethod = map[string]BodyCompressionMethod{
	"BUFFER": BodyCompressionMethodBUFFER,
}
View Source 
var EnumValuesCompressionType = map[string]CompressionType{
	"LZ4_FRAME": CompressionTypeLZ4_FRAME,
	"ZSTD":      CompressionTypeZSTD,
}
View Source 
var EnumValuesDateUnit = map[string]DateUnit{
	"DAY":         DateUnitDAY,
	"MILLISECOND": DateUnitMILLISECOND,
}
View Source 
var EnumValuesDictionaryKind = map[string]DictionaryKind{
	"DenseArray": DictionaryKindDenseArray,
}
View Source 
var EnumValuesEndianness = map[string]Endianness{
	"Little": EndiannessLittle,
	"Big":    EndiannessBig,
}
View Source 
var EnumValuesFeature = map[string]Feature{
	"UNUSED":                 FeatureUNUSED,
	"DICTIONARY_REPLACEMENT": FeatureDICTIONARY_REPLACEMENT,
	"COMPRESSED_BODY":        FeatureCOMPRESSED_BODY,
}
View Source 
var EnumValuesIntervalUnit = map[string]IntervalUnit{
	"YEAR_MONTH":     IntervalUnitYEAR_MONTH,
	"DAY_TIME":       IntervalUnitDAY_TIME,
	"MONTH_DAY_NANO": IntervalUnitMONTH_DAY_NANO,
}
View Source 
var EnumValuesMessageHeader = map[string]MessageHeader{
	"NONE":            MessageHeaderNONE,
	"Schema":          MessageHeaderSchema,
	"DictionaryBatch": MessageHeaderDictionaryBatch,
	"RecordBatch":     MessageHeaderRecordBatch,
	"Tensor":          MessageHeaderTensor,
	"SparseTensor":    MessageHeaderSparseTensor,
}
View Source 
var EnumValuesMetadataVersion = map[string]MetadataVersion{
	"V1": MetadataVersionV1,
	"V2": MetadataVersionV2,
	"V3": MetadataVersionV3,
	"V4": MetadataVersionV4,
	"V5": MetadataVersionV5,
}
View Source 
var EnumValuesPrecision = map[string]Precision{
	"HALF":   PrecisionHALF,
	"SINGLE": PrecisionSINGLE,
	"DOUBLE": PrecisionDOUBLE,
}
View Source 
var EnumValuesSparseMatrixCompressedAxis = map[string]SparseMatrixCompressedAxis{
	"Row":    SparseMatrixCompressedAxisRow,
	"Column": SparseMatrixCompressedAxisColumn,
}
View Source 
var EnumValuesSparseTensorIndex = map[string]SparseTensorIndex{
	"NONE":                 SparseTensorIndexNONE,
	"SparseTensorIndexCOO": SparseTensorIndexSparseTensorIndexCOO,
	"SparseMatrixIndexCSX": SparseTensorIndexSparseMatrixIndexCSX,
	"SparseTensorIndexCSF": SparseTensorIndexSparseTensorIndexCSF,
}
View Source 
var EnumValuesTimeUnit = map[string]TimeUnit{
	"SECOND":      TimeUnitSECOND,
	"MILLISECOND": TimeUnitMILLISECOND,
	"MICROSECOND": TimeUnitMICROSECOND,
	"NANOSECOND":  TimeUnitNANOSECOND,
}
View Source 
var EnumValuesType = map[string]Type{
	"NONE":            TypeNONE,
	"Null":            TypeNull,
	"Int":             TypeInt,
	"FloatingPoint":   TypeFloatingPoint,
	"Binary":          TypeBinary,
	"Utf8":            TypeUtf8,
	"Bool":            TypeBool,
	"Decimal":         TypeDecimal,
	"Date":            TypeDate,
	"Time":            TypeTime,
	"Timestamp":       TypeTimestamp,
	"Interval":        TypeInterval,
	"List":            TypeList,
	"Struct_":         TypeStruct_,
	"Union":           TypeUnion,
	"FixedSizeBinary": TypeFixedSizeBinary,
	"FixedSizeList":   TypeFixedSizeList,
	"Map":             TypeMap,
	"Duration":        TypeDuration,
	"LargeBinary":     TypeLargeBinary,
	"LargeUtf8":       TypeLargeUtf8,
	"LargeList":       TypeLargeList,
}
View Source 
var EnumValuesUnionMode = map[string]UnionMode{
	"Sparse": UnionModeSparse,
	"Dense":  UnionModeDense,
}

Functions

func BinaryEnd 

func BinaryEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT

func BinaryStart 

func BinaryStart(builder *flatbuffers.Builder)

func BodyCompressionAddCodec 

func BodyCompressionAddCodec(builder *flatbuffers.Builder, codec CompressionType)

func BodyCompressionAddMethod 

func BodyCompressionAddMethod(builder *flatbuffers.Builder, method BodyCompressionMethod)

func BodyCompressionEnd 

func BodyCompressionEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT

func BodyCompressionStart 

func BodyCompressionStart(builder *flatbuffers.Builder)

func BoolEnd 

func BoolEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT

func BoolStart 

func BoolStart(builder *flatbuffers.Builder)

func CreateBlock 

func CreateBlock(builder *flatbuffers.Builder, offset int64, metaDataLength int32, bodyLength int64) flatbuffers.UOffsetT

func CreateBuffer 

func CreateBuffer(builder *flatbuffers.Builder, offset int64, length int64) flatbuffers.UOffsetT

func CreateFieldNode 

func CreateFieldNode(builder *flatbuffers.Builder, length int64, nullCount int64) flatbuffers.UOffsetT

func DateAddUnit 

func DateAddUnit(builder *flatbuffers.Builder, unit DateUnit)

func DateEnd 

func DateEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT

func DateStart 

func DateStart(builder *flatbuffers.Builder)

func DecimalAddBitWidth 

func DecimalAddBitWidth(builder *flatbuffers.Builder, bitWidth int32)

func DecimalAddPrecision 

func DecimalAddPrecision(builder *flatbuffers.Builder, precision int32)

func DecimalAddScale 

func DecimalAddScale(builder *flatbuffers.Builder, scale int32)

func DecimalEnd 

func DecimalEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT

func DecimalStart 

func DecimalStart(builder *flatbuffers.Builder)

func DictionaryBatchAddData 

func DictionaryBatchAddData(builder *flatbuffers.Builder, data flatbuffers.UOffsetT)

func DictionaryBatchAddId 

func DictionaryBatchAddId(builder *flatbuffers.Builder, id int64)

func DictionaryBatchAddIsDelta 

func DictionaryBatchAddIsDelta(builder *flatbuffers.Builder, isDelta bool)

func DictionaryBatchEnd 

func DictionaryBatchEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT

func DictionaryBatchStart 

func DictionaryBatchStart(builder *flatbuffers.Builder)

func DictionaryEncodingAddDictionaryKind 

func DictionaryEncodingAddDictionaryKind(builder *flatbuffers.Builder, dictionaryKind DictionaryKind)

func DictionaryEncodingAddId 

func DictionaryEncodingAddId(builder *flatbuffers.Builder, id int64)

func DictionaryEncodingAddIndexType 

func DictionaryEncodingAddIndexType(builder *flatbuffers.Builder, indexType flatbuffers.UOffsetT)

func DictionaryEncodingAddIsOrdered 

func DictionaryEncodingAddIsOrdered(builder *flatbuffers.Builder, isOrdered bool)

func DictionaryEncodingEnd 

func DictionaryEncodingEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT

func DictionaryEncodingStart 

func DictionaryEncodingStart(builder *flatbuffers.Builder)

func DurationAddUnit 

func DurationAddUnit(builder *flatbuffers.Builder, unit TimeUnit)

func DurationEnd 

func DurationEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT

func DurationStart 

func DurationStart(builder *flatbuffers.Builder)

func FieldAddChildren 

func FieldAddChildren(builder *flatbuffers.Builder, children flatbuffers.UOffsetT)

func FieldAddCustomMetadata 

func FieldAddCustomMetadata(builder *flatbuffers.Builder, customMetadata flatbuffers.UOffsetT)

func FieldAddDictionary 

func FieldAddDictionary(builder *flatbuffers.Builder, dictionary flatbuffers.UOffsetT)

func FieldAddName 

func FieldAddName(builder *flatbuffers.Builder, name flatbuffers.UOffsetT)

func FieldAddNullable 

func FieldAddNullable(builder *flatbuffers.Builder, nullable bool)

func FieldAddType 

func FieldAddType(builder *flatbuffers.Builder, type_ flatbuffers.UOffsetT)

func FieldAddTypeType 

func FieldAddTypeType(builder *flatbuffers.Builder, typeType Type)

func FieldEnd 

func FieldEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT

func FieldStart 

func FieldStart(builder *flatbuffers.Builder)

/ User-defined metadata

func FieldStartChildrenVector 

func FieldStartChildrenVector(builder *flatbuffers.Builder, numElems int) flatbuffers.UOffsetT

func FieldStartCustomMetadataVector 

func FieldStartCustomMetadataVector(builder *flatbuffers.Builder, numElems int) flatbuffers.UOffsetT

func FixedSizeBinaryAddByteWidth 

func FixedSizeBinaryAddByteWidth(builder *flatbuffers.Builder, byteWidth int32)

func FixedSizeBinaryEnd 

func FixedSizeBinaryEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT

func FixedSizeBinaryStart 

func FixedSizeBinaryStart(builder *flatbuffers.Builder)

func FixedSizeListAddListSize 

func FixedSizeListAddListSize(builder *flatbuffers.Builder, listSize int32)

func FixedSizeListEnd 

func FixedSizeListEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT

func FixedSizeListStart 

func FixedSizeListStart(builder *flatbuffers.Builder)

func FloatingPointAddPrecision 

func FloatingPointAddPrecision(builder *flatbuffers.Builder, precision Precision)

func FloatingPointEnd 

func FloatingPointEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT

func FloatingPointStart 

func FloatingPointStart(builder *flatbuffers.Builder)

func FooterAddCustomMetadata 

func FooterAddCustomMetadata(builder *flatbuffers.Builder, customMetadata flatbuffers.UOffsetT)

func FooterAddDictionaries 

func FooterAddDictionaries(builder *flatbuffers.Builder, dictionaries flatbuffers.UOffsetT)

func FooterAddRecordBatches 

func FooterAddRecordBatches(builder *flatbuffers.Builder, recordBatches flatbuffers.UOffsetT)

func FooterAddSchema 

func FooterAddSchema(builder *flatbuffers.Builder, schema flatbuffers.UOffsetT)

func FooterAddVersion 

func FooterAddVersion(builder *flatbuffers.Builder, version MetadataVersion)

func FooterEnd 

func FooterEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT

func FooterStart 

func FooterStart(builder *flatbuffers.Builder)

/ User-defined metadata

func FooterStartCustomMetadataVector 

func FooterStartCustomMetadataVector(builder *flatbuffers.Builder, numElems int) flatbuffers.UOffsetT

func FooterStartDictionariesVector 

func FooterStartDictionariesVector(builder *flatbuffers.Builder, numElems int) flatbuffers.UOffsetT

func FooterStartRecordBatchesVector 

func FooterStartRecordBatchesVector(builder *flatbuffers.Builder, numElems int) flatbuffers.UOffsetT

func IntAddBitWidth 

func IntAddBitWidth(builder *flatbuffers.Builder, bitWidth int32)

func IntAddIsSigned 

func IntAddIsSigned(builder *flatbuffers.Builder, isSigned bool)

func IntEnd 

func IntEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT

func IntStart 

func IntStart(builder *flatbuffers.Builder)

func IntervalAddUnit 

func IntervalAddUnit(builder *flatbuffers.Builder, unit IntervalUnit)

func IntervalEnd 

func IntervalEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT

func IntervalStart 

func IntervalStart(builder *flatbuffers.Builder)

func KeyValueAddKey 

func KeyValueAddKey(builder *flatbuffers.Builder, key flatbuffers.UOffsetT)

func KeyValueAddValue 

func KeyValueAddValue(builder *flatbuffers.Builder, value flatbuffers.UOffsetT)

func KeyValueEnd 

func KeyValueEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT

func KeyValueStart 

func KeyValueStart(builder *flatbuffers.Builder)

func LargeBinaryEnd 

func LargeBinaryEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT

func LargeBinaryStart 

func LargeBinaryStart(builder *flatbuffers.Builder)

func LargeListEnd 

func LargeListEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT

func LargeListStart 

func LargeListStart(builder *flatbuffers.Builder)

func LargeUtf8End 

func LargeUtf8End(builder *flatbuffers.Builder) flatbuffers.UOffsetT

func LargeUtf8Start 

func LargeUtf8Start(builder *flatbuffers.Builder)

func ListEnd 

func ListEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT

func ListStart 

func ListStart(builder *flatbuffers.Builder)

func MapAddKeysSorted 

func MapAddKeysSorted(builder *flatbuffers.Builder, keysSorted bool)

func MapEnd 

func MapEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT

func MapStart 

func MapStart(builder *flatbuffers.Builder)

func MessageAddBodyLength 

func MessageAddBodyLength(builder *flatbuffers.Builder, bodyLength int64)

func MessageAddCustomMetadata 

func MessageAddCustomMetadata(builder *flatbuffers.Builder, customMetadata flatbuffers.UOffsetT)

func MessageAddHeader 

func MessageAddHeader(builder *flatbuffers.Builder, header flatbuffers.UOffsetT)

func MessageAddHeaderType 

func MessageAddHeaderType(builder *flatbuffers.Builder, headerType MessageHeader)

func MessageAddVersion 

func MessageAddVersion(builder *flatbuffers.Builder, version MetadataVersion)

func MessageEnd 

func MessageEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT

func MessageStart 

func MessageStart(builder *flatbuffers.Builder)

func MessageStartCustomMetadataVector 

func MessageStartCustomMetadataVector(builder *flatbuffers.Builder, numElems int) flatbuffers.UOffsetT

func NullEnd 

func NullEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT

func NullStart 

func NullStart(builder *flatbuffers.Builder)

func RecordBatchAddBuffers 

func RecordBatchAddBuffers(builder *flatbuffers.Builder, buffers flatbuffers.UOffsetT)

func RecordBatchAddCompression 

func RecordBatchAddCompression(builder *flatbuffers.Builder, compression flatbuffers.UOffsetT)

func RecordBatchAddLength 

func RecordBatchAddLength(builder *flatbuffers.Builder, length int64)

func RecordBatchAddNodes 

func RecordBatchAddNodes(builder *flatbuffers.Builder, nodes flatbuffers.UOffsetT)

func RecordBatchEnd 

func RecordBatchEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT

func RecordBatchStart 

func RecordBatchStart(builder *flatbuffers.Builder)

/ Optional compression of the message body

func RecordBatchStartBuffersVector 

func RecordBatchStartBuffersVector(builder *flatbuffers.Builder, numElems int) flatbuffers.UOffsetT

func RecordBatchStartNodesVector 

func RecordBatchStartNodesVector(builder *flatbuffers.Builder, numElems int) flatbuffers.UOffsetT

func SchemaAddCustomMetadata 

func SchemaAddCustomMetadata(builder *flatbuffers.Builder, customMetadata flatbuffers.UOffsetT)

func SchemaAddEndianness 

func SchemaAddEndianness(builder *flatbuffers.Builder, endianness Endianness)

func SchemaAddFeatures 

func SchemaAddFeatures(builder *flatbuffers.Builder, features flatbuffers.UOffsetT)

func SchemaAddFields 

func SchemaAddFields(builder *flatbuffers.Builder, fields flatbuffers.UOffsetT)

func SchemaEnd 

func SchemaEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT

func SchemaStart 

func SchemaStart(builder *flatbuffers.Builder)

func SchemaStartCustomMetadataVector 

func SchemaStartCustomMetadataVector(builder *flatbuffers.Builder, numElems int) flatbuffers.UOffsetT

func SchemaStartFeaturesVector 

func SchemaStartFeaturesVector(builder *flatbuffers.Builder, numElems int) flatbuffers.UOffsetT

func SchemaStartFieldsVector 

func SchemaStartFieldsVector(builder *flatbuffers.Builder, numElems int) flatbuffers.UOffsetT

func SparseMatrixIndexCSRAddIndicesBuffer 

func SparseMatrixIndexCSRAddIndicesBuffer(builder *flatbuffers.Builder, indicesBuffer flatbuffers.UOffsetT)

func SparseMatrixIndexCSRAddIndicesType 

func SparseMatrixIndexCSRAddIndicesType(builder *flatbuffers.Builder, indicesType flatbuffers.UOffsetT)

func SparseMatrixIndexCSRAddIndptrBuffer 

func SparseMatrixIndexCSRAddIndptrBuffer(builder *flatbuffers.Builder, indptrBuffer flatbuffers.UOffsetT)

func SparseMatrixIndexCSRAddIndptrType 

func SparseMatrixIndexCSRAddIndptrType(builder *flatbuffers.Builder, indptrType flatbuffers.UOffsetT)

func SparseMatrixIndexCSREnd 

func SparseMatrixIndexCSREnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT

func SparseMatrixIndexCSRStart 

func SparseMatrixIndexCSRStart(builder *flatbuffers.Builder)

/ indicesBuffer stores the location and size of the array that / contains the column indices of the corresponding non-zero values. / The type of index value is long. / / For example, the indices of the above X is: / / indices(X) = [1, 2, 2, 1, 3, 0, 2, 3, 1]. / / Note that the indices are sorted in lexicographical order for each row.

func SparseMatrixIndexCSXAddCompressedAxis 

func SparseMatrixIndexCSXAddCompressedAxis(builder *flatbuffers.Builder, compressedAxis SparseMatrixCompressedAxis)

func SparseMatrixIndexCSXAddIndicesBuffer 

func SparseMatrixIndexCSXAddIndicesBuffer(builder *flatbuffers.Builder, indicesBuffer flatbuffers.UOffsetT)

func SparseMatrixIndexCSXAddIndicesType 

func SparseMatrixIndexCSXAddIndicesType(builder *flatbuffers.Builder, indicesType flatbuffers.UOffsetT)

func SparseMatrixIndexCSXAddIndptrBuffer 

func SparseMatrixIndexCSXAddIndptrBuffer(builder *flatbuffers.Builder, indptrBuffer flatbuffers.UOffsetT)

func SparseMatrixIndexCSXAddIndptrType 

func SparseMatrixIndexCSXAddIndptrType(builder *flatbuffers.Builder, indptrType flatbuffers.UOffsetT)

func SparseMatrixIndexCSXEnd 

func SparseMatrixIndexCSXEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT

func SparseMatrixIndexCSXStart 

func SparseMatrixIndexCSXStart(builder *flatbuffers.Builder)

/ indicesBuffer stores the location and size of the array that / contains the column indices of the corresponding non-zero values. / The type of index value is long. / / For example, the indices of the above X is: / ```text / indices(X) = [1, 2, 2, 1, 3, 0, 2, 3, 1]. / ``` / Note that the indices are sorted in lexicographical order for each row.

func SparseTensorAddData 

func SparseTensorAddData(builder *flatbuffers.Builder, data flatbuffers.UOffsetT)

func SparseTensorAddNonZeroLength 

func SparseTensorAddNonZeroLength(builder *flatbuffers.Builder, nonZeroLength int64)

func SparseTensorAddShape 

func SparseTensorAddShape(builder *flatbuffers.Builder, shape flatbuffers.UOffsetT)

func SparseTensorAddSparseIndex 

func SparseTensorAddSparseIndex(builder *flatbuffers.Builder, sparseIndex flatbuffers.UOffsetT)

func SparseTensorAddSparseIndexType 

func SparseTensorAddSparseIndexType(builder *flatbuffers.Builder, sparseIndexType SparseTensorIndex)

func SparseTensorAddType 

func SparseTensorAddType(builder *flatbuffers.Builder, type_ flatbuffers.UOffsetT)

func SparseTensorAddTypeType 

func SparseTensorAddTypeType(builder *flatbuffers.Builder, typeType Type)

func SparseTensorEnd 

func SparseTensorEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT

func SparseTensorIndexCOOAddIndicesBuffer 

func SparseTensorIndexCOOAddIndicesBuffer(builder *flatbuffers.Builder, indicesBuffer flatbuffers.UOffsetT)

func SparseTensorIndexCOOAddIndicesStrides 

func SparseTensorIndexCOOAddIndicesStrides(builder *flatbuffers.Builder, indicesStrides flatbuffers.UOffsetT)

func SparseTensorIndexCOOAddIndicesType 

func SparseTensorIndexCOOAddIndicesType(builder *flatbuffers.Builder, indicesType flatbuffers.UOffsetT)

func SparseTensorIndexCOOAddIsCanonical 

func SparseTensorIndexCOOAddIsCanonical(builder *flatbuffers.Builder, isCanonical bool)

func SparseTensorIndexCOOEnd 

func SparseTensorIndexCOOEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT

func SparseTensorIndexCOOStart 

func SparseTensorIndexCOOStart(builder *flatbuffers.Builder)

func SparseTensorIndexCOOStartIndicesStridesVector 

func SparseTensorIndexCOOStartIndicesStridesVector(builder *flatbuffers.Builder, numElems int) flatbuffers.UOffsetT

func SparseTensorIndexCSFAddAxisOrder 

func SparseTensorIndexCSFAddAxisOrder(builder *flatbuffers.Builder, axisOrder flatbuffers.UOffsetT)

func SparseTensorIndexCSFAddIndicesBuffers 

func SparseTensorIndexCSFAddIndicesBuffers(builder *flatbuffers.Builder, indicesBuffers flatbuffers.UOffsetT)

func SparseTensorIndexCSFAddIndicesType 

func SparseTensorIndexCSFAddIndicesType(builder *flatbuffers.Builder, indicesType flatbuffers.UOffsetT)

func SparseTensorIndexCSFAddIndptrBuffers 

func SparseTensorIndexCSFAddIndptrBuffers(builder *flatbuffers.Builder, indptrBuffers flatbuffers.UOffsetT)

func SparseTensorIndexCSFAddIndptrType 

func SparseTensorIndexCSFAddIndptrType(builder *flatbuffers.Builder, indptrType flatbuffers.UOffsetT)

func SparseTensorIndexCSFEnd 

func SparseTensorIndexCSFEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT

func SparseTensorIndexCSFStart 

func SparseTensorIndexCSFStart(builder *flatbuffers.Builder)

func SparseTensorIndexCSFStartAxisOrderVector 

func SparseTensorIndexCSFStartAxisOrderVector(builder *flatbuffers.Builder, numElems int) flatbuffers.UOffsetT

func SparseTensorIndexCSFStartIndicesBuffersVector 

func SparseTensorIndexCSFStartIndicesBuffersVector(builder *flatbuffers.Builder, numElems int) flatbuffers.UOffsetT

func SparseTensorIndexCSFStartIndptrBuffersVector 

func SparseTensorIndexCSFStartIndptrBuffersVector(builder *flatbuffers.Builder, numElems int) flatbuffers.UOffsetT

func SparseTensorStart 

func SparseTensorStart(builder *flatbuffers.Builder)

/ The location and size of the tensor's data

func SparseTensorStartShapeVector 

func SparseTensorStartShapeVector(builder *flatbuffers.Builder, numElems int) flatbuffers.UOffsetT

func Struct_End 

func Struct_End(builder *flatbuffers.Builder) flatbuffers.UOffsetT

func Struct_Start 

func Struct_Start(builder *flatbuffers.Builder)

func TensorAddData 

func TensorAddData(builder *flatbuffers.Builder, data flatbuffers.UOffsetT)

func TensorAddShape 

func TensorAddShape(builder *flatbuffers.Builder, shape flatbuffers.UOffsetT)

func TensorAddStrides 

func TensorAddStrides(builder *flatbuffers.Builder, strides flatbuffers.UOffsetT)

func TensorAddType 

func TensorAddType(builder *flatbuffers.Builder, type_ flatbuffers.UOffsetT)

func TensorAddTypeType 

func TensorAddTypeType(builder *flatbuffers.Builder, typeType Type)

func TensorDimAddName 

func TensorDimAddName(builder *flatbuffers.Builder, name flatbuffers.UOffsetT)

func TensorDimAddSize 

func TensorDimAddSize(builder *flatbuffers.Builder, size int64)

func TensorDimEnd 

func TensorDimEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT

func TensorDimStart 

func TensorDimStart(builder *flatbuffers.Builder)

/ Name of the dimension, optional

func TensorEnd 

func TensorEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT

func TensorStart 

func TensorStart(builder *flatbuffers.Builder)

/ The location and size of the tensor's data

func TensorStartShapeVector 

func TensorStartShapeVector(builder *flatbuffers.Builder, numElems int) flatbuffers.UOffsetT

func TensorStartStridesVector 

func TensorStartStridesVector(builder *flatbuffers.Builder, numElems int) flatbuffers.UOffsetT

func TimeAddBitWidth 

func TimeAddBitWidth(builder *flatbuffers.Builder, bitWidth int32)

func TimeAddUnit 

func TimeAddUnit(builder *flatbuffers.Builder, unit TimeUnit)

func TimeEnd 

func TimeEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT

func TimeStart 

func TimeStart(builder *flatbuffers.Builder)

func TimestampAddTimezone 

func TimestampAddTimezone(builder *flatbuffers.Builder, timezone flatbuffers.UOffsetT)

func TimestampAddUnit 

func TimestampAddUnit(builder *flatbuffers.Builder, unit TimeUnit)

func TimestampEnd 

func TimestampEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT

func TimestampStart 

func TimestampStart(builder *flatbuffers.Builder)

/ The timezone is an optional string indicating the name of a timezone, / one of: / / * As used in the Olson timezone database (the "tz database" or / "tzdata"), such as "America/New_York". / * An absolute timezone offset of the form "+XX:XX" or "-XX:XX", / such as "+07:30". / / Whether a timezone string is present indicates different semantics about / the data (see above).

func UnionAddMode 

func UnionAddMode(builder *flatbuffers.Builder, mode UnionMode)

func UnionAddTypeIds 

func UnionAddTypeIds(builder *flatbuffers.Builder, typeIds flatbuffers.UOffsetT)

func UnionEnd 

func UnionEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT

func UnionStart 

func UnionStart(builder *flatbuffers.Builder)

func UnionStartTypeIdsVector 

func UnionStartTypeIdsVector(builder *flatbuffers.Builder, numElems int) flatbuffers.UOffsetT

func Utf8End 

func Utf8End(builder *flatbuffers.Builder) flatbuffers.UOffsetT

func Utf8Start 

func Utf8Start(builder *flatbuffers.Builder)

Types

type Binary 

type Binary struct {
	// contains filtered or unexported fields
}

/ Opaque binary data

func GetRootAsBinary 

func GetRootAsBinary(buf []byte, offset flatbuffers.UOffsetT) *Binary

func (*Binary) Init 

func (rcv *Binary) Init(buf []byte, i flatbuffers.UOffsetT)

func (*Binary) Table 

func (rcv *Binary) Table() flatbuffers.Table

type Block 

type Block struct {
	// contains filtered or unexported fields
}

func (*Block) BodyLength 

func (rcv *Block) BodyLength() int64

/ Length of the data (this is aligned so there can be a gap between this and / the metadata).

func (*Block) Init 

func (rcv *Block) Init(buf []byte, i flatbuffers.UOffsetT)

func (*Block) MetaDataLength 

func (rcv *Block) MetaDataLength() int32

/ Length of the metadata

func (*Block) MutateBodyLength 

func (rcv *Block) MutateBodyLength(n int64) bool

/ Length of the data (this is aligned so there can be a gap between this and / the metadata).

func (*Block) MutateMetaDataLength 

func (rcv *Block) MutateMetaDataLength(n int32) bool

/ Length of the metadata

func (*Block) MutateOffset 

func (rcv *Block) MutateOffset(n int64) bool

/ Index to the start of the RecordBlock (note this is past the Message header)

func (*Block) Offset 

func (rcv *Block) Offset() int64

/ Index to the start of the RecordBlock (note this is past the Message header)

func (*Block) Table 

func (rcv *Block) Table() flatbuffers.Table

type BodyCompression 

type BodyCompression struct {
	// contains filtered or unexported fields
}

/ Optional compression for the memory buffers constituting IPC message / bodies. Intended for use with RecordBatch but could be used for other / message types

func GetRootAsBodyCompression 

func GetRootAsBodyCompression(buf []byte, offset flatbuffers.UOffsetT) *BodyCompression

func (*BodyCompression) Codec 

func (rcv *BodyCompression) Codec() CompressionType

/ Compressor library

func (*BodyCompression) Init 

func (rcv *BodyCompression) Init(buf []byte, i flatbuffers.UOffsetT)

func (*BodyCompression) Method 

func (rcv *BodyCompression) Method() BodyCompressionMethod

/ Indicates the way the record batch body was compressed

func (*BodyCompression) MutateCodec 

func (rcv *BodyCompression) MutateCodec(n CompressionType) bool

/ Compressor library

func (*BodyCompression) MutateMethod 

func (rcv *BodyCompression) MutateMethod(n BodyCompressionMethod) bool

/ Indicates the way the record batch body was compressed

func (*BodyCompression) Table 

func (rcv *BodyCompression) Table() flatbuffers.Table

type BodyCompressionMethod 

type BodyCompressionMethod int8

/ Provided for forward compatibility in case we need to support different / strategies for compressing the IPC message body (like whole-body / compression rather than buffer-level) in the future 

const (
	/// Each constituent buffer is first compressed with the indicated
	/// compressor, and then written with the uncompressed length in the first 8
	/// bytes as a 64-bit little-endian signed integer followed by the compressed
	/// buffer bytes (and then padding as required by the protocol). The
	/// uncompressed length may be set to -1 to indicate that the data that
	/// follows is not compressed, which can be useful for cases where
	/// compression does not yield appreciable savings.
	BodyCompressionMethodBUFFER BodyCompressionMethod = 0
)

func (BodyCompressionMethod) String 

func (v BodyCompressionMethod) String() string

type Bool 

type Bool struct {
	// contains filtered or unexported fields
}

func GetRootAsBool 

func GetRootAsBool(buf []byte, offset flatbuffers.UOffsetT) *Bool

func (*Bool) Init 

func (rcv *Bool) Init(buf []byte, i flatbuffers.UOffsetT)

func (*Bool) Table 

func (rcv *Bool) Table() flatbuffers.Table

type Buffer 

type Buffer struct {
	// contains filtered or unexported fields
}

/ ---------------------------------------------------------------------- / A Buffer represents a single contiguous memory segment

func (*Buffer) Init 

func (rcv *Buffer) Init(buf []byte, i flatbuffers.UOffsetT)

func (*Buffer) Length 

func (rcv *Buffer) Length() int64

/ The absolute length (in bytes) of the memory buffer. The memory is found / from offset (inclusive) to offset + length (non-inclusive). When building / messages using the encapsulated IPC message, padding bytes may be written / after a buffer, but such padding bytes do not need to be accounted for in / the size here.

func (*Buffer) MutateLength 

func (rcv *Buffer) MutateLength(n int64) bool

/ The absolute length (in bytes) of the memory buffer. The memory is found / from offset (inclusive) to offset + length (non-inclusive). When building / messages using the encapsulated IPC message, padding bytes may be written / after a buffer, but such padding bytes do not need to be accounted for in / the size here.

func (*Buffer) MutateOffset 

func (rcv *Buffer) MutateOffset(n int64) bool

/ The relative offset into the shared memory page where the bytes for this / buffer starts

func (*Buffer) Offset 

func (rcv *Buffer) Offset() int64

/ The relative offset into the shared memory page where the bytes for this / buffer starts

func (*Buffer) Table 

func (rcv *Buffer) Table() flatbuffers.Table

type CompressionType 

type CompressionType int8
const (
	CompressionTypeLZ4_FRAME CompressionType = 0
	CompressionTypeZSTD      CompressionType = 1
)

func (CompressionType) String 

func (v CompressionType) String() string

type Date 

type Date struct {
	// contains filtered or unexported fields
}

/ Date is either a 32-bit or 64-bit signed integer type representing an / elapsed time since UNIX epoch (1970-01-01), stored in either of two units: / / * Milliseconds (64 bits) indicating UNIX time elapsed since the epoch (no / leap seconds), where the values are evenly divisible by 86400000 / * Days (32 bits) since the UNIX epoch

func GetRootAsDate 

func GetRootAsDate(buf []byte, offset flatbuffers.UOffsetT) *Date

func (*Date) Init 

func (rcv *Date) Init(buf []byte, i flatbuffers.UOffsetT)

func (*Date) MutateUnit 

func (rcv *Date) MutateUnit(n DateUnit) bool

func (*Date) Table 

func (rcv *Date) Table() flatbuffers.Table

func (*Date) Unit 

func (rcv *Date) Unit() DateUnit

type DateUnit 

type DateUnit int16
const (
	DateUnitDAY         DateUnit = 0
	DateUnitMILLISECOND DateUnit = 1
)

func (DateUnit) String 

func (v DateUnit) String() string

type Decimal 

type Decimal struct {
	// contains filtered or unexported fields
}

/ Exact decimal value represented as an integer value in two's / complement. Currently only 128-bit (16-byte) and 256-bit (32-byte) integers / are used. The representation uses the endianness indicated / in the Schema.

func GetRootAsDecimal 

func GetRootAsDecimal(buf []byte, offset flatbuffers.UOffsetT) *Decimal

func (*Decimal) BitWidth 

func (rcv *Decimal) BitWidth() int32

/ Number of bits per value. The only accepted widths are 128 and 256. / We use bitWidth for consistency with Int::bitWidth.

func (*Decimal) Init 

func (rcv *Decimal) Init(buf []byte, i flatbuffers.UOffsetT)

func (*Decimal) MutateBitWidth 

func (rcv *Decimal) MutateBitWidth(n int32) bool

/ Number of bits per value. The only accepted widths are 128 and 256. / We use bitWidth for consistency with Int::bitWidth.

func (*Decimal) MutatePrecision 

func (rcv *Decimal) MutatePrecision(n int32) bool

/ Total number of decimal digits

func (*Decimal) MutateScale 

func (rcv *Decimal) MutateScale(n int32) bool

/ Number of digits after the decimal point "."

func (*Decimal) Precision 

func (rcv *Decimal) Precision() int32

/ Total number of decimal digits

func (*Decimal) Scale 

func (rcv *Decimal) Scale() int32

/ Number of digits after the decimal point "."

func (*Decimal) Table 

func (rcv *Decimal) Table() flatbuffers.Table

type DictionaryBatch 

type DictionaryBatch struct {
	// contains filtered or unexported fields
}

/ For sending dictionary encoding information. Any Field can be / dictionary-encoded, but in this case none of its children may be / dictionary-encoded. / There is one vector / column per dictionary, but that vector / column / may be spread across multiple dictionary batches by using the isDelta / flag

func GetRootAsDictionaryBatch 

func GetRootAsDictionaryBatch(buf []byte, offset flatbuffers.UOffsetT) *DictionaryBatch

func (*DictionaryBatch) Data 

func (rcv *DictionaryBatch) Data(obj *RecordBatch) *RecordBatch

func (*DictionaryBatch) Id 

func (rcv *DictionaryBatch) Id() int64

func (*DictionaryBatch) Init 

func (rcv *DictionaryBatch) Init(buf []byte, i flatbuffers.UOffsetT)

func (*DictionaryBatch) IsDelta 

func (rcv *DictionaryBatch) IsDelta() bool

/ If isDelta is true the values in the dictionary are to be appended to a / dictionary with the indicated id. If isDelta is false this dictionary / should replace the existing dictionary.

func (*DictionaryBatch) MutateId 

func (rcv *DictionaryBatch) MutateId(n int64) bool

func (*DictionaryBatch) MutateIsDelta 

func (rcv *DictionaryBatch) MutateIsDelta(n bool) bool

/ If isDelta is true the values in the dictionary are to be appended to a / dictionary with the indicated id. If isDelta is false this dictionary / should replace the existing dictionary.

func (*DictionaryBatch) Table 

func (rcv *DictionaryBatch) Table() flatbuffers.Table

type DictionaryEncoding 

type DictionaryEncoding struct {
	// contains filtered or unexported fields
}

func GetRootAsDictionaryEncoding 

func GetRootAsDictionaryEncoding(buf []byte, offset flatbuffers.UOffsetT) *DictionaryEncoding

func (*DictionaryEncoding) DictionaryKind 

func (rcv *DictionaryEncoding) DictionaryKind() DictionaryKind

func (*DictionaryEncoding) Id 

func (rcv *DictionaryEncoding) Id() int64

/ The known dictionary id in the application where this data is used. In / the file or streaming formats, the dictionary ids are found in the / DictionaryBatch messages

func (*DictionaryEncoding) IndexType 

func (rcv *DictionaryEncoding) IndexType(obj *Int) *Int

/ The dictionary indices are constrained to be non-negative integers. If / this field is null, the indices must be signed int32. To maximize / cross-language compatibility and performance, implementations are / recommended to prefer signed integer types over unsigned integer types / and to avoid uint64 indices unless they are required by an application.

func (*DictionaryEncoding) Init 

func (rcv *DictionaryEncoding) Init(buf []byte, i flatbuffers.UOffsetT)

func (*DictionaryEncoding) IsOrdered 

func (rcv *DictionaryEncoding) IsOrdered() bool

/ The dictionary indices are constrained to be non-negative integers. If / this field is null, the indices must be signed int32. To maximize / cross-language compatibility and performance, implementations are / recommended to prefer signed integer types over unsigned integer types / and to avoid uint64 indices unless they are required by an application. / By default, dictionaries are not ordered, or the order does not have / semantic meaning. In some statistical, applications, dictionary-encoding / is used to represent ordered categorical data, and we provide a way to / preserve that metadata here

func (*DictionaryEncoding) MutateDictionaryKind 

func (rcv *DictionaryEncoding) MutateDictionaryKind(n DictionaryKind) bool

func (*DictionaryEncoding) MutateId 

func (rcv *DictionaryEncoding) MutateId(n int64) bool

/ The known dictionary id in the application where this data is used. In / the file or streaming formats, the dictionary ids are found in the / DictionaryBatch messages

func (*DictionaryEncoding) MutateIsOrdered 

func (rcv *DictionaryEncoding) MutateIsOrdered(n bool) bool

/ By default, dictionaries are not ordered, or the order does not have / semantic meaning. In some statistical, applications, dictionary-encoding / is used to represent ordered categorical data, and we provide a way to / preserve that metadata here

func (*DictionaryEncoding) Table 

func (rcv *DictionaryEncoding) Table() flatbuffers.Table

type DictionaryKind 

type DictionaryKind int16

/ ---------------------------------------------------------------------- / Dictionary encoding metadata / Maintained for forwards compatibility, in the future / Dictionaries might be explicit maps between integers and values / allowing for non-contiguous index values 

const (
	DictionaryKindDenseArray DictionaryKind = 0
)

func (DictionaryKind) String 

func (v DictionaryKind) String() string

type Duration 

type Duration struct {
	// contains filtered or unexported fields
}

func GetRootAsDuration 

func GetRootAsDuration(buf []byte, offset flatbuffers.UOffsetT) *Duration

func (*Duration) Init 

func (rcv *Duration) Init(buf []byte, i flatbuffers.UOffsetT)

func (*Duration) MutateUnit 

func (rcv *Duration) MutateUnit(n TimeUnit) bool

func (*Duration) Table 

func (rcv *Duration) Table() flatbuffers.Table

func (*Duration) Unit 

func (rcv *Duration) Unit() TimeUnit

type Endianness 

type Endianness int16

/ ---------------------------------------------------------------------- / Endianness of the platform producing the data 

const (
	EndiannessLittle Endianness = 0
	EndiannessBig    Endianness = 1
)

func (Endianness) String 

func (v Endianness) String() string

type Feature 

type Feature int64

/ Represents Arrow Features that might not have full support / within implementations. This is intended to be used in / two scenarios: / 1. A mechanism for readers of Arrow Streams / and files to understand that the stream or file makes / use of a feature that isn't supported or unknown to / the implementation (and therefore can meet the Arrow / forward compatibility guarantees). / 2. A means of negotiating between a client and server / what features a stream is allowed to use. The enums / values here are intented to represent higher level / features, additional details maybe negotiated / with key-value pairs specific to the protocol. / / Enums added to this list should be assigned power-of-two values / to facilitate exchanging and comparing bitmaps for supported / features. 

const (
	/// Needed to make flatbuffers happy.
	FeatureUNUSED Feature = 0
	/// The stream makes use of multiple full dictionaries with the
	/// same ID and assumes clients implement dictionary replacement
	/// correctly.
	FeatureDICTIONARY_REPLACEMENT Feature = 1
	/// The stream makes use of compressed bodies as described
	/// in Message.fbs.
	FeatureCOMPRESSED_BODY Feature = 2
)

func (Feature) String 

func (v Feature) String() string

type Field 

type Field struct {
	// contains filtered or unexported fields
}

/ ---------------------------------------------------------------------- / A field represents a named column in a record / row batch or child of a / nested type.

func GetRootAsField 

func GetRootAsField(buf []byte, offset flatbuffers.UOffsetT) *Field

func (*Field) Children 

func (rcv *Field) Children(obj *Field, j int) bool

/ Present only if the field is dictionary encoded. / children apply only to nested data types like Struct, List and Union. For / primitive types children will have length 0.

func (*Field) ChildrenLength 

func (rcv *Field) ChildrenLength() int

func (*Field) CustomMetadata 

func (rcv *Field) CustomMetadata(obj *KeyValue, j int) bool

/ children apply only to nested data types like Struct, List and Union. For / primitive types children will have length 0. / User-defined metadata

func (*Field) CustomMetadataLength 

func (rcv *Field) CustomMetadataLength() int

func (*Field) Dictionary 

func (rcv *Field) Dictionary(obj *DictionaryEncoding) *DictionaryEncoding

/ This is the type of the decoded value if the field is dictionary encoded. / Present only if the field is dictionary encoded.

func (*Field) Init 

func (rcv *Field) Init(buf []byte, i flatbuffers.UOffsetT)

func (*Field) MutateNullable 

func (rcv *Field) MutateNullable(n bool) bool

/ Whether or not this field can contain nulls. Should be true in general.

func (*Field) MutateTypeType 

func (rcv *Field) MutateTypeType(n Type) bool

func (*Field) Name 

func (rcv *Field) Name() []byte

/ Name is not required, in i.e. a List

func (*Field) Nullable 

func (rcv *Field) Nullable() bool

/ Name is not required, in i.e. a List / Whether or not this field can contain nulls. Should be true in general.

func (*Field) Table 

func (rcv *Field) Table() flatbuffers.Table

func (*Field) Type 

func (rcv *Field) Type(obj *flatbuffers.Table) bool

/ This is the type of the decoded value if the field is dictionary encoded.

func (*Field) TypeType 

func (rcv *Field) TypeType() Type

type FieldNode 

type FieldNode struct {
	// contains filtered or unexported fields
}

/ ---------------------------------------------------------------------- / Data structures for describing a table row batch (a collection of / equal-length Arrow arrays) / Metadata about a field at some level of a nested type tree (but not / its children). / / For example, a List<Int16> with values `[[1, 2, 3], null, [4], [5, 6], null]` / would have {length: 5, null_count: 2} for its List node, and {length: 6, / null_count: 0} for its Int16 node, as separate FieldNode structs

func (*FieldNode) Init 

func (rcv *FieldNode) Init(buf []byte, i flatbuffers.UOffsetT)

func (*FieldNode) Length 

func (rcv *FieldNode) Length() int64

/ The number of value slots in the Arrow array at this level of a nested / tree

func (*FieldNode) MutateLength 

func (rcv *FieldNode) MutateLength(n int64) bool

/ The number of value slots in the Arrow array at this level of a nested / tree

func (*FieldNode) MutateNullCount 

func (rcv *FieldNode) MutateNullCount(n int64) bool

/ The number of observed nulls. Fields with null_count == 0 may choose not / to write their physical validity bitmap out as a materialized buffer, / instead setting the length of the bitmap buffer to 0.

func (*FieldNode) NullCount 

func (rcv *FieldNode) NullCount() int64

/ The number of observed nulls. Fields with null_count == 0 may choose not / to write their physical validity bitmap out as a materialized buffer, / instead setting the length of the bitmap buffer to 0.

func (*FieldNode) Table 

func (rcv *FieldNode) Table() flatbuffers.Table

type FixedSizeBinary 

type FixedSizeBinary struct {
	// contains filtered or unexported fields
}

func GetRootAsFixedSizeBinary 

func GetRootAsFixedSizeBinary(buf []byte, offset flatbuffers.UOffsetT) *FixedSizeBinary

func (*FixedSizeBinary) ByteWidth 

func (rcv *FixedSizeBinary) ByteWidth() int32

/ Number of bytes per value

func (*FixedSizeBinary) Init 

func (rcv *FixedSizeBinary) Init(buf []byte, i flatbuffers.UOffsetT)

func (*FixedSizeBinary) MutateByteWidth 

func (rcv *FixedSizeBinary) MutateByteWidth(n int32) bool

/ Number of bytes per value

func (*FixedSizeBinary) Table 

func (rcv *FixedSizeBinary) Table() flatbuffers.Table

type FixedSizeList 

type FixedSizeList struct {
	// contains filtered or unexported fields
}

func GetRootAsFixedSizeList 

func GetRootAsFixedSizeList(buf []byte, offset flatbuffers.UOffsetT) *FixedSizeList

func (*FixedSizeList) Init 

func (rcv *FixedSizeList) Init(buf []byte, i flatbuffers.UOffsetT)

func (*FixedSizeList) ListSize 

func (rcv *FixedSizeList) ListSize() int32

/ Number of list items per value

func (*FixedSizeList) MutateListSize 

func (rcv *FixedSizeList) MutateListSize(n int32) bool

/ Number of list items per value

func (*FixedSizeList) Table 

func (rcv *FixedSizeList) Table() flatbuffers.Table

type FloatingPoint 

type FloatingPoint struct {
	// contains filtered or unexported fields
}

func GetRootAsFloatingPoint 

func GetRootAsFloatingPoint(buf []byte, offset flatbuffers.UOffsetT) *FloatingPoint

func (*FloatingPoint) Init 

func (rcv *FloatingPoint) Init(buf []byte, i flatbuffers.UOffsetT)

func (*FloatingPoint) MutatePrecision 

func (rcv *FloatingPoint) MutatePrecision(n Precision) bool

func (*FloatingPoint) Precision 

func (rcv *FloatingPoint) Precision() Precision

func (*FloatingPoint) Table 

func (rcv *FloatingPoint) Table() flatbuffers.Table
type Footer struct {
	// contains filtered or unexported fields
}

/ ---------------------------------------------------------------------- / Arrow File metadata /

func GetRootAsFooter 

func GetRootAsFooter(buf []byte, offset flatbuffers.UOffsetT) *Footer

func (*Footer) CustomMetadata 

func (rcv *Footer) CustomMetadata(obj *KeyValue, j int) bool

/ User-defined metadata

func (*Footer) CustomMetadataLength 

func (rcv *Footer) CustomMetadataLength() int

func (*Footer) Dictionaries 

func (rcv *Footer) Dictionaries(obj *Block, j int) bool

func (*Footer) DictionariesLength 

func (rcv *Footer) DictionariesLength() int

func (*Footer) Init 

func (rcv *Footer) Init(buf []byte, i flatbuffers.UOffsetT)

func (*Footer) MutateVersion 

func (rcv *Footer) MutateVersion(n MetadataVersion) bool

func (*Footer) RecordBatches 

func (rcv *Footer) RecordBatches(obj *Block, j int) bool

func (*Footer) RecordBatchesLength 

func (rcv *Footer) RecordBatchesLength() int

func (*Footer) Schema 

func (rcv *Footer) Schema(obj *Schema) *Schema

func (*Footer) Table 

func (rcv *Footer) Table() flatbuffers.Table

func (*Footer) Version 

func (rcv *Footer) Version() MetadataVersion

type Int 

type Int struct {
	// contains filtered or unexported fields
}

func GetRootAsInt 

func GetRootAsInt(buf []byte, offset flatbuffers.UOffsetT) *Int

func (*Int) BitWidth 

func (rcv *Int) BitWidth() int32

func (*Int) Init 

func (rcv *Int) Init(buf []byte, i flatbuffers.UOffsetT)

func (*Int) IsSigned 

func (rcv *Int) IsSigned() bool

func (*Int) MutateBitWidth 

func (rcv *Int) MutateBitWidth(n int32) bool

func (*Int) MutateIsSigned 

func (rcv *Int) MutateIsSigned(n bool) bool

func (*Int) Table 

func (rcv *Int) Table() flatbuffers.Table

type Interval 

type Interval struct {
	// contains filtered or unexported fields
}

func GetRootAsInterval 

func GetRootAsInterval(buf []byte, offset flatbuffers.UOffsetT) *Interval

func (*Interval) Init 

func (rcv *Interval) Init(buf []byte, i flatbuffers.UOffsetT)

func (*Interval) MutateUnit 

func (rcv *Interval) MutateUnit(n IntervalUnit) bool

func (*Interval) Table 

func (rcv *Interval) Table() flatbuffers.Table

func (*Interval) Unit 

func (rcv *Interval) Unit() IntervalUnit

type IntervalUnit 

type IntervalUnit int16
const (
	IntervalUnitYEAR_MONTH     IntervalUnit = 0
	IntervalUnitDAY_TIME       IntervalUnit = 1
	IntervalUnitMONTH_DAY_NANO IntervalUnit = 2
)

func (IntervalUnit) String 

func (v IntervalUnit) String() string

type KeyValue 

type KeyValue struct {
	// contains filtered or unexported fields
}

/ ---------------------------------------------------------------------- / user defined key value pairs to add custom metadata to arrow / key namespacing is the responsibility of the user

func GetRootAsKeyValue 

func GetRootAsKeyValue(buf []byte, offset flatbuffers.UOffsetT) *KeyValue

func (*KeyValue) Init 

func (rcv *KeyValue) Init(buf []byte, i flatbuffers.UOffsetT)

func (*KeyValue) Key 

func (rcv *KeyValue) Key() []byte

func (*KeyValue) Table 

func (rcv *KeyValue) Table() flatbuffers.Table

func (*KeyValue) Value 

func (rcv *KeyValue) Value() []byte

type LargeBinary 

type LargeBinary struct {
	// contains filtered or unexported fields
}

/ Same as Binary, but with 64-bit offsets, allowing to represent / extremely large data values.

func GetRootAsLargeBinary 

func GetRootAsLargeBinary(buf []byte, offset flatbuffers.UOffsetT) *LargeBinary

func (*LargeBinary) Init 

func (rcv *LargeBinary) Init(buf []byte, i flatbuffers.UOffsetT)

func (*LargeBinary) Table 

func (rcv *LargeBinary) Table() flatbuffers.Table

type LargeList 

type LargeList struct {
	// contains filtered or unexported fields
}

/ Same as List, but with 64-bit offsets, allowing to represent / extremely large data values.

func GetRootAsLargeList 

func GetRootAsLargeList(buf []byte, offset flatbuffers.UOffsetT) *LargeList

func (*LargeList) Init 

func (rcv *LargeList) Init(buf []byte, i flatbuffers.UOffsetT)

func (*LargeList) Table 

func (rcv *LargeList) Table() flatbuffers.Table

type LargeUtf8 

type LargeUtf8 struct {
	// contains filtered or unexported fields
}

/ Same as Utf8, but with 64-bit offsets, allowing to represent / extremely large data values.

func GetRootAsLargeUtf8 

func GetRootAsLargeUtf8(buf []byte, offset flatbuffers.UOffsetT) *LargeUtf8

func (*LargeUtf8) Init 

func (rcv *LargeUtf8) Init(buf []byte, i flatbuffers.UOffsetT)

func (*LargeUtf8) Table 

func (rcv *LargeUtf8) Table() flatbuffers.Table

type List 

type List struct {
	// contains filtered or unexported fields
}

func GetRootAsList 

func GetRootAsList(buf []byte, offset flatbuffers.UOffsetT) *List

func (*List) Init 

func (rcv *List) Init(buf []byte, i flatbuffers.UOffsetT)

func (*List) Table 

func (rcv *List) Table() flatbuffers.Table

type Map 

type Map struct {
	// contains filtered or unexported fields
}

/ A Map is a logical nested type that is represented as / / List<entries: Struct<key: K, value: V>> / / In this layout, the keys and values are each respectively contiguous. We do / not constrain the key and value types, so the application is responsible / for ensuring that the keys are hashable and unique. Whether the keys are sorted / may be set in the metadata for this field. / / In a field with Map type, the field has a child Struct field, which then / has two children: key type and the second the value type. The names of the / child fields may be respectively "entries", "key", and "value", but this is / not enforced. / / Map / ```text / - child[0] entries: Struct / - child[0] key: K / - child[1] value: V / ``` / Neither the "entries" field nor the "key" field may be nullable. / / The metadata is structured so that Arrow systems without special handling / for Map can make Map an alias for List. The "layout" attribute for the Map / field must have the same contents as a List.

func GetRootAsMap 

func GetRootAsMap(buf []byte, offset flatbuffers.UOffsetT) *Map

func (*Map) Init 

func (rcv *Map) Init(buf []byte, i flatbuffers.UOffsetT)

func (*Map) KeysSorted 

func (rcv *Map) KeysSorted() bool

/ Set to true if the keys within each value are sorted

func (*Map) MutateKeysSorted 

func (rcv *Map) MutateKeysSorted(n bool) bool

/ Set to true if the keys within each value are sorted

func (*Map) Table 

func (rcv *Map) Table() flatbuffers.Table

type Message 

type Message struct {
	// contains filtered or unexported fields
}

func GetRootAsMessage 

func GetRootAsMessage(buf []byte, offset flatbuffers.UOffsetT) *Message

func (*Message) BodyLength 

func (rcv *Message) BodyLength() int64

func (*Message) CustomMetadata 

func (rcv *Message) CustomMetadata(obj *KeyValue, j int) bool

func (*Message) CustomMetadataLength 

func (rcv *Message) CustomMetadataLength() int

func (*Message) Header 

func (rcv *Message) Header(obj *flatbuffers.Table) bool

func (*Message) HeaderType 

func (rcv *Message) HeaderType() MessageHeader

func (*Message) Init 

func (rcv *Message) Init(buf []byte, i flatbuffers.UOffsetT)

func (*Message) MutateBodyLength 

func (rcv *Message) MutateBodyLength(n int64) bool

func (*Message) MutateHeaderType 

func (rcv *Message) MutateHeaderType(n MessageHeader) bool

func (*Message) MutateVersion 

func (rcv *Message) MutateVersion(n MetadataVersion) bool

func (*Message) Table 

func (rcv *Message) Table() flatbuffers.Table

func (*Message) Version 

func (rcv *Message) Version() MetadataVersion

type MessageHeader 

type MessageHeader byte

/ ---------------------------------------------------------------------- / The root Message type / This union enables us to easily send different message types without / redundant storage, and in the future we can easily add new message types. / / Arrow implementations do not need to implement all of the message types, / which may include experimental metadata types. For maximum compatibility, / it is best to send data using RecordBatch 

const (
	MessageHeaderNONE            MessageHeader = 0
	MessageHeaderSchema          MessageHeader = 1
	MessageHeaderDictionaryBatch MessageHeader = 2
	MessageHeaderRecordBatch     MessageHeader = 3
	MessageHeaderTensor          MessageHeader = 4
	MessageHeaderSparseTensor    MessageHeader = 5
)

func (MessageHeader) String 

func (v MessageHeader) String() string

type MetadataVersion 

type MetadataVersion int16
const (
	/// 0.1.0 (October 2016).
	MetadataVersionV1 MetadataVersion = 0
	/// 0.2.0 (February 2017). Non-backwards compatible with V1.
	MetadataVersionV2 MetadataVersion = 1
	/// 0.3.0 -> 0.7.1 (May - December 2017). Non-backwards compatible with V2.
	MetadataVersionV3 MetadataVersion = 2
	/// >= 0.8.0 (December 2017). Non-backwards compatible with V3.
	MetadataVersionV4 MetadataVersion = 3
	/// >= 1.0.0 (July 2020. Backwards compatible with V4 (V5 readers can read V4
	/// metadata and IPC messages). Implementations are recommended to provide a
	/// V4 compatibility mode with V5 format changes disabled.
	///
	/// Incompatible changes between V4 and V5:
	/// - Union buffer layout has changed. In V5, Unions don't have a validity
	///   bitmap buffer.
	MetadataVersionV5 MetadataVersion = 4
)

func (MetadataVersion) String 

func (v MetadataVersion) String() string

type Null 

type Null struct {
	// contains filtered or unexported fields
}

/ These are stored in the flatbuffer in the Type union below

func GetRootAsNull 

func GetRootAsNull(buf []byte, offset flatbuffers.UOffsetT) *Null

func (*Null) Init 

func (rcv *Null) Init(buf []byte, i flatbuffers.UOffsetT)

func (*Null) Table 

func (rcv *Null) Table() flatbuffers.Table

type Precision 

type Precision int16
const (
	PrecisionHALF   Precision = 0
	PrecisionSINGLE Precision = 1
	PrecisionDOUBLE Precision = 2
)

func (Precision) String 

func (v Precision) String() string

type RecordBatch 

type RecordBatch struct {
	// contains filtered or unexported fields
}

/ A data header describing the shared memory layout of a "record" or "row" / batch. Some systems call this a "row batch" internally and others a "record / batch".

func GetRootAsRecordBatch 

func GetRootAsRecordBatch(buf []byte, offset flatbuffers.UOffsetT) *RecordBatch

func (*RecordBatch) Buffers 

func (rcv *RecordBatch) Buffers(obj *Buffer, j int) bool

/ Nodes correspond to the pre-ordered flattened logical schema / Buffers correspond to the pre-ordered flattened buffer tree / / The number of buffers appended to this list depends on the schema. For / example, most primitive arrays will have 2 buffers, 1 for the validity / bitmap and 1 for the values. For struct arrays, there will only be a / single buffer for the validity (nulls) bitmap

func (*RecordBatch) BuffersLength 

func (rcv *RecordBatch) BuffersLength() int

func (*RecordBatch) Compression 

func (rcv *RecordBatch) Compression(obj *BodyCompression) *BodyCompression

/ Buffers correspond to the pre-ordered flattened buffer tree / / The number of buffers appended to this list depends on the schema. For / example, most primitive arrays will have 2 buffers, 1 for the validity / bitmap and 1 for the values. For struct arrays, there will only be a / single buffer for the validity (nulls) bitmap / Optional compression of the message body

func (*RecordBatch) Init 

func (rcv *RecordBatch) Init(buf []byte, i flatbuffers.UOffsetT)

func (*RecordBatch) Length 

func (rcv *RecordBatch) Length() int64

/ number of records / rows. The arrays in the batch should all have this / length

func (*RecordBatch) MutateLength 

func (rcv *RecordBatch) MutateLength(n int64) bool

/ number of records / rows. The arrays in the batch should all have this / length

func (*RecordBatch) Nodes 

func (rcv *RecordBatch) Nodes(obj *FieldNode, j int) bool

/ Nodes correspond to the pre-ordered flattened logical schema

func (*RecordBatch) NodesLength 

func (rcv *RecordBatch) NodesLength() int

func (*RecordBatch) Table 

func (rcv *RecordBatch) Table() flatbuffers.Table

type Schema 

type Schema struct {
	// contains filtered or unexported fields
}

/ ---------------------------------------------------------------------- / A Schema describes the columns in a row batch

func GetRootAsSchema 

func GetRootAsSchema(buf []byte, offset flatbuffers.UOffsetT) *Schema

func (*Schema) CustomMetadata 

func (rcv *Schema) CustomMetadata(obj *KeyValue, j int) bool

func (*Schema) CustomMetadataLength 

func (rcv *Schema) CustomMetadataLength() int

func (*Schema) Endianness 

func (rcv *Schema) Endianness() Endianness

/ endianness of the buffer / it is Little Endian by default / if endianness doesn't match the underlying system then the vectors need to be converted

func (*Schema) Features 

func (rcv *Schema) Features(j int) Feature

/ Features used in the stream/file.

func (*Schema) FeaturesLength 

func (rcv *Schema) FeaturesLength() int

func (*Schema) Fields 

func (rcv *Schema) Fields(obj *Field, j int) bool

func (*Schema) FieldsLength 

func (rcv *Schema) FieldsLength() int

func (*Schema) Init 

func (rcv *Schema) Init(buf []byte, i flatbuffers.UOffsetT)

func (*Schema) MutateEndianness 

func (rcv *Schema) MutateEndianness(n Endianness) bool

/ endianness of the buffer / it is Little Endian by default / if endianness doesn't match the underlying system then the vectors need to be converted

func (*Schema) MutateFeatures 

func (rcv *Schema) MutateFeatures(j int, n Feature) bool

/ Features used in the stream/file.

func (*Schema) Table 

func (rcv *Schema) Table() flatbuffers.Table

type SparseMatrixCompressedAxis 

type SparseMatrixCompressedAxis int16
const (
	SparseMatrixCompressedAxisRow    SparseMatrixCompressedAxis = 0
	SparseMatrixCompressedAxisColumn SparseMatrixCompressedAxis = 1
)

func (SparseMatrixCompressedAxis) String 

func (v SparseMatrixCompressedAxis) String() string

type SparseMatrixIndexCSR 

type SparseMatrixIndexCSR struct {
	// contains filtered or unexported fields
}

/ Compressed Sparse Row format, that is matrix-specific.

func GetRootAsSparseMatrixIndexCSR 

func GetRootAsSparseMatrixIndexCSR(buf []byte, offset flatbuffers.UOffsetT) *SparseMatrixIndexCSR

func (*SparseMatrixIndexCSR) IndicesBuffer 

func (rcv *SparseMatrixIndexCSR) IndicesBuffer(obj *Buffer) *Buffer

/ The type of values in indicesBuffer / indicesBuffer stores the location and size of the array that / contains the column indices of the corresponding non-zero values. / The type of index value is long. / / For example, the indices of the above X is: / / indices(X) = [1, 2, 2, 1, 3, 0, 2, 3, 1]. / / Note that the indices are sorted in lexicographical order for each row.

func (*SparseMatrixIndexCSR) IndicesType 

func (rcv *SparseMatrixIndexCSR) IndicesType(obj *Int) *Int

/ indptrBuffer stores the location and size of indptr array that / represents the range of the rows. / The i-th row spans from indptr[i] to indptr[i+1] in the data. / The length of this array is 1 + (the number of rows), and the type / of index value is long. / / For example, let X be the following 6x4 matrix: / / X := [[0, 1, 2, 0], / [0, 0, 3, 0], / [0, 4, 0, 5], / [0, 0, 0, 0], / [6, 0, 7, 8], / [0, 9, 0, 0]]. / / The array of non-zero values in X is: / / values(X) = [1, 2, 3, 4, 5, 6, 7, 8, 9]. / / And the indptr of X is: / / indptr(X) = [0, 2, 3, 5, 5, 8, 10]. / The type of values in indicesBuffer

func (*SparseMatrixIndexCSR) IndptrBuffer 

func (rcv *SparseMatrixIndexCSR) IndptrBuffer(obj *Buffer) *Buffer

/ The type of values in indptrBuffer / indptrBuffer stores the location and size of indptr array that / represents the range of the rows. / The i-th row spans from indptr[i] to indptr[i+1] in the data. / The length of this array is 1 + (the number of rows), and the type / of index value is long. / / For example, let X be the following 6x4 matrix: / / X := [[0, 1, 2, 0], / [0, 0, 3, 0], / [0, 4, 0, 5], / [0, 0, 0, 0], / [6, 0, 7, 8], / [0, 9, 0, 0]]. / / The array of non-zero values in X is: / / values(X) = [1, 2, 3, 4, 5, 6, 7, 8, 9]. / / And the indptr of X is: / / indptr(X) = [0, 2, 3, 5, 5, 8, 10].

func (*SparseMatrixIndexCSR) IndptrType 

func (rcv *SparseMatrixIndexCSR) IndptrType(obj *Int) *Int

/ The type of values in indptrBuffer

func (*SparseMatrixIndexCSR) Init 

func (rcv *SparseMatrixIndexCSR) Init(buf []byte, i flatbuffers.UOffsetT)

func (*SparseMatrixIndexCSR) Table 

func (rcv *SparseMatrixIndexCSR) Table() flatbuffers.Table

type SparseMatrixIndexCSX 

type SparseMatrixIndexCSX struct {
	// contains filtered or unexported fields
}

/ Compressed Sparse format, that is matrix-specific.

func GetRootAsSparseMatrixIndexCSX 

func GetRootAsSparseMatrixIndexCSX(buf []byte, offset flatbuffers.UOffsetT) *SparseMatrixIndexCSX

func (*SparseMatrixIndexCSX) CompressedAxis 

func (rcv *SparseMatrixIndexCSX) CompressedAxis() SparseMatrixCompressedAxis

/ Which axis, row or column, is compressed

func (*SparseMatrixIndexCSX) IndicesBuffer 

func (rcv *SparseMatrixIndexCSX) IndicesBuffer(obj *Buffer) *Buffer

/ The type of values in indicesBuffer / indicesBuffer stores the location and size of the array that / contains the column indices of the corresponding non-zero values. / The type of index value is long. / / For example, the indices of the above X is: / ```text / indices(X) = [1, 2, 2, 1, 3, 0, 2, 3, 1]. / ``` / Note that the indices are sorted in lexicographical order for each row.

func (*SparseMatrixIndexCSX) IndicesType 

func (rcv *SparseMatrixIndexCSX) IndicesType(obj *Int) *Int

/ indptrBuffer stores the location and size of indptr array that / represents the range of the rows. / The i-th row spans from `indptr[i]` to `indptr[i+1]` in the data. / The length of this array is 1 + (the number of rows), and the type / of index value is long. / / For example, let X be the following 6x4 matrix: / ```text / X := [[0, 1, 2, 0], / [0, 0, 3, 0], / [0, 4, 0, 5], / [0, 0, 0, 0], / [6, 0, 7, 8], / [0, 9, 0, 0]]. / ``` / The array of non-zero values in X is: / ```text / values(X) = [1, 2, 3, 4, 5, 6, 7, 8, 9]. / ``` / And the indptr of X is: / ```text / indptr(X) = [0, 2, 3, 5, 5, 8, 10]. / ``` / The type of values in indicesBuffer

func (*SparseMatrixIndexCSX) IndptrBuffer 

func (rcv *SparseMatrixIndexCSX) IndptrBuffer(obj *Buffer) *Buffer

/ The type of values in indptrBuffer / indptrBuffer stores the location and size of indptr array that / represents the range of the rows. / The i-th row spans from `indptr[i]` to `indptr[i+1]` in the data. / The length of this array is 1 + (the number of rows), and the type / of index value is long. / / For example, let X be the following 6x4 matrix: / ```text / X := [[0, 1, 2, 0], / [0, 0, 3, 0], / [0, 4, 0, 5], / [0, 0, 0, 0], / [6, 0, 7, 8], / [0, 9, 0, 0]]. / ``` / The array of non-zero values in X is: / ```text / values(X) = [1, 2, 3, 4, 5, 6, 7, 8, 9]. / ``` / And the indptr of X is: / ```text / indptr(X) = [0, 2, 3, 5, 5, 8, 10]. / ```

func (*SparseMatrixIndexCSX) IndptrType 

func (rcv *SparseMatrixIndexCSX) IndptrType(obj *Int) *Int

/ The type of values in indptrBuffer

func (*SparseMatrixIndexCSX) Init 

func (rcv *SparseMatrixIndexCSX) Init(buf []byte, i flatbuffers.UOffsetT)

func (*SparseMatrixIndexCSX) MutateCompressedAxis 

func (rcv *SparseMatrixIndexCSX) MutateCompressedAxis(n SparseMatrixCompressedAxis) bool

/ Which axis, row or column, is compressed

func (*SparseMatrixIndexCSX) Table 

func (rcv *SparseMatrixIndexCSX) Table() flatbuffers.Table

type SparseTensor 

type SparseTensor struct {
	// contains filtered or unexported fields
}

func GetRootAsSparseTensor 

func GetRootAsSparseTensor(buf []byte, offset flatbuffers.UOffsetT) *SparseTensor

func (*SparseTensor) Data 

func (rcv *SparseTensor) Data(obj *Buffer) *Buffer

/ Sparse tensor index / The location and size of the tensor's data

func (*SparseTensor) Init 

func (rcv *SparseTensor) Init(buf []byte, i flatbuffers.UOffsetT)

func (*SparseTensor) MutateNonZeroLength 

func (rcv *SparseTensor) MutateNonZeroLength(n int64) bool

/ The number of non-zero values in a sparse tensor.

func (*SparseTensor) MutateSparseIndexType 

func (rcv *SparseTensor) MutateSparseIndexType(n SparseTensorIndex) bool

func (*SparseTensor) MutateTypeType 

func (rcv *SparseTensor) MutateTypeType(n Type) bool

func (*SparseTensor) NonZeroLength 

func (rcv *SparseTensor) NonZeroLength() int64

/ The dimensions of the tensor, optionally named. / The number of non-zero values in a sparse tensor.

func (*SparseTensor) Shape 

func (rcv *SparseTensor) Shape(obj *TensorDim, j int) bool

/ The type of data contained in a value cell. / Currently only fixed-width value types are supported, / no strings or nested types. / The dimensions of the tensor, optionally named.

func (*SparseTensor) ShapeLength 

func (rcv *SparseTensor) ShapeLength() int

func (*SparseTensor) SparseIndex 

func (rcv *SparseTensor) SparseIndex(obj *flatbuffers.Table) bool

/ Sparse tensor index

func (*SparseTensor) SparseIndexType 

func (rcv *SparseTensor) SparseIndexType() SparseTensorIndex

func (*SparseTensor) Table 

func (rcv *SparseTensor) Table() flatbuffers.Table

func (*SparseTensor) Type 

func (rcv *SparseTensor) Type(obj *flatbuffers.Table) bool

/ The type of data contained in a value cell. / Currently only fixed-width value types are supported, / no strings or nested types.

func (*SparseTensor) TypeType 

func (rcv *SparseTensor) TypeType() Type

type SparseTensorIndex 

type SparseTensorIndex byte
const (
	SparseTensorIndexNONE                 SparseTensorIndex = 0
	SparseTensorIndexSparseTensorIndexCOO SparseTensorIndex = 1
	SparseTensorIndexSparseMatrixIndexCSX SparseTensorIndex = 2
	SparseTensorIndexSparseTensorIndexCSF SparseTensorIndex = 3
)

func (SparseTensorIndex) String 

func (v SparseTensorIndex) String() string

type SparseTensorIndexCOO 

type SparseTensorIndexCOO struct {
	// contains filtered or unexported fields
}

/ ---------------------------------------------------------------------- / EXPERIMENTAL: Data structures for sparse tensors / Coordinate (COO) format of sparse tensor index. / / COO's index list are represented as a NxM matrix, / where N is the number of non-zero values, / and M is the number of dimensions of a sparse tensor. / / indicesBuffer stores the location and size of the data of this indices / matrix. The value type and the stride of the indices matrix is / specified in indicesType and indicesStrides fields. / / For example, let X be a 2x3x4x5 tensor, and it has the following / 6 non-zero values: / ```text / X[0, 1, 2, 0] := 1 / X[1, 1, 2, 3] := 2 / X[0, 2, 1, 0] := 3 / X[0, 1, 3, 0] := 4 / X[0, 1, 2, 1] := 5 / X[1, 2, 0, 4] := 6 / ``` / In COO format, the index matrix of X is the following 4x6 matrix: / ```text / [[0, 0, 0, 0, 1, 1], / [1, 1, 1, 2, 1, 2], / [2, 2, 3, 1, 2, 0], / [0, 1, 0, 0, 3, 4]] / ``` / When isCanonical is true, the indices is sorted in lexicographical order / (row-major order), and it does not have duplicated entries. Otherwise, / the indices may not be sorted, or may have duplicated entries.

func GetRootAsSparseTensorIndexCOO 

func GetRootAsSparseTensorIndexCOO(buf []byte, offset flatbuffers.UOffsetT) *SparseTensorIndexCOO

func (*SparseTensorIndexCOO) IndicesBuffer 

func (rcv *SparseTensorIndexCOO) IndicesBuffer(obj *Buffer) *Buffer

/ The location and size of the indices matrix's data

func (*SparseTensorIndexCOO) IndicesStrides 

func (rcv *SparseTensorIndexCOO) IndicesStrides(j int) int64

/ The type of values in indicesBuffer / Non-negative byte offsets to advance one value cell along each dimension / If omitted, default to row-major order (C-like).

func (*SparseTensorIndexCOO) IndicesStridesLength 

func (rcv *SparseTensorIndexCOO) IndicesStridesLength() int

func (*SparseTensorIndexCOO) IndicesType 

func (rcv *SparseTensorIndexCOO) IndicesType(obj *Int) *Int

/ The type of values in indicesBuffer

func (*SparseTensorIndexCOO) Init 

func (rcv *SparseTensorIndexCOO) Init(buf []byte, i flatbuffers.UOffsetT)

func (*SparseTensorIndexCOO) IsCanonical 

func (rcv *SparseTensorIndexCOO) IsCanonical() bool

/ The location and size of the indices matrix's data / This flag is true if and only if the indices matrix is sorted in / row-major order, and does not have duplicated entries. / This sort order is the same as of Tensorflow's SparseTensor, / but it is inverse order of SciPy's canonical coo_matrix / (SciPy employs column-major order for its coo_matrix).

func (*SparseTensorIndexCOO) MutateIndicesStrides 

func (rcv *SparseTensorIndexCOO) MutateIndicesStrides(j int, n int64) bool

/ Non-negative byte offsets to advance one value cell along each dimension / If omitted, default to row-major order (C-like).

func (*SparseTensorIndexCOO) MutateIsCanonical 

func (rcv *SparseTensorIndexCOO) MutateIsCanonical(n bool) bool

/ This flag is true if and only if the indices matrix is sorted in / row-major order, and does not have duplicated entries. / This sort order is the same as of Tensorflow's SparseTensor, / but it is inverse order of SciPy's canonical coo_matrix / (SciPy employs column-major order for its coo_matrix).

func (*SparseTensorIndexCOO) Table 

func (rcv *SparseTensorIndexCOO) Table() flatbuffers.Table

type SparseTensorIndexCSF 

type SparseTensorIndexCSF struct {
	// contains filtered or unexported fields
}

/ Compressed Sparse Fiber (CSF) sparse tensor index.

func GetRootAsSparseTensorIndexCSF 

func GetRootAsSparseTensorIndexCSF(buf []byte, offset flatbuffers.UOffsetT) *SparseTensorIndexCSF

func (*SparseTensorIndexCSF) AxisOrder 

func (rcv *SparseTensorIndexCSF) AxisOrder(j int) int32

/ indicesBuffers stores values of nodes. / Each tensor dimension corresponds to a buffer in indicesBuffers. / For example, the indicesBuffers for the above X is: / ```text / indicesBuffer(X) = [ / [0, 1], / [0, 1, 1], / [0, 0, 1, 1], / [1, 2, 0, 2, 0, 0, 1, 2] / ]. / ``` / axisOrder stores the sequence in which dimensions were traversed to / produce the prefix tree. / For example, the axisOrder for the above X is: / ```text / axisOrder(X) = [0, 1, 2, 3]. / ```

func (*SparseTensorIndexCSF) AxisOrderLength 

func (rcv *SparseTensorIndexCSF) AxisOrderLength() int

func (*SparseTensorIndexCSF) IndicesBuffers 

func (rcv *SparseTensorIndexCSF) IndicesBuffers(obj *Buffer, j int) bool

/ The type of values in indicesBuffers / indicesBuffers stores values of nodes. / Each tensor dimension corresponds to a buffer in indicesBuffers. / For example, the indicesBuffers for the above X is: / ```text / indicesBuffer(X) = [ / [0, 1], / [0, 1, 1], / [0, 0, 1, 1], / [1, 2, 0, 2, 0, 0, 1, 2] / ]. / ```

func (*SparseTensorIndexCSF) IndicesBuffersLength 

func (rcv *SparseTensorIndexCSF) IndicesBuffersLength() int

func (*SparseTensorIndexCSF) IndicesType 

func (rcv *SparseTensorIndexCSF) IndicesType(obj *Int) *Int

/ indptrBuffers stores the sparsity structure. / Each two consecutive dimensions in a tensor correspond to a buffer in / indptrBuffers. A pair of consecutive values at `indptrBuffers[dim][i]` / and `indptrBuffers[dim][i + 1]` signify a range of nodes in / `indicesBuffers[dim + 1]` who are children of `indicesBuffers[dim][i]` node. / / For example, the indptrBuffers for the above X is: / ```text / indptrBuffer(X) = [ / [0, 2, 3], / [0, 1, 3, 4], / [0, 2, 4, 5, 8] / ]. / ``` / The type of values in indicesBuffers

func (*SparseTensorIndexCSF) IndptrBuffers 

func (rcv *SparseTensorIndexCSF) IndptrBuffers(obj *Buffer, j int) bool

/ CSF is a generalization of compressed sparse row (CSR) index. / See [smith2017knl](http://shaden.io/pub-files/smith2017knl.pdf) / / CSF index recursively compresses each dimension of a tensor into a set / of prefix trees. Each path from a root to leaf forms one tensor / non-zero index. CSF is implemented with two arrays of buffers and one / arrays of integers. / / For example, let X be a 2x3x4x5 tensor and let it have the following / 8 non-zero values: / ```text / X[0, 0, 0, 1] := 1 / X[0, 0, 0, 2] := 2 / X[0, 1, 0, 0] := 3 / X[0, 1, 0, 2] := 4 / X[0, 1, 1, 0] := 5 / X[1, 1, 1, 0] := 6 / X[1, 1, 1, 1] := 7 / X[1, 1, 1, 2] := 8 / ``` / As a prefix tree this would be represented as: / ```text / 0 1 / / \ | / 0 1 1 / / / \ | / 0 0 1 1 / /| /| | /| | / 1 2 0 2 0 0 1 2 / ``` / The type of values in indptrBuffers / indptrBuffers stores the sparsity structure. / Each two consecutive dimensions in a tensor correspond to a buffer in / indptrBuffers. A pair of consecutive values at `indptrBuffers[dim][i]` / and `indptrBuffers[dim][i + 1]` signify a range of nodes in / `indicesBuffers[dim + 1]` who are children of `indicesBuffers[dim][i]` node. / / For example, the indptrBuffers for the above X is: / ```text / indptrBuffer(X) = [ / [0, 2, 3], / [0, 1, 3, 4], / [0, 2, 4, 5, 8] / ]. / ```

func (*SparseTensorIndexCSF) IndptrBuffersLength 

func (rcv *SparseTensorIndexCSF) IndptrBuffersLength() int

func (*SparseTensorIndexCSF) IndptrType 

func (rcv *SparseTensorIndexCSF) IndptrType(obj *Int) *Int

/ CSF is a generalization of compressed sparse row (CSR) index. / See [smith2017knl](http://shaden.io/pub-files/smith2017knl.pdf) / / CSF index recursively compresses each dimension of a tensor into a set / of prefix trees. Each path from a root to leaf forms one tensor / non-zero index. CSF is implemented with two arrays of buffers and one / arrays of integers. / / For example, let X be a 2x3x4x5 tensor and let it have the following / 8 non-zero values: / ```text / X[0, 0, 0, 1] := 1 / X[0, 0, 0, 2] := 2 / X[0, 1, 0, 0] := 3 / X[0, 1, 0, 2] := 4 / X[0, 1, 1, 0] := 5 / X[1, 1, 1, 0] := 6 / X[1, 1, 1, 1] := 7 / X[1, 1, 1, 2] := 8 / ``` / As a prefix tree this would be represented as: / ```text / 0 1 / / \ | / 0 1 1 / / / \ | / 0 0 1 1 / /| /| | /| | / 1 2 0 2 0 0 1 2 / ``` / The type of values in indptrBuffers

func (*SparseTensorIndexCSF) Init 

func (rcv *SparseTensorIndexCSF) Init(buf []byte, i flatbuffers.UOffsetT)

func (*SparseTensorIndexCSF) MutateAxisOrder 

func (rcv *SparseTensorIndexCSF) MutateAxisOrder(j int, n int32) bool

/ axisOrder stores the sequence in which dimensions were traversed to / produce the prefix tree. / For example, the axisOrder for the above X is: / ```text / axisOrder(X) = [0, 1, 2, 3]. / ```

func (*SparseTensorIndexCSF) Table 

func (rcv *SparseTensorIndexCSF) Table() flatbuffers.Table

type Struct_ 

type Struct_ struct {
	// contains filtered or unexported fields
}

/ A Struct_ in the flatbuffer metadata is the same as an Arrow Struct / (according to the physical memory layout). We used Struct_ here as / Struct is a reserved word in Flatbuffers

func GetRootAsStruct_ 

func GetRootAsStruct_(buf []byte, offset flatbuffers.UOffsetT) *Struct_

func (*Struct_) Init 

func (rcv *Struct_) Init(buf []byte, i flatbuffers.UOffsetT)

func (*Struct_) Table 

func (rcv *Struct_) Table() flatbuffers.Table

type Tensor 

type Tensor struct {
	// contains filtered or unexported fields
}

func GetRootAsTensor 

func GetRootAsTensor(buf []byte, offset flatbuffers.UOffsetT) *Tensor

func (*Tensor) Data 

func (rcv *Tensor) Data(obj *Buffer) *Buffer

/ The location and size of the tensor's data

func (*Tensor) Init 

func (rcv *Tensor) Init(buf []byte, i flatbuffers.UOffsetT)

func (*Tensor) MutateStrides 

func (rcv *Tensor) MutateStrides(j int, n int64) bool

/ Non-negative byte offsets to advance one value cell along each dimension / If omitted, default to row-major order (C-like).

func (*Tensor) MutateTypeType 

func (rcv *Tensor) MutateTypeType(n Type) bool

func (*Tensor) Shape 

func (rcv *Tensor) Shape(obj *TensorDim, j int) bool

/ The type of data contained in a value cell. Currently only fixed-width / value types are supported, no strings or nested types / The dimensions of the tensor, optionally named

func (*Tensor) ShapeLength 

func (rcv *Tensor) ShapeLength() int

func (*Tensor) Strides 

func (rcv *Tensor) Strides(j int) int64

/ The dimensions of the tensor, optionally named / Non-negative byte offsets to advance one value cell along each dimension / If omitted, default to row-major order (C-like).

func (*Tensor) StridesLength 

func (rcv *Tensor) StridesLength() int

func (*Tensor) Table 

func (rcv *Tensor) Table() flatbuffers.Table

func (*Tensor) Type 

func (rcv *Tensor) Type(obj *flatbuffers.Table) bool

/ The type of data contained in a value cell. Currently only fixed-width / value types are supported, no strings or nested types

func (*Tensor) TypeType 

func (rcv *Tensor) TypeType() Type

type TensorDim 

type TensorDim struct {
	// contains filtered or unexported fields
}

/ ---------------------------------------------------------------------- / Data structures for dense tensors / Shape data for a single axis in a tensor

func GetRootAsTensorDim 

func GetRootAsTensorDim(buf []byte, offset flatbuffers.UOffsetT) *TensorDim

func (*TensorDim) Init 

func (rcv *TensorDim) Init(buf []byte, i flatbuffers.UOffsetT)

func (*TensorDim) MutateSize 

func (rcv *TensorDim) MutateSize(n int64) bool

/ Length of dimension

func (*TensorDim) Name 

func (rcv *TensorDim) Name() []byte

/ Name of the dimension, optional

func (*TensorDim) Size 

func (rcv *TensorDim) Size() int64

/ Length of dimension

func (*TensorDim) Table 

func (rcv *TensorDim) Table() flatbuffers.Table

type Time 

type Time struct {
	// contains filtered or unexported fields
}

/ Time is either a 32-bit or 64-bit signed integer type representing an / elapsed time since midnight, stored in either of four units: seconds, / milliseconds, microseconds or nanoseconds. / / The integer `bitWidth` depends on the `unit` and must be one of the following: / * SECOND and MILLISECOND: 32 bits / * MICROSECOND and NANOSECOND: 64 bits / / The allowed values are between 0 (inclusive) and 86400 (=24*60*60) seconds / (exclusive), adjusted for the time unit (for example, up to 86400000 / exclusive for the MILLISECOND unit). / This definition doesn't allow for leap seconds. Time values from / measurements with leap seconds will need to be corrected when ingesting / into Arrow (for example by replacing the value 86400 with 86399).

func GetRootAsTime 

func GetRootAsTime(buf []byte, offset flatbuffers.UOffsetT) *Time

func (*Time) BitWidth 

func (rcv *Time) BitWidth() int32

func (*Time) Init 

func (rcv *Time) Init(buf []byte, i flatbuffers.UOffsetT)

func (*Time) MutateBitWidth 

func (rcv *Time) MutateBitWidth(n int32) bool

func (*Time) MutateUnit 

func (rcv *Time) MutateUnit(n TimeUnit) bool

func (*Time) Table 

func (rcv *Time) Table() flatbuffers.Table

func (*Time) Unit 

func (rcv *Time) Unit() TimeUnit

type TimeUnit 

type TimeUnit int16
const (
	TimeUnitSECOND      TimeUnit = 0
	TimeUnitMILLISECOND TimeUnit = 1
	TimeUnitMICROSECOND TimeUnit = 2
	TimeUnitNANOSECOND  TimeUnit = 3
)

func (TimeUnit) String 

func (v TimeUnit) String() string

type Timestamp 

type Timestamp struct {
	// contains filtered or unexported fields
}

/ Timestamp is a 64-bit signed integer representing an elapsed time since a / fixed epoch, stored in either of four units: seconds, milliseconds, / microseconds or nanoseconds, and is optionally annotated with a timezone. / / Timestamp values do not include any leap seconds (in other words, all / days are considered 86400 seconds long). / / Timestamps with a non-empty timezone / ------------------------------------ / / If a Timestamp column has a non-empty timezone value, its epoch is / 1970-01-01 00:00:00 (January 1st 1970, midnight) in the *UTC* timezone / (the Unix epoch), regardless of the Timestamp's own timezone. / / Therefore, timestamp values with a non-empty timezone correspond to / physical points in time together with some additional information about / how the data was obtained and/or how to display it (the timezone). / / For example, the timestamp value 0 with the timezone string "Europe/Paris" / corresponds to "January 1st 1970, 00h00" in the UTC timezone, but the / application may prefer to display it as "January 1st 1970, 01h00" in / the Europe/Paris timezone (which is the same physical point in time). / / One consequence is that timestamp values with a non-empty timezone / can be compared and ordered directly, since they all share the same / well-known point of reference (the Unix epoch). / / Timestamps with an unset / empty timezone / ----------------------------------------- / / If a Timestamp column has no timezone value, its epoch is / 1970-01-01 00:00:00 (January 1st 1970, midnight) in an *unknown* timezone. / / Therefore, timestamp values without a timezone cannot be meaningfully / interpreted as physical points in time, but only as calendar / clock / indications ("wall clock time") in an unspecified timezone. / / For example, the timestamp value 0 with an empty timezone string / corresponds to "January 1st 1970, 00h00" in an unknown timezone: there / is not enough information to interpret it as a well-defined physical / point in time. / / One consequence is that timestamp values without a timezone cannot / be reliably compared or ordered, since they may have different points of / reference. In particular, it is *not* possible to interpret an unset / or empty timezone as the same as "UTC". / / Conversion between timezones / ---------------------------- / / If a Timestamp column has a non-empty timezone, changing the timezone / to a different non-empty value is a metadata-only operation: / the timestamp values need not change as their point of reference remains / the same (the Unix epoch). / / However, if a Timestamp column has no timezone value, changing it to a / non-empty value requires to think about the desired semantics. / One possibility is to assume that the original timestamp values are / relative to the epoch of the timezone being set; timestamp values should / then adjusted to the Unix epoch (for example, changing the timezone from / empty to "Europe/Paris" would require converting the timestamp values / from "Europe/Paris" to "UTC", which seems counter-intuitive but is / nevertheless correct). / / Guidelines for encoding data from external libraries / ---------------------------------------------------- / / Date & time libraries often have multiple different data types for temporal / data. In order to ease interoperability between different implementations the / Arrow project has some recommendations for encoding these types into a Timestamp / column. / / An "instant" represents a physical point in time that has no relevant timezone / (for example, astronomical data). To encode an instant, use a Timestamp with / the timezone string set to "UTC", and make sure the Timestamp values / are relative to the UTC epoch (January 1st 1970, midnight). / / A "zoned date-time" represents a physical point in time annotated with an / informative timezone (for example, the timezone in which the data was / recorded). To encode a zoned date-time, use a Timestamp with the timezone / string set to the name of the timezone, and make sure the Timestamp values / are relative to the UTC epoch (January 1st 1970, midnight). / / (There is some ambiguity between an instant and a zoned date-time with the / UTC timezone. Both of these are stored the same in Arrow. Typically, / this distinction does not matter. If it does, then an application should / use custom metadata or an extension type to distinguish between the two cases.) / / An "offset date-time" represents a physical point in time combined with an / explicit offset from UTC. To encode an offset date-time, use a Timestamp / with the timezone string set to the numeric timezone offset string / (e.g. "+03:00"), and make sure the Timestamp values are relative to / the UTC epoch (January 1st 1970, midnight). / / A "naive date-time" (also called "local date-time" in some libraries) / represents a wall clock time combined with a calendar date, but with / no indication of how to map this information to a physical point in time. / Naive date-times must be handled with care because of this missing / information, and also because daylight saving time (DST) may make / some values ambiguous or non-existent. A naive date-time may be / stored as a struct with Date and Time fields. However, it may also be / encoded into a Timestamp column with an empty timezone. The timestamp / values should be computed "as if" the timezone of the date-time values / was UTC; for example, the naive date-time "January 1st 1970, 00h00" would / be encoded as timestamp value 0.

func GetRootAsTimestamp 

func GetRootAsTimestamp(buf []byte, offset flatbuffers.UOffsetT) *Timestamp

func (*Timestamp) Init 

func (rcv *Timestamp) Init(buf []byte, i flatbuffers.UOffsetT)

func (*Timestamp) MutateUnit 

func (rcv *Timestamp) MutateUnit(n TimeUnit) bool

func (*Timestamp) Table 

func (rcv *Timestamp) Table() flatbuffers.Table

func (*Timestamp) Timezone 

func (rcv *Timestamp) Timezone() []byte

/ The timezone is an optional string indicating the name of a timezone, / one of: / / * As used in the Olson timezone database (the "tz database" or / "tzdata"), such as "America/New_York". / * An absolute timezone offset of the form "+XX:XX" or "-XX:XX", / such as "+07:30". / / Whether a timezone string is present indicates different semantics about / the data (see above).

func (*Timestamp) Unit 

func (rcv *Timestamp) Unit() TimeUnit

type Type 

type Type byte

/ ---------------------------------------------------------------------- / Top-level Type value, enabling extensible type-specific metadata. We can / add new logical types to Type without breaking backwards compatibility 

const (
	TypeNONE            Type = 0
	TypeNull            Type = 1
	TypeInt             Type = 2
	TypeFloatingPoint   Type = 3
	TypeBinary          Type = 4
	TypeUtf8            Type = 5
	TypeBool            Type = 6
	TypeDecimal         Type = 7
	TypeDate            Type = 8
	TypeTime            Type = 9
	TypeTimestamp       Type = 10
	TypeInterval        Type = 11
	TypeList            Type = 12
	TypeStruct_         Type = 13
	TypeUnion           Type = 14
	TypeFixedSizeBinary Type = 15
	TypeFixedSizeList   Type = 16
	TypeMap             Type = 17
	TypeDuration        Type = 18
	TypeLargeBinary     Type = 19
	TypeLargeUtf8       Type = 20
	TypeLargeList       Type = 21
)

func (Type) String 

func (v Type) String() string

type Union 

type Union struct {
	// contains filtered or unexported fields
}

/ A union is a complex type with children in Field / By default ids in the type vector refer to the offsets in the children / optionally typeIds provides an indirection between the child offset and the type id / for each child `typeIds[offset]` is the id used in the type vector

func GetRootAsUnion 

func GetRootAsUnion(buf []byte, offset flatbuffers.UOffsetT) *Union

func (*Union) Init 

func (rcv *Union) Init(buf []byte, i flatbuffers.UOffsetT)

func (*Union) Mode 

func (rcv *Union) Mode() UnionMode

func (*Union) MutateMode 

func (rcv *Union) MutateMode(n UnionMode) bool

func (*Union) MutateTypeIds 

func (rcv *Union) MutateTypeIds(j int, n int32) bool

func (*Union) Table 

func (rcv *Union) Table() flatbuffers.Table

func (*Union) TypeIds 

func (rcv *Union) TypeIds(j int) int32

func (*Union) TypeIdsLength 

func (rcv *Union) TypeIdsLength() int

type UnionMode 

type UnionMode int16
const (
	UnionModeSparse UnionMode = 0
	UnionModeDense  UnionMode = 1
)

func (UnionMode) String 

func (v UnionMode) String() string

type Utf8 

type Utf8 struct {
	// contains filtered or unexported fields
}

/ Unicode with UTF-8 encoding

func GetRootAsUtf8 

func GetRootAsUtf8(buf []byte, offset flatbuffers.UOffsetT) *Utf8

func (*Utf8) Init 

func (rcv *Utf8) Init(buf []byte, i flatbuffers.UOffsetT)

func (*Utf8) Table 

func (rcv *Utf8) Table() flatbuffers.Table

Source Files

View all Source files

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.