ceph/src/arrow/julia/Arrow/src/metadata/Schema.jl

   1 # Licensed to the Apache Software Foundation (ASF) under one
   2 # or more contributor license agreements.  See the NOTICE file
   3 # distributed with this work for additional information
   4 # regarding copyright ownership.  The ASF licenses this file
   5 # to you under the Apache License, Version 2.0 (the
   6 # "License"); you may not use this file except in compliance
   7 # with the License.  You may obtain a copy of the License at
   8 #
   9 # http://www.apache.org/licenses/LICENSE-2.0
  10 #
  11 # Unless required by applicable law or agreed to in writing, software
  12 # distributed under the License is distributed on an "AS IS" BASIS,
  13 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  14 # See the License for the specific language governing permissions and
  15 # limitations under the License.
  16
  17 FlatBuffers.@scopedenum MetadataVersion::Int16 V1 V2 V3 V4 V5
  18
  19 struct Null <: FlatBuffers.Table
  20     bytes::Vector{UInt8}
  21     pos::Base.Int
  22 end
  23
  24 Base.propertynames(x::Null) = ()
  25
  26 nullStart(b::FlatBuffers.Builder) = FlatBuffers.startobject!(b, 0)
  27 nullEnd(b::FlatBuffers.Builder) = FlatBuffers.endobject!(b)
  28
  29 struct Struct <: FlatBuffers.Table
  30     bytes::Vector{UInt8}
  31     pos::Base.Int
  32 end
  33
  34 Base.propertynames(x::Struct) = ()
  35
  36 structStart(b::FlatBuffers.Builder) = FlatBuffers.startobject!(b, 0)
  37 structEnd(b::FlatBuffers.Builder) = FlatBuffers.endobject!(b)
  38
  39 struct List <: FlatBuffers.Table
  40     bytes::Vector{UInt8}
  41     pos::Base.Int
  42 end
  43
  44 Base.propertynames(x::List) = ()
  45
  46 listStart(b::FlatBuffers.Builder) = FlatBuffers.startobject!(b, 0)
  47 listEnd(b::FlatBuffers.Builder) = FlatBuffers.endobject!(b)
  48
  49 struct LargeList <: FlatBuffers.Table
  50     bytes::Vector{UInt8}
  51     pos::Base.Int
  52 end
  53
  54 Base.propertynames(x::LargeList) = ()
  55
  56 largeListStart(b::FlatBuffers.Builder) = FlatBuffers.startobject!(b, 0)
  57 largeListEnd(b::FlatBuffers.Builder) = FlatBuffers.endobject!(b)
  58
  59 struct FixedSizeList <: FlatBuffers.Table
  60     bytes::Vector{UInt8}
  61     pos::Base.Int
  62 end
  63
  64 Base.propertynames(x::FixedSizeList) = (:listSize,)
  65
  66 function Base.getproperty(x::FixedSizeList, field::Symbol)
  67     if field === :listSize
  68         o = FlatBuffers.offset(x, 4)
  69         o != 0 && return FlatBuffers.get(x, o + FlatBuffers.pos(x), Int32)
  70         return Int32(0)
  71     end
  72     return nothing
  73 end
  74
  75 fixedSizeListStart(b::FlatBuffers.Builder) = FlatBuffers.startobject!(b, 1)
  76 fixedSizeListAddListSize(b::FlatBuffers.Builder, listSize::Int32) = FlatBuffers.prependslot!(b, 0, listSize, 0)
  77 fixedSizeListEnd(b::FlatBuffers.Builder) = FlatBuffers.endobject!(b)
  78
  79 struct Map <: FlatBuffers.Table
  80     bytes::Vector{UInt8}
  81     pos::Base.Int
  82 end
  83
  84 Base.propertynames(x::Map) = (:keysSorted,)
  85
  86 function Base.getproperty(x::Map, field::Symbol)
  87     if field === :keysSorted
  88         o = FlatBuffers.offset(x, 4)
  89         o != 0 && return FlatBuffers.get(x, o + FlatBuffers.pos(x), Base.Bool)
  90     end
  91     return nothing
  92 end
  93
  94 mapStart(b::FlatBuffers.Builder) = FlatBuffers.startobject!(b, 1)
  95 mapAddKeysSorted(b::FlatBuffers.Builder, keyssorted::Base.Bool) = FlatBuffers.prependslot!(b, 0, keyssorted, 0)
  96 mapEnd(b::FlatBuffers.Builder) = FlatBuffers.endobject!(b)
  97
  98 FlatBuffers.@scopedenum UnionMode::Int16 Sparse Dense
  99
 100 struct Union <: FlatBuffers.Table
 101     bytes::Vector{UInt8}
 102     pos::Base.Int
 103 end
 104
 105 Base.propertynames(x::Union) = (:mode, :typeIds)
 106
 107 function Base.getproperty(x::Union, field::Symbol)
 108     if field === :mode
 109         o = FlatBuffers.offset(x, 4)
 110         o != 0 && return FlatBuffers.get(x, o + FlatBuffers.pos(x), UnionMode)
 111         return UnionMode.Sparse
 112     elseif field === :typeIds
 113         o = FlatBuffers.offset(x, 6)
 114         o != 0 && return FlatBuffers.Array{Int32}(x, o)
 115     end
 116     return nothing
 117 end
 118
 119 unionStart(b::FlatBuffers.Builder) = FlatBuffers.startobject!(b, 2)
 120 unionAddMode(b::FlatBuffers.Builder, mode::UnionMode) = FlatBuffers.prependslot!(b, 0, mode, 0)
 121 unionAddTypeIds(b::FlatBuffers.Builder, typeIds::FlatBuffers.UOffsetT) = FlatBuffers.prependoffsetslot!(b, 1, typeIds, 0)
 122 unionStartTypeIdsVector(b::FlatBuffers.Builder, numelems) = FlatBuffers.startvector!(b, 4, numelems, 4)
 123 unionEnd(b::FlatBuffers.Builder) = FlatBuffers.endobject!(b)
 124
 125 struct Int <: FlatBuffers.Table
 126     bytes::Vector{UInt8}
 127     pos::Base.Int
 128 end
 129
 130 Base.propertynames(x::Int) = (:bitWidth, :is_signed)
 131
 132 function Base.getproperty(x::Int, field::Symbol)
 133     if field === :bitWidth
 134         o = FlatBuffers.offset(x, 4)
 135         o != 0 && return FlatBuffers.get(x, o + FlatBuffers.pos(x), Int32)
 136     elseif field === :is_signed
 137         o = FlatBuffers.offset(x, 6)
 138         o != 0 && return FlatBuffers.get(x, o + FlatBuffers.pos(x), Base.Bool)
 139         return false
 140     end
 141     return nothing
 142 end
 143
 144 intStart(b::FlatBuffers.Builder) = FlatBuffers.startobject!(b, 2)
 145 intAddBitWidth(b::FlatBuffers.Builder, bitwidth::Int32) = FlatBuffers.prependslot!(b, 0, bitwidth, 0)
 146 intAddIsSigned(b::FlatBuffers.Builder, issigned::Base.Bool) = FlatBuffers.prependslot!(b, 1, issigned, 0)
 147 intEnd(b::FlatBuffers.Builder) = FlatBuffers.endobject!(b)
 148
 149 FlatBuffers.@scopedenum Precision::Int16 HALF SINGLE DOUBLE
 150
 151 struct FloatingPoint <: FlatBuffers.Table
 152     bytes::Vector{UInt8}
 153     pos::Base.Int
 154 end
 155
 156 Base.propertynames(x::FloatingPoint) = (:precision,)
 157
 158 function Base.getproperty(x::FloatingPoint, field::Symbol)
 159     if field === :precision
 160         o = FlatBuffers.offset(x, 4)
 161         o != 0 && return FlatBuffers.get(x, o + FlatBuffers.pos(x), Precision)
 162         return Precision.HALF
 163     end
 164     return nothing
 165 end
 166
 167 floatingPointStart(b::FlatBuffers.Builder) = FlatBuffers.startobject!(b, 1)
 168 floatingPointAddPrecision(b::FlatBuffers.Builder, precision::Precision) = FlatBuffers.prependslot!(b, 0, precision, 0)
 169 floatingPointEnd(b::FlatBuffers.Builder) = FlatBuffers.endobject!(b)
 170
 171 struct Utf8 <: FlatBuffers.Table
 172     bytes::Vector{UInt8}
 173     pos::Base.Int
 174 end
 175
 176 Base.propertynames(x::Utf8) = ()
 177
 178 utf8Start(b::FlatBuffers.Builder) = FlatBuffers.startobject!(b, 0)
 179 utf8End(b::FlatBuffers.Builder) = FlatBuffers.endobject!(b)
 180
 181 struct Binary <: FlatBuffers.Table
 182     bytes::Vector{UInt8}
 183     pos::Base.Int
 184 end
 185
 186 Base.propertynames(x::Binary) = ()
 187
 188 binaryStart(b::FlatBuffers.Builder) = FlatBuffers.startobject!(b, 0)
 189 binaryEnd(b::FlatBuffers.Builder) = FlatBuffers.endobject!(b)
 190
 191 struct LargeUtf8 <: FlatBuffers.Table
 192     bytes::Vector{UInt8}
 193     pos::Base.Int
 194 end
 195
 196 Base.propertynames(x::LargeUtf8) = ()
 197
 198 largUtf8Start(b::FlatBuffers.Builder) = FlatBuffers.startobject!(b, 0)
 199 largUtf8End(b::FlatBuffers.Builder) = FlatBuffers.endobject!(b)
 200
 201 struct LargeBinary <: FlatBuffers.Table
 202     bytes::Vector{UInt8}
 203     pos::Base.Int
 204 end
 205
 206 Base.propertynames(x::LargeBinary) = ()
 207
 208 largeBinaryStart(b::FlatBuffers.Builder) = FlatBuffers.startobject!(b, 0)
 209 largeBinaryEnd(b::FlatBuffers.Builder) = FlatBuffers.endobject!(b)
 210
 211 struct FixedSizeBinary <: FlatBuffers.Table
 212     bytes::Vector{UInt8}
 213     pos::Base.Int
 214 end
 215
 216 Base.propertynames(x::FixedSizeBinary) = (:byteWidth,)
 217
 218 function Base.getproperty(x::FixedSizeBinary, field::Symbol)
 219     if field === :byteWidth
 220         o = FlatBuffers.offset(x, 4)
 221         o != 0 && return FlatBuffers.get(x, o + FlatBuffers.pos(x), Int32)
 222     end
 223     return nothing
 224 end
 225
 226 fixedSizeBinaryStart(b::FlatBuffers.Builder) = FlatBuffers.startobject!(b, 1)
 227 fixedSizeBinaryAddByteWidth(b::FlatBuffers.Builder, bytewidth::Int32) = FlatBuffers.prependslot!(b, 0, bytewidth, 0)
 228 fixedSizeBinaryEnd(b::FlatBuffers.Builder) = FlatBuffers.endobject!(b)
 229
 230 struct Bool <: FlatBuffers.Table
 231     bytes::Vector{UInt8}
 232     pos::Base.Int
 233 end
 234
 235 Base.propertynames(x::Bool) = ()
 236
 237 boolStart(b::FlatBuffers.Builder) = FlatBuffers.startobject!(b, 0)
 238 boolEnd(b::FlatBuffers.Builder) = FlatBuffers.endobject!(b)
 239
 240 struct Decimal <: FlatBuffers.Table
 241     bytes::Vector{UInt8}
 242     pos::Base.Int
 243 end
 244
 245 Base.propertynames(x::Decimal) = (:precision, :scale, :bitWidth)
 246
 247 function Base.getproperty(x::Decimal, field::Symbol)
 248     if field === :precision
 249         o = FlatBuffers.offset(x, 4)
 250         o != 0 && return FlatBuffers.get(x, o + FlatBuffers.pos(x), Int32)
 251         return Int32(0)
 252     elseif field === :scale
 253         o = FlatBuffers.offset(x, 6)
 254         o != 0 && return FlatBuffers.get(x, o + FlatBuffers.pos(x), Int32)
 255         return Int32(0)
 256     elseif field === :bitWidth
 257         o = FlatBuffers.offset(x, 8)
 258         o != 0 && return FlatBuffers.get(x, o + FlatBuffers.pos(x), Int32)
 259         return Int32(128)
 260     end
 261     return nothing
 262 end
 263
 264 decimalStart(b::FlatBuffers.Builder) = FlatBuffers.startobject!(b, 3)
 265 decimalAddPrecision(b::FlatBuffers.Builder, precision::Int32) = FlatBuffers.prependslot!(b, 0, precision, 0)
 266 decimalAddScale(b::FlatBuffers.Builder, scale::Int32) = FlatBuffers.prependslot!(b, 1, scale, 0)
 267 decimalAddBitWidth(b::FlatBuffers.Builder, bitWidth::Int32) = FlatBuffers.prependslot!(b, 2, bitWidth, Int32(128))
 268 decimalEnd(b::FlatBuffers.Builder) = FlatBuffers.endobject!(b)
 269
 270 FlatBuffers.@scopedenum DateUnit::Int16 DAY MILLISECOND
 271
 272 struct Date <: FlatBuffers.Table
 273     bytes::Vector{UInt8}
 274     pos::Base.Int
 275 end
 276
 277 Base.propertynames(x::Date) = (:unit,)
 278
 279 function Base.getproperty(x::Date, field::Symbol)
 280     if field === :unit
 281         o = FlatBuffers.offset(x, 4)
 282         o != 0 && return FlatBuffers.get(x, o + FlatBuffers.pos(x), DateUnit)
 283         return DateUnit.MILLISECOND
 284     end
 285     return nothing
 286 end
 287
 288 dateStart(b::FlatBuffers.Builder) = FlatBuffers.startobject!(b, 1)
 289 dateAddUnit(b::FlatBuffers.Builder, unit::DateUnit) = FlatBuffers.prependslot!(b, 0, unit, 1)
 290 dateEnd(b::FlatBuffers.Builder) = FlatBuffers.endobject!(b)
 291
 292 FlatBuffers.@scopedenum TimeUnit::Int16 SECOND MILLISECOND MICROSECOND NANOSECOND
 293
 294 struct Time <: FlatBuffers.Table
 295     bytes::Vector{UInt8}
 296     pos::Base.Int
 297 end
 298
 299 Base.propertynames(x::Time) = (:unit, :bitWidth)
 300
 301 function Base.getproperty(x::Time, field::Symbol)
 302     if field === :unit
 303         o = FlatBuffers.offset(x, 4)
 304         o != 0 && return FlatBuffers.get(x, o + FlatBuffers.pos(x), TimeUnit)
 305         return TimeUnit.MILLISECOND
 306     elseif field === :bitWidth
 307         o = FlatBuffers.offset(x, 6)
 308         o != 0 && return FlatBuffers.get(x, o + FlatBuffers.pos(x), Int32)
 309         return 32
 310     end
 311     return nothing
 312 end
 313
 314 timeStart(b::FlatBuffers.Builder) = FlatBuffers.startobject!(b, 2)
 315 timeAddUnit(b::FlatBuffers.Builder, unit::TimeUnit) = FlatBuffers.prependslot!(b, 0, unit, 1)
 316 timeAddBitWidth(b::FlatBuffers.Builder, bitwidth::Int32) = FlatBuffers.prependslot!(b, 1, bitwidth, 32)
 317 timeEnd(b::FlatBuffers.Builder) = FlatBuffers.endobject!(b)
 318
 319 struct Timestamp <: FlatBuffers.Table
 320     bytes::Vector{UInt8}
 321     pos::Base.Int
 322 end
 323
 324 Base.propertynames(x::Timestamp) = (:unit, :timezone)
 325
 326 function Base.getproperty(x::Timestamp, field::Symbol)
 327     if field === :unit
 328         o = FlatBuffers.offset(x, 4)
 329         o != 0 && return FlatBuffers.get(x, o + FlatBuffers.pos(x), TimeUnit)
 330         return TimeUnit.SECOND
 331     elseif field === :timezone
 332         o = FlatBuffers.offset(x, 6)
 333         o != 0 && return String(x, o + FlatBuffers.pos(x))
 334     end
 335     return nothing
 336 end
 337
 338 timestampStart(b::FlatBuffers.Builder) = FlatBuffers.startobject!(b, 2)
 339 timestampAddUnit(b::FlatBuffers.Builder, unit::TimeUnit) = FlatBuffers.prependslot!(b, 0, unit, 0)
 340 timestampAddTimezone(b::FlatBuffers.Builder, timezone::FlatBuffers.UOffsetT) = FlatBuffers.prependoffsetslot!(b, 1, timezone, 0)
 341 timestampEnd(b::FlatBuffers.Builder) = FlatBuffers.endobject!(b)
 342
 343 FlatBuffers.@scopedenum IntervalUnit::Int16 YEAR_MONTH DAY_TIME
 344
 345 struct Interval <: FlatBuffers.Table
 346     bytes::Vector{UInt8}
 347     pos::Base.Int
 348 end
 349
 350 Base.propertynames(x::Interval) = (:unit,)
 351
 352 function Base.getproperty(x::Interval, field::Symbol)
 353     if field === :unit
 354         o = FlatBuffers.offset(x, 4)
 355         o != 0 && return FlatBuffers.get(x, o + FlatBuffers.pos(x), IntervalUnit)
 356         return IntervalUnit.YEAR_MONTH
 357     end
 358     return nothing
 359 end
 360
 361 intervalStart(b::FlatBuffers.Builder) = FlatBuffers.startobject!(b, 1)
 362 intervalAddUnit(b::FlatBuffers.Builder, unit::IntervalUnit) = FlatBuffers.prependslot!(b, 0, unit, 0)
 363 intervalEnd(b::FlatBuffers.Builder) = FlatBuffers.endobject!(b)
 364
 365 struct Duration <: FlatBuffers.Table
 366     bytes::Vector{UInt8}
 367     pos::Base.Int
 368 end
 369
 370 Base.propertynames(x::Duration) = (:unit,)
 371
 372 function Base.getproperty(x::Duration, field::Symbol)
 373     if field === :unit
 374         o = FlatBuffers.offset(x, 4)
 375         o != 0 && return FlatBuffers.get(x, o + FlatBuffers.pos(x), TimeUnit)
 376         return TimeUnit.MILLISECOND
 377     end
 378     return nothing
 379 end
 380
 381 durationStart(b::FlatBuffers.Builder) = FlatBuffers.startobject!(b, 1)
 382 durationAddUnit(b::FlatBuffers.Builder, unit::TimeUnit) = FlatBuffers.prependslot!(b, 0, unit, 1)
 383 durationEnd(b::FlatBuffers.Builder) = FlatBuffers.endobject!(b)
 384
 385 function Type(b::UInt8)
 386     b == 1 && return Null
 387     b == 2 && return Int
 388     b == 3 && return FloatingPoint
 389     b == 4 && return Binary
 390     b == 5 && return Utf8
 391     b == 6 && return Bool
 392     b == 7 && return Decimal
 393     b == 8 && return Date
 394     b == 9 && return Time
 395     b == 10 && return Timestamp
 396     b == 11 && return Interval
 397     b == 12 && return List
 398     b == 13 && return Struct
 399     b == 14 && return Union
 400     b == 15 && return FixedSizeBinary
 401     b == 16 && return FixedSizeList
 402     b == 17 && return Map
 403     b == 18 && return Duration
 404     b == 19 && return LargeBinary
 405     b == 20 && return LargeUtf8
 406     b == 21 && return LargeList
 407     return nothing
 408 end
 409
 410 function Type(::Base.Type{T})::Int16 where {T}
 411     T == Null && return 1
 412     T == Int && return 2
 413     T == FloatingPoint && return 3
 414     T == Binary && return 4
 415     T == Utf8 && return 5
 416     T == Bool && return 6
 417     T == Decimal && return 7
 418     T == Date && return 8
 419     T == Time && return 9
 420     T == Timestamp && return 10
 421     T == Interval && return 11
 422     T == List && return 12
 423     T == Struct && return 13
 424     T == Union && return 14
 425     T == FixedSizeBinary && return 15
 426     T == FixedSizeList && return 16
 427     T == Map && return 17
 428     T == Duration && return 18
 429     T == LargeBinary && return 19
 430     T == LargeUtf8 && return 20
 431     T == LargeList && return 21
 432     return 0
 433 end
 434
 435 struct KeyValue <: FlatBuffers.Table
 436     bytes::Vector{UInt8}
 437     pos::Base.Int
 438 end
 439
 440 Base.propertynames(x::KeyValue) = (:key, :value)
 441
 442 function Base.getproperty(x::KeyValue, field::Symbol)
 443     if field === :key
 444         o = FlatBuffers.offset(x, 4)
 445         o != 0 && return String(x, o + FlatBuffers.pos(x))
 446     elseif field === :value
 447         o = FlatBuffers.offset(x, 6)
 448         o != 0 && return String(x, o + FlatBuffers.pos(x))
 449     end
 450     return nothing
 451 end
 452
 453 keyValueStart(b::FlatBuffers.Builder) = FlatBuffers.startobject!(b, 2)
 454 keyValueAddKey(b::FlatBuffers.Builder, key::FlatBuffers.UOffsetT) = FlatBuffers.prependoffsetslot!(b, 0, key, 0)
 455 keyValueAddValue(b::FlatBuffers.Builder, value::FlatBuffers.UOffsetT) = FlatBuffers.prependoffsetslot!(b, 1, value, 0)
 456 keyValueEnd(b::FlatBuffers.Builder) = FlatBuffers.endobject!(b)
 457
 458 FlatBuffers.@scopedenum DictionaryKind::Int16 DenseArray
 459
 460 struct DictionaryEncoding <: FlatBuffers.Table
 461     bytes::Vector{UInt8}
 462     pos::Base.Int
 463 end
 464
 465 Base.propertynames(x::DictionaryEncoding) = (:id, :indexType, :isOrdered, :dictionaryKind)
 466
 467 function Base.getproperty(x::DictionaryEncoding, field::Symbol)
 468     if field === :id
 469         o = FlatBuffers.offset(x, 4)
 470         o != 0 && return FlatBuffers.get(x, o + FlatBuffers.pos(x), Int64)
 471         return Int64(0)
 472     elseif field === :indexType
 473         o = FlatBuffers.offset(x, 6)
 474         if o != 0
 475             y = FlatBuffers.indirect(x, o + FlatBuffers.pos(x))
 476             return FlatBuffers.init(Int, FlatBuffers.bytes(x), y)
 477         end
 478     elseif field === :isOrdered
 479         o = FlatBuffers.offset(x, 8)
 480         o != 0 && return FlatBuffers.get(x, o + FlatBuffers.pos(x), Base.Bool)
 481         return false
 482     elseif field === :dictionaryKind
 483         o = FlatBuffers.offset(x, 10)
 484         o != 0 && return FlatBuffers.get(x, o + FlatBuffers.pos(x), DictionaryKind)
 485     end
 486     return nothing
 487 end
 488
 489 dictionaryEncodingStart(b::FlatBuffers.Builder) = FlatBuffers.startobject!(b, 3)
 490 dictionaryEncodingAddId(b::FlatBuffers.Builder, id::Int64) = FlatBuffers.prependslot!(b, 0, id, 0)
 491 dictionaryEncodingAddIndexType(b::FlatBuffers.Builder, indextype::FlatBuffers.UOffsetT) = FlatBuffers.prependoffsetslot!(b, 1, indextype, 0)
 492 dictionaryEncodingAddIsOrdered(b::FlatBuffers.Builder, isordered::Base.Bool) = FlatBuffers.prependslot!(b, 1, isordered, 0)
 493 dictionaryEncodingEnd(b::FlatBuffers.Builder) = FlatBuffers.endobject!(b)
 494
 495 struct Field <: FlatBuffers.Table
 496     bytes::Vector{UInt8}
 497     pos::Base.Int
 498 end
 499
 500 Base.propertynames(x::Field) = (:name, :nullable, :type, :dictionary, :children, :custom_metadata)
 501
 502 function Base.getproperty(x::Field, field::Symbol)
 503     if field === :name
 504         o = FlatBuffers.offset(x, 4)
 505         o != 0 && return String(x, o + FlatBuffers.pos(x))
 506     elseif field === :nullable
 507         o = FlatBuffers.offset(x, 6)
 508         o != 0 && return FlatBuffers.get(x, o + FlatBuffers.pos(x), Base.Bool)
 509         return false
 510     elseif field === :type
 511         o = FlatBuffers.offset(x, 8)
 512         if o != 0
 513             T = Type(FlatBuffers.get(x, o + FlatBuffers.pos(x), UInt8))
 514             o = FlatBuffers.offset(x, 10)
 515             pos = FlatBuffers.union(x, o)
 516             if o != 0
 517                 return FlatBuffers.init(T, FlatBuffers.bytes(x), pos)
 518             end
 519         end
 520     elseif field === :dictionary
 521         o = FlatBuffers.offset(x, 12)
 522         if o != 0
 523             y = FlatBuffers.indirect(x, o + FlatBuffers.pos(x))
 524             return FlatBuffers.init(DictionaryEncoding, FlatBuffers.bytes(x), y)
 525         end
 526     elseif field === :children
 527         o = FlatBuffers.offset(x, 14)
 528         if o != 0
 529             return FlatBuffers.Array{Field}(x, o)
 530         end
 531     elseif field === :custom_metadata
 532         o = FlatBuffers.offset(x, 16)
 533         if o != 0
 534             return FlatBuffers.Array{KeyValue}(x, o)
 535         end
 536     end
 537     return nothing
 538 end
 539
 540 fieldStart(b::FlatBuffers.Builder) = FlatBuffers.startobject!(b, 7)
 541 fieldAddName(b::FlatBuffers.Builder, name::FlatBuffers.UOffsetT) = FlatBuffers.prependoffsetslot!(b, 0, name, 0)
 542 fieldAddNullable(b::FlatBuffers.Builder, nullable::Base.Bool) = FlatBuffers.prependslot!(b, 1, nullable, false)
 543 fieldAddTypeType(b::FlatBuffers.Builder, ::Core.Type{T}) where {T} = FlatBuffers.prependslot!(b, 2, Type(T), 0)
 544 fieldAddType(b::FlatBuffers.Builder, type::FlatBuffers.UOffsetT) = FlatBuffers.prependoffsetslot!(b, 3, type, 0)
 545 fieldAddDictionary(b::FlatBuffers.Builder, dictionary::FlatBuffers.UOffsetT) = FlatBuffers.prependoffsetslot!(b, 4, dictionary, 0)
 546 fieldAddChildren(b::FlatBuffers.Builder, children::FlatBuffers.UOffsetT) = FlatBuffers.prependoffsetslot!(b, 5, children, 0)
 547 fieldStartChildrenVector(b::FlatBuffers.Builder, numelems) = FlatBuffers.startvector!(b, 4, numelems, 4)
 548 fieldAddCustomMetadata(b::FlatBuffers.Builder, custommetadata::FlatBuffers.UOffsetT) = FlatBuffers.prependoffsetslot!(b, 6, custommetadata, 0)
 549 fieldStartCustomMetadataVector(b::FlatBuffers.Builder, numelems) = FlatBuffers.startvector!(b, 4, numelems, 4)
 550 fieldEnd(b::FlatBuffers.Builder) = FlatBuffers.endobject!(b)
 551
 552 FlatBuffers.@scopedenum Endianness::Int16 Little Big
 553
 554 struct Buffer <: FlatBuffers.Struct
 555     bytes::Vector{UInt8}
 556     pos::Base.Int
 557 end
 558
 559 FlatBuffers.structsizeof(::Base.Type{Buffer}) = 16
 560
 561 Base.propertynames(x::Buffer) = (:offset, :length)
 562
 563 function Base.getproperty(x::Buffer, field::Symbol)
 564     if field === :offset
 565         return FlatBuffers.get(x, FlatBuffers.pos(x), Int64)
 566     elseif field === :length
 567         return FlatBuffers.get(x, FlatBuffers.pos(x) + 8, Int64)
 568     end
 569     return nothing
 570 end
 571
 572 function createBuffer(b::FlatBuffers.Builder, offset::Int64, length::Int64)
 573     FlatBuffers.prep!(b, 8, 16)
 574     prepend!(b, length)
 575     prepend!(b, offset)
 576     return FlatBuffers.offset(b)
 577 end
 578
 579 struct Schema <: FlatBuffers.Table
 580     bytes::Vector{UInt8}
 581     pos::Base.Int
 582 end
 583
 584 Base.propertynames(x::Schema) = (:endianness, :fields, :custom_metadata)
 585
 586 function Base.getproperty(x::Schema, field::Symbol)
 587     if field === :endianness
 588         o = FlatBuffers.offset(x, 4)
 589         o != 0 && return FlatBuffers.get(x, o + FlatBuffers.pos(x), Endianness)
 590     elseif field === :fields
 591         o = FlatBuffers.offset(x, 6)
 592         if o != 0
 593             return FlatBuffers.Array{Field}(x, o)
 594         end
 595     elseif field === :custom_metadata
 596         o = FlatBuffers.offset(x, 8)
 597         if o != 0
 598             return FlatBuffers.Array{KeyValue}(x, o)
 599         end
 600     end
 601     return nothing
 602 end
 603
 604 schemaStart(b::FlatBuffers.Builder) = FlatBuffers.startobject!(b, 3)
 605 schemaAddEndianness(b::FlatBuffers.Builder, endianness::Endianness) = FlatBuffers.prependslot!(b, 0, endianness, 0)
 606 schemaAddFields(b::FlatBuffers.Builder, fields::FlatBuffers.UOffsetT) = FlatBuffers.prependoffsetslot!(b, 1, fields, 0)
 607 schemaStartFieldsVector(b::FlatBuffers.Builder, numelems) = FlatBuffers.startvector!(b, 4, numelems, 4)
 608 schemaAddCustomMetadata(b::FlatBuffers.Builder, custommetadata::FlatBuffers.UOffsetT) = FlatBuffers.prependoffsetslot!(b, 2, custommetadata, 0)
 609 schemaStartCustomMetadataVector(b::FlatBuffers.Builder, numelems) = FlatBuffers.startvector!(b, 4, numelems, 4)
 610 schemaEnd(b::FlatBuffers.Builder) = FlatBuffers.endobject!(b)