Squashed 'third_party/flatbuffers/' changes from bc44fad35..8aa8b9139
8aa8b9139 Fix handling of +/-inf defaults in TS/rust/go/dart codegen (#7588)
001adf782 Add support for parsing proto map fields (#7613)
dbc58ab77 Fix help output for --gen-includes (#7611)
2facfeec7 Fix missing spaces in flatc help text (#7612)
4de2814c7 Fix: arduino platform build (#7625)
37b1acdaf Fix current official name of macOS (#7627)
a22434e2a Add missing #include <algorithm> for std::min/std::max uses, and #include <limits> for std::numeric_limits<> (#7624)
214cc9468 Bump Rust version to 22.10.26 before publication (#7622)
a4ff275d9 Added option to not requires an EoF token when parsing JSON (#7620)
15f32c690 python: object generation prefix and suffix (#7565)
051afd882 Add CreateSharedString to python builder (#7608)
728c033ad Add check for presence of realpath to CMakeLists.txt to support more platforms (#7603)
4c514483d Update DartTest.sh golden files (#7606)
c2d9c2080 [TS] Add support for fixed length arrays on Typescript (#5864) (#7021) (#7581)
e34ae4c6b `build.yml`: Fix missing 'v' in version
e54536127 `build.yml` Update to Kotlin Wrapper 1.0.5
49d9f941c `release.yml` Use env var for passphrase
cefc21c1f `release.yml` Add GPG key for Maven
3e64fa724 `release.yml`: Add Maven Steps
b15f3c57e `release_yml` Use new dotnet version
ff802c680 `release.yml` Use NuGet Key directly
b401957d5 `release.yml` Changed Push to follow examples
8c8151f8f `release.yml` Fix nuget push command
ebb7c203d `release.yml` Add Nuget support
203241ed3 FlatBuffers Version 22.10.26 (#7607)
ac485609c `setup.py`: Define version directly
de5b85aa6 `release.yml`: Switch to `python` directory
de3df2d88 `release.yml`: Add publishing to PyPi
043a24f2e [Python] Fixed the issue with nested unions relying on InitFromBuf. (#7576)
5a48b0d7d release.yml: Typo
ce307556f release.yml: Remove `npm ci`
cb616e27c Create release.yml (#7605)
a54ca1e75 FlatBuffers Version 22.10.25 (#7604)
5b3fadcc1 [vector] Allow to iterate with mutables (#7586)
872a49746 [Nim] Bfbs Nim Generator (#7534)
e30170296 Make type conversions explicit. (#7595)
f7b734438 Fix LongEnum definitions (#7596)
5792623df Rust fix compilation for no_std targets #2 (#7553)
0edb27528 Update Rust version (#7574)
acc6a20d3 tests/test.cpp contains a couple of tests that are only executed (#7571)
04cd037ba Fix #7580 by documenting union schema evolution rules (#7585)
e1c5db988 Turn on clippy for Rust and fix lints for non-generated code (#7575)
b80142b90 Update documentation to mention enum value attributes (#7570)
54418f371 Add support for metadata attributes for enum values (#7567) (#7568)
c92e78a9f FlatBuffers Version 22.9.29 (#7557)
d243b904c [TS] Make strict compliant and improve typings (#7549)
374f8fb5f Rust soundness fixes (#7518)
dadbff571 Moves swift package to root of repository so it can be used directly … (#7548)
76ddae006 FlatBuffers Version 22.9.24 (#7547)
cfe157ec5 Emit internal enums when swift_implementation_only (#7545)
413115858 [Python] Python fixed size array (#7529)
88046190e Upgrade grpc to 1.49.0 and make sure it builds (#7538)
72aa85a75 [C++] Rare bad buffer content alignment if sizeof(T) != alignof(T) (#7520)
bfceebb7f Fix conform (#7532)
git-subtree-dir: third_party/flatbuffers
git-subtree-split: 8aa8b9139eb330f27816a5b8b5bbef402fbe3632
Signed-off-by: James Kuszmaul <james.kuszmaul@bluerivertech.com>
Change-Id: I943faba499baf58e9f561b1e4734922188ba8626
diff --git a/tests/optional_scalars/OptionalByte.nim b/tests/optional_scalars/OptionalByte.nim
new file mode 100644
index 0000000..8a4e23c
--- /dev/null
+++ b/tests/optional_scalars/OptionalByte.nim
@@ -0,0 +1,14 @@
+#[ optional_scalars.OptionalByte
+ Automatically generated by the FlatBuffers compiler, do not modify.
+ Or modify. I'm a message, not a cop.
+
+ flatc version: 22.10.26
+
+ Declared by :
+ Rooting type : optional_scalars.ScalarStuff ()
+]#
+
+type OptionalByte*{.pure.} = enum
+ None = 0.int8,
+ One = 1.int8,
+ Two = 2.int8,
diff --git a/tests/optional_scalars/ScalarStuff.cs b/tests/optional_scalars/ScalarStuff.cs
index 85c1672..f1a6517 100644
--- a/tests/optional_scalars/ScalarStuff.cs
+++ b/tests/optional_scalars/ScalarStuff.cs
@@ -13,7 +13,7 @@
{
private Table __p;
public ByteBuffer ByteBuffer { get { return __p.bb; } }
- public static void ValidateVersion() { FlatBufferConstants.FLATBUFFERS_2_0_8(); }
+ public static void ValidateVersion() { FlatBufferConstants.FLATBUFFERS_22_10_26(); }
public static ScalarStuff GetRootAsScalarStuff(ByteBuffer _bb) { return GetRootAsScalarStuff(_bb, new ScalarStuff()); }
public static ScalarStuff GetRootAsScalarStuff(ByteBuffer _bb, ScalarStuff obj) { return (obj.__assign(_bb.GetInt(_bb.Position) + _bb.Position, _bb)); }
public static bool ScalarStuffBufferHasIdentifier(ByteBuffer _bb) { return Table.__has_identifier(_bb, "NULL"); }
diff --git a/tests/optional_scalars/ScalarStuff.java b/tests/optional_scalars/ScalarStuff.java
index f4890b1..f8adf64 100644
--- a/tests/optional_scalars/ScalarStuff.java
+++ b/tests/optional_scalars/ScalarStuff.java
@@ -9,7 +9,7 @@
@SuppressWarnings("unused")
public final class ScalarStuff extends Table {
- public static void ValidateVersion() { Constants.FLATBUFFERS_2_0_8(); }
+ public static void ValidateVersion() { Constants.FLATBUFFERS_22_10_26(); }
public static ScalarStuff getRootAsScalarStuff(ByteBuffer _bb) { return getRootAsScalarStuff(_bb, new ScalarStuff()); }
public static ScalarStuff getRootAsScalarStuff(ByteBuffer _bb, ScalarStuff obj) { _bb.order(ByteOrder.LITTLE_ENDIAN); return (obj.__assign(_bb.getInt(_bb.position()) + _bb.position(), _bb)); }
public static boolean ScalarStuffBufferHasIdentifier(ByteBuffer _bb) { return __has_identifier(_bb, "NULL"); }
diff --git a/tests/optional_scalars/ScalarStuff.kt b/tests/optional_scalars/ScalarStuff.kt
index e9067bb..22d1796 100644
--- a/tests/optional_scalars/ScalarStuff.kt
+++ b/tests/optional_scalars/ScalarStuff.kt
@@ -197,7 +197,7 @@
return if(o != 0) bb.get(o + bb_pos) else 1
}
companion object {
- fun validateVersion() = Constants.FLATBUFFERS_2_0_8()
+ fun validateVersion() = Constants.FLATBUFFERS_22_10_26()
fun getRootAsScalarStuff(_bb: ByteBuffer): ScalarStuff = getRootAsScalarStuff(_bb, ScalarStuff())
fun getRootAsScalarStuff(_bb: ByteBuffer, obj: ScalarStuff): ScalarStuff {
_bb.order(ByteOrder.LITTLE_ENDIAN)
diff --git a/tests/optional_scalars/ScalarStuff.nim b/tests/optional_scalars/ScalarStuff.nim
new file mode 100644
index 0000000..6df1403
--- /dev/null
+++ b/tests/optional_scalars/ScalarStuff.nim
@@ -0,0 +1,331 @@
+#[ optional_scalars.ScalarStuff
+ Automatically generated by the FlatBuffers compiler, do not modify.
+ Or modify. I'm a message, not a cop.
+
+ flatc version: 22.10.26
+
+ Declared by :
+ Rooting type : optional_scalars.ScalarStuff ()
+]#
+
+import OptionalByte as optional_scalars_OptionalByte
+import flatbuffers
+import std/options
+
+type ScalarStuff* = object of FlatObj
+func justI8*(self: ScalarStuff): int8 =
+ let o = self.tab.Offset(4)
+ if o != 0:
+ return Get[int8](self.tab, self.tab.Pos + o)
+ return 0
+func `justI8=`*(self: var ScalarStuff, n: int8): bool =
+ return self.tab.MutateSlot(4, n)
+func maybeI8*(self: ScalarStuff): Option[int8] =
+ let o = self.tab.Offset(6)
+ if o != 0:
+ return some(Get[int8](self.tab, self.tab.Pos + o))
+func `maybeI8=`*(self: var ScalarStuff, n: Option[int8]): bool =
+ return self.tab.MutateSlot(6, n)
+func defaultI8*(self: ScalarStuff): int8 =
+ let o = self.tab.Offset(8)
+ if o != 0:
+ return Get[int8](self.tab, self.tab.Pos + o)
+ return 42
+func `defaultI8=`*(self: var ScalarStuff, n: int8): bool =
+ return self.tab.MutateSlot(8, n)
+func justU8*(self: ScalarStuff): uint8 =
+ let o = self.tab.Offset(10)
+ if o != 0:
+ return Get[uint8](self.tab, self.tab.Pos + o)
+ return 0
+func `justU8=`*(self: var ScalarStuff, n: uint8): bool =
+ return self.tab.MutateSlot(10, n)
+func maybeU8*(self: ScalarStuff): Option[uint8] =
+ let o = self.tab.Offset(12)
+ if o != 0:
+ return some(Get[uint8](self.tab, self.tab.Pos + o))
+func `maybeU8=`*(self: var ScalarStuff, n: Option[uint8]): bool =
+ return self.tab.MutateSlot(12, n)
+func defaultU8*(self: ScalarStuff): uint8 =
+ let o = self.tab.Offset(14)
+ if o != 0:
+ return Get[uint8](self.tab, self.tab.Pos + o)
+ return 42
+func `defaultU8=`*(self: var ScalarStuff, n: uint8): bool =
+ return self.tab.MutateSlot(14, n)
+func justI16*(self: ScalarStuff): int16 =
+ let o = self.tab.Offset(16)
+ if o != 0:
+ return Get[int16](self.tab, self.tab.Pos + o)
+ return 0
+func `justI16=`*(self: var ScalarStuff, n: int16): bool =
+ return self.tab.MutateSlot(16, n)
+func maybeI16*(self: ScalarStuff): Option[int16] =
+ let o = self.tab.Offset(18)
+ if o != 0:
+ return some(Get[int16](self.tab, self.tab.Pos + o))
+func `maybeI16=`*(self: var ScalarStuff, n: Option[int16]): bool =
+ return self.tab.MutateSlot(18, n)
+func defaultI16*(self: ScalarStuff): int16 =
+ let o = self.tab.Offset(20)
+ if o != 0:
+ return Get[int16](self.tab, self.tab.Pos + o)
+ return 42
+func `defaultI16=`*(self: var ScalarStuff, n: int16): bool =
+ return self.tab.MutateSlot(20, n)
+func justU16*(self: ScalarStuff): uint16 =
+ let o = self.tab.Offset(22)
+ if o != 0:
+ return Get[uint16](self.tab, self.tab.Pos + o)
+ return 0
+func `justU16=`*(self: var ScalarStuff, n: uint16): bool =
+ return self.tab.MutateSlot(22, n)
+func maybeU16*(self: ScalarStuff): Option[uint16] =
+ let o = self.tab.Offset(24)
+ if o != 0:
+ return some(Get[uint16](self.tab, self.tab.Pos + o))
+func `maybeU16=`*(self: var ScalarStuff, n: Option[uint16]): bool =
+ return self.tab.MutateSlot(24, n)
+func defaultU16*(self: ScalarStuff): uint16 =
+ let o = self.tab.Offset(26)
+ if o != 0:
+ return Get[uint16](self.tab, self.tab.Pos + o)
+ return 42
+func `defaultU16=`*(self: var ScalarStuff, n: uint16): bool =
+ return self.tab.MutateSlot(26, n)
+func justI32*(self: ScalarStuff): int32 =
+ let o = self.tab.Offset(28)
+ if o != 0:
+ return Get[int32](self.tab, self.tab.Pos + o)
+ return 0
+func `justI32=`*(self: var ScalarStuff, n: int32): bool =
+ return self.tab.MutateSlot(28, n)
+func maybeI32*(self: ScalarStuff): Option[int32] =
+ let o = self.tab.Offset(30)
+ if o != 0:
+ return some(Get[int32](self.tab, self.tab.Pos + o))
+func `maybeI32=`*(self: var ScalarStuff, n: Option[int32]): bool =
+ return self.tab.MutateSlot(30, n)
+func defaultI32*(self: ScalarStuff): int32 =
+ let o = self.tab.Offset(32)
+ if o != 0:
+ return Get[int32](self.tab, self.tab.Pos + o)
+ return 42
+func `defaultI32=`*(self: var ScalarStuff, n: int32): bool =
+ return self.tab.MutateSlot(32, n)
+func justU32*(self: ScalarStuff): uint32 =
+ let o = self.tab.Offset(34)
+ if o != 0:
+ return Get[uint32](self.tab, self.tab.Pos + o)
+ return 0
+func `justU32=`*(self: var ScalarStuff, n: uint32): bool =
+ return self.tab.MutateSlot(34, n)
+func maybeU32*(self: ScalarStuff): Option[uint32] =
+ let o = self.tab.Offset(36)
+ if o != 0:
+ return some(Get[uint32](self.tab, self.tab.Pos + o))
+func `maybeU32=`*(self: var ScalarStuff, n: Option[uint32]): bool =
+ return self.tab.MutateSlot(36, n)
+func defaultU32*(self: ScalarStuff): uint32 =
+ let o = self.tab.Offset(38)
+ if o != 0:
+ return Get[uint32](self.tab, self.tab.Pos + o)
+ return 42
+func `defaultU32=`*(self: var ScalarStuff, n: uint32): bool =
+ return self.tab.MutateSlot(38, n)
+func justI64*(self: ScalarStuff): int64 =
+ let o = self.tab.Offset(40)
+ if o != 0:
+ return Get[int64](self.tab, self.tab.Pos + o)
+ return 0
+func `justI64=`*(self: var ScalarStuff, n: int64): bool =
+ return self.tab.MutateSlot(40, n)
+func maybeI64*(self: ScalarStuff): Option[int64] =
+ let o = self.tab.Offset(42)
+ if o != 0:
+ return some(Get[int64](self.tab, self.tab.Pos + o))
+func `maybeI64=`*(self: var ScalarStuff, n: Option[int64]): bool =
+ return self.tab.MutateSlot(42, n)
+func defaultI64*(self: ScalarStuff): int64 =
+ let o = self.tab.Offset(44)
+ if o != 0:
+ return Get[int64](self.tab, self.tab.Pos + o)
+ return 42
+func `defaultI64=`*(self: var ScalarStuff, n: int64): bool =
+ return self.tab.MutateSlot(44, n)
+func justU64*(self: ScalarStuff): uint64 =
+ let o = self.tab.Offset(46)
+ if o != 0:
+ return Get[uint64](self.tab, self.tab.Pos + o)
+ return 0
+func `justU64=`*(self: var ScalarStuff, n: uint64): bool =
+ return self.tab.MutateSlot(46, n)
+func maybeU64*(self: ScalarStuff): Option[uint64] =
+ let o = self.tab.Offset(48)
+ if o != 0:
+ return some(Get[uint64](self.tab, self.tab.Pos + o))
+func `maybeU64=`*(self: var ScalarStuff, n: Option[uint64]): bool =
+ return self.tab.MutateSlot(48, n)
+func defaultU64*(self: ScalarStuff): uint64 =
+ let o = self.tab.Offset(50)
+ if o != 0:
+ return Get[uint64](self.tab, self.tab.Pos + o)
+ return 42
+func `defaultU64=`*(self: var ScalarStuff, n: uint64): bool =
+ return self.tab.MutateSlot(50, n)
+func justF32*(self: ScalarStuff): float32 =
+ let o = self.tab.Offset(52)
+ if o != 0:
+ return Get[float32](self.tab, self.tab.Pos + o)
+ return 0.0
+func `justF32=`*(self: var ScalarStuff, n: float32): bool =
+ return self.tab.MutateSlot(52, n)
+func maybeF32*(self: ScalarStuff): Option[float32] =
+ let o = self.tab.Offset(54)
+ if o != 0:
+ return some(Get[float32](self.tab, self.tab.Pos + o))
+func `maybeF32=`*(self: var ScalarStuff, n: Option[float32]): bool =
+ return self.tab.MutateSlot(54, n)
+func defaultF32*(self: ScalarStuff): float32 =
+ let o = self.tab.Offset(56)
+ if o != 0:
+ return Get[float32](self.tab, self.tab.Pos + o)
+ return 42.0
+func `defaultF32=`*(self: var ScalarStuff, n: float32): bool =
+ return self.tab.MutateSlot(56, n)
+func justF64*(self: ScalarStuff): float64 =
+ let o = self.tab.Offset(58)
+ if o != 0:
+ return Get[float64](self.tab, self.tab.Pos + o)
+ return 0.0
+func `justF64=`*(self: var ScalarStuff, n: float64): bool =
+ return self.tab.MutateSlot(58, n)
+func maybeF64*(self: ScalarStuff): Option[float64] =
+ let o = self.tab.Offset(60)
+ if o != 0:
+ return some(Get[float64](self.tab, self.tab.Pos + o))
+func `maybeF64=`*(self: var ScalarStuff, n: Option[float64]): bool =
+ return self.tab.MutateSlot(60, n)
+func defaultF64*(self: ScalarStuff): float64 =
+ let o = self.tab.Offset(62)
+ if o != 0:
+ return Get[float64](self.tab, self.tab.Pos + o)
+ return 42.0
+func `defaultF64=`*(self: var ScalarStuff, n: float64): bool =
+ return self.tab.MutateSlot(62, n)
+func justBool*(self: ScalarStuff): bool =
+ let o = self.tab.Offset(64)
+ if o != 0:
+ return Get[bool](self.tab, self.tab.Pos + o)
+ return false
+func `justBool=`*(self: var ScalarStuff, n: bool): bool =
+ return self.tab.MutateSlot(64, n)
+func maybeBool*(self: ScalarStuff): Option[bool] =
+ let o = self.tab.Offset(66)
+ if o != 0:
+ return some(Get[bool](self.tab, self.tab.Pos + o))
+func `maybeBool=`*(self: var ScalarStuff, n: Option[bool]): bool =
+ return self.tab.MutateSlot(66, n)
+func defaultBool*(self: ScalarStuff): bool =
+ let o = self.tab.Offset(68)
+ if o != 0:
+ return Get[bool](self.tab, self.tab.Pos + o)
+ return true
+func `defaultBool=`*(self: var ScalarStuff, n: bool): bool =
+ return self.tab.MutateSlot(68, n)
+func justEnum*(self: ScalarStuff): optional_scalars_OptionalByte.OptionalByte =
+ let o = self.tab.Offset(70)
+ if o != 0:
+ return optional_scalars_OptionalByte.OptionalByte(Get[int8](self.tab, self.tab.Pos + o))
+ return type(result)(0)
+func `justEnum=`*(self: var ScalarStuff, n: optional_scalars_OptionalByte.OptionalByte): bool =
+ return self.tab.MutateSlot(70, n)
+func maybeEnum*(self: ScalarStuff): Option[optional_scalars_OptionalByte.OptionalByte] =
+ let o = self.tab.Offset(72)
+ if o != 0:
+ return some(optional_scalars_OptionalByte.OptionalByte(Get[int8](self.tab, self.tab.Pos + o)))
+func `maybeEnum=`*(self: var ScalarStuff, n: Option[optional_scalars_OptionalByte.OptionalByte]): bool =
+ return self.tab.MutateSlot(72, n)
+func defaultEnum*(self: ScalarStuff): optional_scalars_OptionalByte.OptionalByte =
+ let o = self.tab.Offset(74)
+ if o != 0:
+ return optional_scalars_OptionalByte.OptionalByte(Get[int8](self.tab, self.tab.Pos + o))
+ return type(result)(1)
+func `defaultEnum=`*(self: var ScalarStuff, n: optional_scalars_OptionalByte.OptionalByte): bool =
+ return self.tab.MutateSlot(74, n)
+proc ScalarStuffStart*(builder: var Builder) =
+ builder.StartObject(36)
+proc ScalarStuffAddjustI8*(builder: var Builder, justI8: int8) =
+ builder.PrependSlot(0, justI8, default(int8))
+proc ScalarStuffAddmaybeI8*(builder: var Builder, maybeI8: int8) =
+ builder.PrependSlot(1, maybeI8, default(int8))
+proc ScalarStuffAdddefaultI8*(builder: var Builder, defaultI8: int8) =
+ builder.PrependSlot(2, defaultI8, default(int8))
+proc ScalarStuffAddjustU8*(builder: var Builder, justU8: uint8) =
+ builder.PrependSlot(3, justU8, default(uint8))
+proc ScalarStuffAddmaybeU8*(builder: var Builder, maybeU8: uint8) =
+ builder.PrependSlot(4, maybeU8, default(uint8))
+proc ScalarStuffAdddefaultU8*(builder: var Builder, defaultU8: uint8) =
+ builder.PrependSlot(5, defaultU8, default(uint8))
+proc ScalarStuffAddjustI16*(builder: var Builder, justI16: int16) =
+ builder.PrependSlot(6, justI16, default(int16))
+proc ScalarStuffAddmaybeI16*(builder: var Builder, maybeI16: int16) =
+ builder.PrependSlot(7, maybeI16, default(int16))
+proc ScalarStuffAdddefaultI16*(builder: var Builder, defaultI16: int16) =
+ builder.PrependSlot(8, defaultI16, default(int16))
+proc ScalarStuffAddjustU16*(builder: var Builder, justU16: uint16) =
+ builder.PrependSlot(9, justU16, default(uint16))
+proc ScalarStuffAddmaybeU16*(builder: var Builder, maybeU16: uint16) =
+ builder.PrependSlot(10, maybeU16, default(uint16))
+proc ScalarStuffAdddefaultU16*(builder: var Builder, defaultU16: uint16) =
+ builder.PrependSlot(11, defaultU16, default(uint16))
+proc ScalarStuffAddjustI32*(builder: var Builder, justI32: int32) =
+ builder.PrependSlot(12, justI32, default(int32))
+proc ScalarStuffAddmaybeI32*(builder: var Builder, maybeI32: int32) =
+ builder.PrependSlot(13, maybeI32, default(int32))
+proc ScalarStuffAdddefaultI32*(builder: var Builder, defaultI32: int32) =
+ builder.PrependSlot(14, defaultI32, default(int32))
+proc ScalarStuffAddjustU32*(builder: var Builder, justU32: uint32) =
+ builder.PrependSlot(15, justU32, default(uint32))
+proc ScalarStuffAddmaybeU32*(builder: var Builder, maybeU32: uint32) =
+ builder.PrependSlot(16, maybeU32, default(uint32))
+proc ScalarStuffAdddefaultU32*(builder: var Builder, defaultU32: uint32) =
+ builder.PrependSlot(17, defaultU32, default(uint32))
+proc ScalarStuffAddjustI64*(builder: var Builder, justI64: int64) =
+ builder.PrependSlot(18, justI64, default(int64))
+proc ScalarStuffAddmaybeI64*(builder: var Builder, maybeI64: int64) =
+ builder.PrependSlot(19, maybeI64, default(int64))
+proc ScalarStuffAdddefaultI64*(builder: var Builder, defaultI64: int64) =
+ builder.PrependSlot(20, defaultI64, default(int64))
+proc ScalarStuffAddjustU64*(builder: var Builder, justU64: uint64) =
+ builder.PrependSlot(21, justU64, default(uint64))
+proc ScalarStuffAddmaybeU64*(builder: var Builder, maybeU64: uint64) =
+ builder.PrependSlot(22, maybeU64, default(uint64))
+proc ScalarStuffAdddefaultU64*(builder: var Builder, defaultU64: uint64) =
+ builder.PrependSlot(23, defaultU64, default(uint64))
+proc ScalarStuffAddjustF32*(builder: var Builder, justF32: float32) =
+ builder.PrependSlot(24, justF32, default(float32))
+proc ScalarStuffAddmaybeF32*(builder: var Builder, maybeF32: float32) =
+ builder.PrependSlot(25, maybeF32, default(float32))
+proc ScalarStuffAdddefaultF32*(builder: var Builder, defaultF32: float32) =
+ builder.PrependSlot(26, defaultF32, default(float32))
+proc ScalarStuffAddjustF64*(builder: var Builder, justF64: float64) =
+ builder.PrependSlot(27, justF64, default(float64))
+proc ScalarStuffAddmaybeF64*(builder: var Builder, maybeF64: float64) =
+ builder.PrependSlot(28, maybeF64, default(float64))
+proc ScalarStuffAdddefaultF64*(builder: var Builder, defaultF64: float64) =
+ builder.PrependSlot(29, defaultF64, default(float64))
+proc ScalarStuffAddjustBool*(builder: var Builder, justBool: bool) =
+ builder.PrependSlot(30, justBool, default(bool))
+proc ScalarStuffAddmaybeBool*(builder: var Builder, maybeBool: bool) =
+ builder.PrependSlot(31, maybeBool, default(bool))
+proc ScalarStuffAdddefaultBool*(builder: var Builder, defaultBool: bool) =
+ builder.PrependSlot(32, defaultBool, default(bool))
+proc ScalarStuffAddjustEnum*(builder: var Builder, justEnum: int8) =
+ builder.PrependSlot(33, justEnum, default(int8))
+proc ScalarStuffAddmaybeEnum*(builder: var Builder, maybeEnum: int8) =
+ builder.PrependSlot(34, maybeEnum, default(int8))
+proc ScalarStuffAdddefaultEnum*(builder: var Builder, defaultEnum: int8) =
+ builder.PrependSlot(35, defaultEnum, default(int8))
+proc ScalarStuffEnd*(builder: var Builder): uoffset =
+ return builder.EndObject()
diff --git a/tests/optional_scalars/ScalarStuff.py b/tests/optional_scalars/ScalarStuff.py
index 4dea123..ca7c253 100644
--- a/tests/optional_scalars/ScalarStuff.py
+++ b/tests/optional_scalars/ScalarStuff.py
@@ -443,6 +443,11 @@
return cls.InitFromObj(scalarStuff)
@classmethod
+ def InitFromPackedBuf(cls, buf, pos=0):
+ n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, pos)
+ return cls.InitFromBuf(buf, pos+n)
+
+ @classmethod
def InitFromObj(cls, scalarStuff):
x = ScalarStuffT()
x._UnPack(scalarStuff)
diff --git a/tests/optional_scalars/optional_scalars/optional_byte_generated.rs b/tests/optional_scalars/optional_scalars/optional_byte_generated.rs
index dae1366..9cb47c6 100644
--- a/tests/optional_scalars/optional_scalars/optional_byte_generated.rs
+++ b/tests/optional_scalars/optional_scalars/optional_byte_generated.rs
@@ -59,10 +59,8 @@
impl<'a> flatbuffers::Follow<'a> for OptionalByte {
type Inner = Self;
#[inline]
- fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
- let b = unsafe {
- flatbuffers::read_scalar_at::<i8>(buf, loc)
- };
+ unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
+ let b = flatbuffers::read_scalar_at::<i8>(buf, loc);
Self(b)
}
}
@@ -70,21 +68,21 @@
impl flatbuffers::Push for OptionalByte {
type Output = OptionalByte;
#[inline]
- fn push(&self, dst: &mut [u8], _rest: &[u8]) {
- unsafe { flatbuffers::emplace_scalar::<i8>(dst, self.0); }
+ unsafe fn push(&self, dst: &mut [u8], _written_len: usize) {
+ flatbuffers::emplace_scalar::<i8>(dst, self.0);
}
}
impl flatbuffers::EndianScalar for OptionalByte {
+ type Scalar = i8;
#[inline]
- fn to_little_endian(self) -> Self {
- let b = i8::to_le(self.0);
- Self(b)
+ fn to_little_endian(self) -> i8 {
+ self.0.to_le()
}
#[inline]
#[allow(clippy::wrong_self_convention)]
- fn from_little_endian(self) -> Self {
- let b = i8::from_le(self.0);
+ fn from_little_endian(v: i8) -> Self {
+ let b = i8::from_le(v);
Self(b)
}
}
diff --git a/tests/optional_scalars/optional_scalars/scalar_stuff_generated.rs b/tests/optional_scalars/optional_scalars/scalar_stuff_generated.rs
index e201cc0..8916932 100644
--- a/tests/optional_scalars/optional_scalars/scalar_stuff_generated.rs
+++ b/tests/optional_scalars/optional_scalars/scalar_stuff_generated.rs
@@ -19,8 +19,8 @@
impl<'a> flatbuffers::Follow<'a> for ScalarStuff<'a> {
type Inner = ScalarStuff<'a>;
#[inline]
- fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
- Self { _tab: flatbuffers::Table { buf, loc } }
+ unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
+ Self { _tab: flatbuffers::Table::new(buf, loc) }
}
}
@@ -67,7 +67,7 @@
}
#[inline]
- pub fn init_from_table(table: flatbuffers::Table<'a>) -> Self {
+ pub unsafe fn init_from_table(table: flatbuffers::Table<'a>) -> Self {
ScalarStuff { _tab: table }
}
#[allow(unused_mut)]
@@ -194,147 +194,255 @@
#[inline]
pub fn just_i8(&self) -> i8 {
- self._tab.get::<i8>(ScalarStuff::VT_JUST_I8, Some(0)).unwrap()
+ // Safety:
+ // Created from valid Table for this object
+ // which contains a valid value in this slot
+ unsafe { self._tab.get::<i8>(ScalarStuff::VT_JUST_I8, Some(0)).unwrap()}
}
#[inline]
pub fn maybe_i8(&self) -> Option<i8> {
- self._tab.get::<i8>(ScalarStuff::VT_MAYBE_I8, None)
+ // Safety:
+ // Created from valid Table for this object
+ // which contains a valid value in this slot
+ unsafe { self._tab.get::<i8>(ScalarStuff::VT_MAYBE_I8, None)}
}
#[inline]
pub fn default_i8(&self) -> i8 {
- self._tab.get::<i8>(ScalarStuff::VT_DEFAULT_I8, Some(42)).unwrap()
+ // Safety:
+ // Created from valid Table for this object
+ // which contains a valid value in this slot
+ unsafe { self._tab.get::<i8>(ScalarStuff::VT_DEFAULT_I8, Some(42)).unwrap()}
}
#[inline]
pub fn just_u8(&self) -> u8 {
- self._tab.get::<u8>(ScalarStuff::VT_JUST_U8, Some(0)).unwrap()
+ // Safety:
+ // Created from valid Table for this object
+ // which contains a valid value in this slot
+ unsafe { self._tab.get::<u8>(ScalarStuff::VT_JUST_U8, Some(0)).unwrap()}
}
#[inline]
pub fn maybe_u8(&self) -> Option<u8> {
- self._tab.get::<u8>(ScalarStuff::VT_MAYBE_U8, None)
+ // Safety:
+ // Created from valid Table for this object
+ // which contains a valid value in this slot
+ unsafe { self._tab.get::<u8>(ScalarStuff::VT_MAYBE_U8, None)}
}
#[inline]
pub fn default_u8(&self) -> u8 {
- self._tab.get::<u8>(ScalarStuff::VT_DEFAULT_U8, Some(42)).unwrap()
+ // Safety:
+ // Created from valid Table for this object
+ // which contains a valid value in this slot
+ unsafe { self._tab.get::<u8>(ScalarStuff::VT_DEFAULT_U8, Some(42)).unwrap()}
}
#[inline]
pub fn just_i16(&self) -> i16 {
- self._tab.get::<i16>(ScalarStuff::VT_JUST_I16, Some(0)).unwrap()
+ // Safety:
+ // Created from valid Table for this object
+ // which contains a valid value in this slot
+ unsafe { self._tab.get::<i16>(ScalarStuff::VT_JUST_I16, Some(0)).unwrap()}
}
#[inline]
pub fn maybe_i16(&self) -> Option<i16> {
- self._tab.get::<i16>(ScalarStuff::VT_MAYBE_I16, None)
+ // Safety:
+ // Created from valid Table for this object
+ // which contains a valid value in this slot
+ unsafe { self._tab.get::<i16>(ScalarStuff::VT_MAYBE_I16, None)}
}
#[inline]
pub fn default_i16(&self) -> i16 {
- self._tab.get::<i16>(ScalarStuff::VT_DEFAULT_I16, Some(42)).unwrap()
+ // Safety:
+ // Created from valid Table for this object
+ // which contains a valid value in this slot
+ unsafe { self._tab.get::<i16>(ScalarStuff::VT_DEFAULT_I16, Some(42)).unwrap()}
}
#[inline]
pub fn just_u16(&self) -> u16 {
- self._tab.get::<u16>(ScalarStuff::VT_JUST_U16, Some(0)).unwrap()
+ // Safety:
+ // Created from valid Table for this object
+ // which contains a valid value in this slot
+ unsafe { self._tab.get::<u16>(ScalarStuff::VT_JUST_U16, Some(0)).unwrap()}
}
#[inline]
pub fn maybe_u16(&self) -> Option<u16> {
- self._tab.get::<u16>(ScalarStuff::VT_MAYBE_U16, None)
+ // Safety:
+ // Created from valid Table for this object
+ // which contains a valid value in this slot
+ unsafe { self._tab.get::<u16>(ScalarStuff::VT_MAYBE_U16, None)}
}
#[inline]
pub fn default_u16(&self) -> u16 {
- self._tab.get::<u16>(ScalarStuff::VT_DEFAULT_U16, Some(42)).unwrap()
+ // Safety:
+ // Created from valid Table for this object
+ // which contains a valid value in this slot
+ unsafe { self._tab.get::<u16>(ScalarStuff::VT_DEFAULT_U16, Some(42)).unwrap()}
}
#[inline]
pub fn just_i32(&self) -> i32 {
- self._tab.get::<i32>(ScalarStuff::VT_JUST_I32, Some(0)).unwrap()
+ // Safety:
+ // Created from valid Table for this object
+ // which contains a valid value in this slot
+ unsafe { self._tab.get::<i32>(ScalarStuff::VT_JUST_I32, Some(0)).unwrap()}
}
#[inline]
pub fn maybe_i32(&self) -> Option<i32> {
- self._tab.get::<i32>(ScalarStuff::VT_MAYBE_I32, None)
+ // Safety:
+ // Created from valid Table for this object
+ // which contains a valid value in this slot
+ unsafe { self._tab.get::<i32>(ScalarStuff::VT_MAYBE_I32, None)}
}
#[inline]
pub fn default_i32(&self) -> i32 {
- self._tab.get::<i32>(ScalarStuff::VT_DEFAULT_I32, Some(42)).unwrap()
+ // Safety:
+ // Created from valid Table for this object
+ // which contains a valid value in this slot
+ unsafe { self._tab.get::<i32>(ScalarStuff::VT_DEFAULT_I32, Some(42)).unwrap()}
}
#[inline]
pub fn just_u32(&self) -> u32 {
- self._tab.get::<u32>(ScalarStuff::VT_JUST_U32, Some(0)).unwrap()
+ // Safety:
+ // Created from valid Table for this object
+ // which contains a valid value in this slot
+ unsafe { self._tab.get::<u32>(ScalarStuff::VT_JUST_U32, Some(0)).unwrap()}
}
#[inline]
pub fn maybe_u32(&self) -> Option<u32> {
- self._tab.get::<u32>(ScalarStuff::VT_MAYBE_U32, None)
+ // Safety:
+ // Created from valid Table for this object
+ // which contains a valid value in this slot
+ unsafe { self._tab.get::<u32>(ScalarStuff::VT_MAYBE_U32, None)}
}
#[inline]
pub fn default_u32(&self) -> u32 {
- self._tab.get::<u32>(ScalarStuff::VT_DEFAULT_U32, Some(42)).unwrap()
+ // Safety:
+ // Created from valid Table for this object
+ // which contains a valid value in this slot
+ unsafe { self._tab.get::<u32>(ScalarStuff::VT_DEFAULT_U32, Some(42)).unwrap()}
}
#[inline]
pub fn just_i64(&self) -> i64 {
- self._tab.get::<i64>(ScalarStuff::VT_JUST_I64, Some(0)).unwrap()
+ // Safety:
+ // Created from valid Table for this object
+ // which contains a valid value in this slot
+ unsafe { self._tab.get::<i64>(ScalarStuff::VT_JUST_I64, Some(0)).unwrap()}
}
#[inline]
pub fn maybe_i64(&self) -> Option<i64> {
- self._tab.get::<i64>(ScalarStuff::VT_MAYBE_I64, None)
+ // Safety:
+ // Created from valid Table for this object
+ // which contains a valid value in this slot
+ unsafe { self._tab.get::<i64>(ScalarStuff::VT_MAYBE_I64, None)}
}
#[inline]
pub fn default_i64(&self) -> i64 {
- self._tab.get::<i64>(ScalarStuff::VT_DEFAULT_I64, Some(42)).unwrap()
+ // Safety:
+ // Created from valid Table for this object
+ // which contains a valid value in this slot
+ unsafe { self._tab.get::<i64>(ScalarStuff::VT_DEFAULT_I64, Some(42)).unwrap()}
}
#[inline]
pub fn just_u64(&self) -> u64 {
- self._tab.get::<u64>(ScalarStuff::VT_JUST_U64, Some(0)).unwrap()
+ // Safety:
+ // Created from valid Table for this object
+ // which contains a valid value in this slot
+ unsafe { self._tab.get::<u64>(ScalarStuff::VT_JUST_U64, Some(0)).unwrap()}
}
#[inline]
pub fn maybe_u64(&self) -> Option<u64> {
- self._tab.get::<u64>(ScalarStuff::VT_MAYBE_U64, None)
+ // Safety:
+ // Created from valid Table for this object
+ // which contains a valid value in this slot
+ unsafe { self._tab.get::<u64>(ScalarStuff::VT_MAYBE_U64, None)}
}
#[inline]
pub fn default_u64(&self) -> u64 {
- self._tab.get::<u64>(ScalarStuff::VT_DEFAULT_U64, Some(42)).unwrap()
+ // Safety:
+ // Created from valid Table for this object
+ // which contains a valid value in this slot
+ unsafe { self._tab.get::<u64>(ScalarStuff::VT_DEFAULT_U64, Some(42)).unwrap()}
}
#[inline]
pub fn just_f32(&self) -> f32 {
- self._tab.get::<f32>(ScalarStuff::VT_JUST_F32, Some(0.0)).unwrap()
+ // Safety:
+ // Created from valid Table for this object
+ // which contains a valid value in this slot
+ unsafe { self._tab.get::<f32>(ScalarStuff::VT_JUST_F32, Some(0.0)).unwrap()}
}
#[inline]
pub fn maybe_f32(&self) -> Option<f32> {
- self._tab.get::<f32>(ScalarStuff::VT_MAYBE_F32, None)
+ // Safety:
+ // Created from valid Table for this object
+ // which contains a valid value in this slot
+ unsafe { self._tab.get::<f32>(ScalarStuff::VT_MAYBE_F32, None)}
}
#[inline]
pub fn default_f32(&self) -> f32 {
- self._tab.get::<f32>(ScalarStuff::VT_DEFAULT_F32, Some(42.0)).unwrap()
+ // Safety:
+ // Created from valid Table for this object
+ // which contains a valid value in this slot
+ unsafe { self._tab.get::<f32>(ScalarStuff::VT_DEFAULT_F32, Some(42.0)).unwrap()}
}
#[inline]
pub fn just_f64(&self) -> f64 {
- self._tab.get::<f64>(ScalarStuff::VT_JUST_F64, Some(0.0)).unwrap()
+ // Safety:
+ // Created from valid Table for this object
+ // which contains a valid value in this slot
+ unsafe { self._tab.get::<f64>(ScalarStuff::VT_JUST_F64, Some(0.0)).unwrap()}
}
#[inline]
pub fn maybe_f64(&self) -> Option<f64> {
- self._tab.get::<f64>(ScalarStuff::VT_MAYBE_F64, None)
+ // Safety:
+ // Created from valid Table for this object
+ // which contains a valid value in this slot
+ unsafe { self._tab.get::<f64>(ScalarStuff::VT_MAYBE_F64, None)}
}
#[inline]
pub fn default_f64(&self) -> f64 {
- self._tab.get::<f64>(ScalarStuff::VT_DEFAULT_F64, Some(42.0)).unwrap()
+ // Safety:
+ // Created from valid Table for this object
+ // which contains a valid value in this slot
+ unsafe { self._tab.get::<f64>(ScalarStuff::VT_DEFAULT_F64, Some(42.0)).unwrap()}
}
#[inline]
pub fn just_bool(&self) -> bool {
- self._tab.get::<bool>(ScalarStuff::VT_JUST_BOOL, Some(false)).unwrap()
+ // Safety:
+ // Created from valid Table for this object
+ // which contains a valid value in this slot
+ unsafe { self._tab.get::<bool>(ScalarStuff::VT_JUST_BOOL, Some(false)).unwrap()}
}
#[inline]
pub fn maybe_bool(&self) -> Option<bool> {
- self._tab.get::<bool>(ScalarStuff::VT_MAYBE_BOOL, None)
+ // Safety:
+ // Created from valid Table for this object
+ // which contains a valid value in this slot
+ unsafe { self._tab.get::<bool>(ScalarStuff::VT_MAYBE_BOOL, None)}
}
#[inline]
pub fn default_bool(&self) -> bool {
- self._tab.get::<bool>(ScalarStuff::VT_DEFAULT_BOOL, Some(true)).unwrap()
+ // Safety:
+ // Created from valid Table for this object
+ // which contains a valid value in this slot
+ unsafe { self._tab.get::<bool>(ScalarStuff::VT_DEFAULT_BOOL, Some(true)).unwrap()}
}
#[inline]
pub fn just_enum(&self) -> OptionalByte {
- self._tab.get::<OptionalByte>(ScalarStuff::VT_JUST_ENUM, Some(OptionalByte::None)).unwrap()
+ // Safety:
+ // Created from valid Table for this object
+ // which contains a valid value in this slot
+ unsafe { self._tab.get::<OptionalByte>(ScalarStuff::VT_JUST_ENUM, Some(OptionalByte::None)).unwrap()}
}
#[inline]
pub fn maybe_enum(&self) -> Option<OptionalByte> {
- self._tab.get::<OptionalByte>(ScalarStuff::VT_MAYBE_ENUM, None)
+ // Safety:
+ // Created from valid Table for this object
+ // which contains a valid value in this slot
+ unsafe { self._tab.get::<OptionalByte>(ScalarStuff::VT_MAYBE_ENUM, None)}
}
#[inline]
pub fn default_enum(&self) -> OptionalByte {
- self._tab.get::<OptionalByte>(ScalarStuff::VT_DEFAULT_ENUM, Some(OptionalByte::One)).unwrap()
+ // Safety:
+ // Created from valid Table for this object
+ // which contains a valid value in this slot
+ unsafe { self._tab.get::<OptionalByte>(ScalarStuff::VT_DEFAULT_ENUM, Some(OptionalByte::One)).unwrap()}
}
}
@@ -837,18 +945,6 @@
}
}
#[inline]
-#[deprecated(since="2.0.0", note="Deprecated in favor of `root_as...` methods.")]
-pub fn get_root_as_scalar_stuff<'a>(buf: &'a [u8]) -> ScalarStuff<'a> {
- unsafe { flatbuffers::root_unchecked::<ScalarStuff<'a>>(buf) }
-}
-
-#[inline]
-#[deprecated(since="2.0.0", note="Deprecated in favor of `root_as...` methods.")]
-pub fn get_size_prefixed_root_as_scalar_stuff<'a>(buf: &'a [u8]) -> ScalarStuff<'a> {
- unsafe { flatbuffers::size_prefixed_root_unchecked::<ScalarStuff<'a>>(buf) }
-}
-
-#[inline]
/// Verifies that a buffer of bytes contains a `ScalarStuff`
/// and returns it.
/// Note that verification is still experimental and may not