GitHub/flatbuffers
1
0
Fork 0
mirror of https://github.com/google/flatbuffers.git synced 2025-04-09 00:12:15 +08:00
Code Issues Packages Projects Releases Wiki Activity

Add basic Kotlin support (#5409)

Browse Source 
* [Kotlin] Add kotlin generate code for tests and add
kotlin test to TestAll.sh

* [Kotlin] Add Kotlin generator

This change adds support for generating Kotlin classes.

The approach of this generator is to keep it as close
as possible to the java generator for now, in order
to keep the change simple.

It uses the already implemented java runtime,
so we don't support cross-platform nor js Kotlin yet.

Kotlin tests are just a copy of the java tests.

* Add optional ident support for CodeWriter

Identation is important for some languages and
different projects have different ways of ident
code, e.g. tabs vs spaces, so we are adding optional
support on CodeWriter for identation.

* [Kotlin] Add Documentation for Kotlin

* [Kotlin] Modify generated code to use experimental Unsigned types.
This commit is contained in:
Paulo Pinheiro 2019-07-22 20:05:15 -03:00 committed by Wouter van Oortmerssen
parent a752d1b88c
commit de9aa0cdee
54 changed files with 4995 additions and 64 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
BUILD
View File

@ -86,6 +86,7 @@ cc_binary(
"src/idl_gen_cpp.cpp",
"src/idl_gen_dart.cpp",
"src/idl_gen_general.cpp",
"src/idl_gen_kotlin.cpp",
"src/idl_gen_go.cpp",
"src/idl_gen_grpc.cpp",
"src/idl_gen_js_ts.cpp",

1
CMakeLists.txt
View File

@ -83,6 +83,7 @@ set(FlatBuffers_Compiler_SRCS
src/idl_gen_cpp.cpp
src/idl_gen_dart.cpp
src/idl_gen_general.cpp
src/idl_gen_kotlin.cpp
src/idl_gen_go.cpp
src/idl_gen_js_ts.cpp
src/idl_gen_php.cpp

2
docs/source/Compiler.md
View File

@ -23,6 +23,8 @@ For any schema input files, one or more generators can be specified:
- `--java`, `-j` : Generate Java code.
- `--kotlin`, `-k` : Generate Kotlin code.
- `--csharp`, `-n` : Generate C# code.
- `--go`, `-g` : Generate Go code.

8
docs/source/FlatBuffers.md
View File

@ -4,7 +4,7 @@ FlatBuffers {#flatbuffers_index}
# Overview {#flatbuffers_overview}
[FlatBuffers](@ref flatbuffers_overview) is an efficient cross platform
serialization library for C++, C#, C, Go, Java, JavaScript, Lobster, Lua, TypeScript, PHP, Python, and Rust.
serialization library for C++, C#, C, Go, Java, Kotlin, JavaScript, Lobster, Lua, TypeScript, PHP, Python, and Rust.
It was originally created at Google for game development and other
performance-critical applications.
@ -51,7 +51,7 @@ under the Apache license, v2 (see LICENSE.txt).
needed (faster and more memory efficient than other JSON
parsers).
Java and Go code supports object-reuse. C# has efficient struct based
Java, Kotlin and Go code supports object-reuse. C# has efficient struct based
accessors.
- **Cross platform code with no dependencies** - C++ code will work
@ -108,7 +108,7 @@ sections provide a more in-depth usage guide.
present for every object instance.
- Use `flatc` (the FlatBuffer compiler) to generate a C++ header (or
Java/C#/Go/Python.. classes) with helper classes to access and construct
Java/Kotlin/C#/Go/Python.. classes) with helper classes to access and construct
serialized data. This header (say `mydata_generated.h`) only depends on
`flatbuffers.h`, which defines the core functionality.
@ -132,6 +132,8 @@ sections provide a more in-depth usage guide.
own programs.
- How to [use the generated Java/C# code](@ref flatbuffers_guide_use_java_c-sharp)
in your own programs.
- How to [use the generated Kotlin code](@ref flatbuffers_guide_use_kotlin)
in your own programs.
- How to [use the generated Go code](@ref flatbuffers_guide_use_go) in your
own programs.
- How to [use the generated Lua code](@ref flatbuffers_guide_use_lua) in your

84
docs/source/KotlinUsage.md Normal file
View File

@ -0,0 +1,84 @@
Use in Kotlin {#flatbuffers_guide_use_kotlin}
==============
## Before you get started
Before diving into the FlatBuffers usage in Kotlin, it should be noted that
the [Tutorial](@ref flatbuffers_guide_tutorial) page has a complete guide to
general FlatBuffers usage in all of the supported languages (including K).
This page is designed to cover the nuances of FlatBuffers usage, specific to Kotlin.
You should also have read the [Building](@ref flatbuffers_guide_building)
documentation to build `flatc` and should be familiar with
[Using the schema compiler](@ref flatbuffers_guide_using_schema_compiler) and
[Writing a schema](@ref flatbuffers_guide_writing_schema).
## Kotlin and FlatBuffers Java code location
Code generated for Kotlin currently uses the flatbuffers java runtime library. That means that Kotlin generated code can only have Java virtual machine as target architecture (which includes Android). Kotlin Native and Kotlin.js are currently not supported.
The code for the FlatBuffers Java library can be found at
`flatbuffers/java/com/google/flatbuffers`. You can browse the library on the
[FlatBuffers GitHub page](https://github.com/google/flatbuffers/tree/master/
java/com/google/flatbuffers).
## Testing FlatBuffers Kotlin
The test code for Java is located in [KotlinTest.java](https://github.com/google
/flatbuffers/blob/master/tests/KotlinTest.kt).
To run the tests, use [KotlinTest.sh](https://github.com/google/
flatbuffers/blob/master/tests/KotlinTest.sh) shell script.
*Note: These scripts require that [Kotlin](https://kotlinlang.org/) is installed.*
## Using the FlatBuffers Kotlin library
*Note: See [Tutorial](@ref flatbuffers_guide_tutorial) for a more in-depth
example of how to use FlatBuffers in Kotlin.*
FlatBuffers supports reading and writing binary FlatBuffers in Kotlin.
To use FlatBuffers in your own code, first generate Java classes from your
schema with the `--kotlin` option to `flatc`.
Then you can include both FlatBuffers and the generated code to read
or write a FlatBuffer.
For example, here is how you would read a FlatBuffer binary file in Kotlin:
First, import the library and generated code. Then, you read a FlatBuffer binary
file into a `ByteArray`. You then turn the `ByteArray` into a `ByteBuffer`, which you
pass to the `getRootAsMyRootType` function:
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~{.kt}
import MyGame.Example.*
import com.google.flatbuffers.FlatBufferBuilder
// This snippet ignores exceptions for brevity.
val data = RandomAccessFile(File("monsterdata_test.mon"), "r").use {
val temp = ByteArray(it.length().toInt())
it.readFully(temp)
temp
}
val bb = ByteBuffer.wrap(data)
val monster = Monster.getRootAsMonster(bb)
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
Now you can access the data from the `Monster monster`:
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~{.kt}
val hp = monster.hp
val pos = monster.pos!!;
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
## Differences between Kotlin and Java code
Kotlin generated code was designed to be as close as possible to the java counterpart, as for now, we only support kotlin on java virtual machine. So the differences in implementation and usage are basically the ones introduced by the Kotlin language itself. You can find more in-depth information [here](https://kotlinlang.org/docs/reference/comparison-to-java.html).
The most obvious ones are:
* Fields as accessed as Kotlin [properties](https://kotlinlang.org/docs/reference/properties.html)
* Static methods are accessed in [companion object](https://kotlinlang.org/docs/reference/classes.html#companion-objects)

191
docs/source/Tutorial.md
View File

@ -23,6 +23,7 @@ Please select your desired language for our quest:
<form>
<input type="radio" name="language" value="cpp" checked="checked">C++</input>
<input type="radio" name="language" value="java">Java</input>
<input type="radio" name="language" value="kotlin">Kotlin</input>
<input type="radio" name="language" value="csharp">C#</input>
<input type="radio" name="language" value="go">Go</input>
<input type="radio" name="language" value="python">Python</input>
@ -115,6 +116,9 @@ For your chosen language, please cross-reference with:
<div class="language-java">
[SampleBinary.java](https://github.com/google/flatbuffers/blob/master/samples/SampleBinary.java)
</div>
<div class="language-kotlin">
[SampleBinary.kt](https://github.com/google/flatbuffers/blob/master/samples/SampleBinary.kt)
</div>
<div class="language-csharp">
[SampleBinary.cs](https://github.com/google/flatbuffers/blob/master/samples/SampleBinary.cs)
</div>
@ -284,6 +288,12 @@ Please be aware of the difference between `flatc` and `flatcc` tools.
./../flatc --java monster.fbs
~~~
</div>
<div class="language-kotlin">
~~~{.sh}
cd flatbuffers/samples
./../flatc --kotlin monster.fbs
~~~
</div>
<div class="language-csharp">
~~~{.sh}
cd flatbuffers/samples
@ -382,6 +392,13 @@ The first step is to import/include the library, generated files, etc.
import com.google.flatbuffers.FlatBufferBuilder;
~~~
</div>
<div class="language-kotlin">
~~~{.kotlin}
import MyGame.Sample.* //The `flatc` generated files. (Monster, Vec3, etc.)
import com.google.flatbuffers.FlatBufferBuilder
~~~
</div>
<div class="language-csharp">
~~~{.cs}
using FlatBuffers;
@ -525,6 +542,13 @@ which will grow automatically if needed:
FlatBufferBuilder builder = new FlatBufferBuilder(1024);
~~~
</div>
<div class="language-kotlin">
~~~{.kt}
// Create a `FlatBufferBuilder`, which will be used to create our
// monsters' FlatBuffers.
val builder = FlatBufferBuilder(1024)
~~~
</div>
<div class="language-csharp">
~~~{.cs}
// Create a `FlatBufferBuilder`, which will be used to create our
@ -633,6 +657,19 @@ our `orc` Monster, lets create some `Weapon`s: a `Sword` and an `Axe`.
int axe = Weapon.createWeapon(builder, weaponTwoName, weaponTwoDamage);
~~~
</div>
<div class="language-kotlin">
~~~{.kt}
val weaponOneName = builder.createString("Sword")
val weaponOneDamage: Short = 3;
val weaponTwoName = builder.createString("Axe")
val weaponTwoDamage: Short = 5;
// Use the `createWeapon()` helper function to create the weapons, since we set every field.
val sword = Weapon.createWeapon(builder, weaponOneName, weaponOneDamage)
val axe = Weapon.createWeapon(builder, weaponTwoName, weaponTwoDamage)
~~~
</div>
<div class="language-csharp">
~~~{.cs}
var weaponOneName = builder.CreateString("Sword");
@ -875,6 +912,17 @@ traversal. This is generally easy to do on any tree structures.
int inv = Monster.createInventoryVector(builder, treasure);
~~~
</div>
<div class="language-kotlin">
~~~{.kt}
// Serialize a name for our monster, called "Orc".
val name = builder.createString("Orc")
// Create a `vector` representing the inventory of the Orc. Each number
// could correspond to an item that can be claimed after he is slain.
val treasure = byteArrayOf(0, 1, 2, 3, 4, 5, 6, 7, 8, 9)
val inv = Monster.createInventoryVector(builder, treasure)
~~~
</div>
<div class="language-csharp">
~~~{.cs}
// Serialize a name for our monster, called "Orc".
@ -1060,6 +1108,16 @@ offsets.
int weapons = Monster.createWeaponsVector(builder, weaps);
~~~
</div>
<div class="language-kotlin">
~~~{.kt}
// Place the two weapons into an array, and pass it to the `createWeaponsVector()` method to
// create a FlatBuffer vector.
val weaps = intArrayOf(sword, axe)
// Pass the `weaps` array into the `createWeaponsVector()` method to create a FlatBuffer vector.
val weapons = Monster.createWeaponsVector(builder, weaps)
~~~
</div>
<div class="language-csharp">
~~~{.cs}
var weaps = new Offset<Weapon>[2];
@ -1180,6 +1238,14 @@ for the `path` field above:
int path = fbb.endVector();
~~~
</div>
<div class="language-kotlin">
~~~{.kt}
Monster.startPathVector(fbb, 2)
Vec3.createVec3(builder, 1.0f, 2.0f, 3.0f)
Vec3.createVec3(builder, 4.0f, 5.0f, 6.0f)
val path = fbb.endVector()
~~~
</div>
<div class="language-csharp">
~~~{.cs}
Monster.StartPathVector(fbb, 2);
@ -1318,6 +1384,22 @@ can serialize the monster itself:
int orc = Monster.endMonster(builder);
~~~
</div>
<div class="language-kotlin">
~~~{.kt}
// Create our monster using `startMonster()` and `endMonster()`.
Monster.startMonster(builder)
Monster.addPos(builder, Vec3.createVec3(builder, 1.0f, 2.0f, 3.0f))
Monster.addName(builder, name)
Monster.addColor(builder, Color.Red)
Monster.addHp(builder, 300.toShort())
Monster.addInventory(builder, inv)
Monster.addWeapons(builder, weapons)
Monster.addEquippedType(builder, Equipment.Weapon)
Monster.addEquipped(builder, axe)
Monster.addPath(builder, path)
val orc = Monster.endMonster(builder)
~~~
</div>
<div class="language-csharp">
~~~{.cs}
// Create our monster using `StartMonster()` and `EndMonster()`.
@ -1627,6 +1709,12 @@ Here is a repetition these lines, to help highlight them more clearly:
Monster.addEquipped(axe); // Union data
~~~
</div>
<div class="language-kotlin">
~~~{.kt}
Monster.addEquippedType(builder, Equipment.Weapon) // Union type
Monster.addEquipped(axe) // Union data
~~~
</div>
<div class="language-csharp">
~~~{.cs}
Monster.AddEquippedType(builder, Equipment.Weapon); // Union type
@ -1722,6 +1810,12 @@ appropriate `finish` method.
builder.finish(orc); // You could also call `Monster.finishMonsterBuffer(builder, orc);`.
~~~
</div>
<div class="language-kotlin">
~~~{.kt}
// Call `finish()` to instruct the builder that this monster is complete.
builder.finish(orc) // You could also call `Monster.finishMonsterBuffer(builder, orc);`.
~~~
</div>
<div class="language-csharp">
~~~{.cs}
// Call `Finish()` to instruct the builder that this monster is complete.
@ -1814,6 +1908,17 @@ like so:
byte[] buf = builder.sizedByteArray();
~~~
</div>
<div class="language-kotlin">
~~~{.kt}
// This must be called after `finish()`.
val buf = builder.dataBuffer()
// The data in this ByteBuffer does NOT start at 0, but at buf.position().
// The number of bytes is buf.remaining().
// Alternatively this copies the above data out of the ByteBuffer for you:
val buf = builder.sizedByteArray()
~~~
</div>
<div class="language-csharp">
~~~{.cs}
// This must be called after `Finish()`.
@ -1936,6 +2041,13 @@ before:
import com.google.flatbuffers.FlatBufferBuilder;
~~~
</div>
<div class="language-kotlin">
~~~{.kt}
import MyGame.Sample.* //The `flatc` generated files. (Monster, Vec3, etc.)
import com.google.flatbuffers.FlatBufferBuilder
~~~
</div>
<div class="language-csharp">
~~~{.cs}
using FlatBuffers;
@ -2084,6 +2196,15 @@ won't work**
Monster monster = Monster.getRootAsMonster(buf);
~~~
</div>
<div class="language-kotlin">
~~~{.kt}
val bytes = /* the data you just read */
val buf = java.nio.ByteBuffer.wrap(bytes)
// Get an accessor to the root object inside the buffer.
Monster monster = Monster.getRootAsMonster(buf)
~~~
</div>
<div class="language-csharp">
~~~{.cs}
byte[] bytes = /* the data you just read */
@ -2208,6 +2329,13 @@ accessors for all non-`deprecated` fields. For example:
String name = monster.name();
~~~
</div>
<div class="language-kotlin">
~~~{.kt}
val hp = monster.hp
val mana = monster.mana
val name = monster.name
~~~
</div>
<div class="language-csharp">
~~~{.cs}
// For C#, unlike most other languages support by FlatBuffers, most values (except for
@ -2313,6 +2441,14 @@ To access sub-objects, in the case of our `pos`, which is a `Vec3`:
float z = pos.z();
~~~
</div>
<div class="language-kotlin">
~~~{.kt}
val pos = monster.pos!!
val x = pos.x
val y = pos.y
val z = pos.z
~~~
</div>
<div class="language-csharp">
~~~{.cs}
var pos = monster.Pos.Value;
@ -2429,6 +2565,12 @@ FlatBuffers `vector`.
byte thirdItem = monster.inventory(2);
~~~
</div>
<div class="language-kotlin">
~~~{.kotlin}
val invLength = monster.inventoryLength
val thirdItem = monster.inventory(2)!!
~~~
</div>
<div class="language-csharp">
~~~{.cs}
int invLength = monster.InventoryLength;
@ -2520,6 +2662,13 @@ except your need to handle the result as a FlatBuffer `table`:
short secondWeaponDamage = monster.weapons(1).damage();
~~~
</div>
<div class="language-kotlin">
~~~{.kt}
val weaponsLength = monster.weaponsLength
val secondWeaponName = monster.weapons(1)!!.name
val secondWeaponDamage = monster.weapons(1)!!.damage
~~~
</div>
<div class="language-csharp">
~~~{.cs}
int weaponsLength = monster.WeaponsLength;
@ -2640,6 +2789,19 @@ We can access the type to dynamically cast the data as needed (since the
}
~~~
</div>
<div class="language-kotlin">
~~~{.kt}
val unionType = monster.EquippedType
if (unionType == Equipment.Weapon) {
val weapon = monster.equipped(Weapon()) as Weapon // Requires explicit cast
// to `Weapon`.
val weaponName = weapon.name // "Axe"
val weaponDamage = weapon.damage // 5
}
~~~
</div>
<div class="language-csharp">
~~~{.cs}
var unionType = monster.EquippedType;
@ -2816,6 +2978,14 @@ mutators like so:
monster.mutateInventory(0, 1); // Set vector element.
~~~
</div>
<div class="language-kotlin">
~~~{.kt}
val monster = Monster.getRootAsMonster(buf)
monster.mutateHp(10) // Set table field.
monster.pos!!.mutateZ(4) // Set struct field.
monster.mutateInventory(0, 1) // Set vector element.
~~~
</div>
<div class="language-csharp">
~~~{.cs}
var monster = Monster.GetRootAsMonster(buf);
@ -2903,9 +3073,9 @@ See the individual language documents for support.
If you are working with C, C++, or Lobster, you can parse JSON at runtime.
If your language does not support JSON at the moment, `flatc` may provide an
alternative. Using `flatc` is often the preferred method, as it doesn't require you to
add any new code to your program. It is also efficient, since you can ship with
the binary data. The drawback is that it requires an extra step for your
alternative. Using `flatc` is often the preferred method, as it doesn't require you to
add any new code to your program. It is also efficient, since you can ship with
the binary data. The drawback is that it requires an extra step for your
users/developers to perform (although it may be able to be automated
as part of your compilation).
@ -2979,13 +3149,13 @@ Converting from a FlatBuffer binary representation to JSON is supported as well:
./../flatc --json --raw-binary monster.fbs -- monsterdata.bin
~~~
This will convert `monsterdata.bin` back to its original JSON representation.
You need to pass the corresponding FlatBuffers schema so that flatc knows how to
interpret the binary buffer. Since `monster.fbs` does not specify an explicit
`file_identifier` for binary buffers, `flatc` needs to be forced into reading
You need to pass the corresponding FlatBuffers schema so that flatc knows how to
interpret the binary buffer. Since `monster.fbs` does not specify an explicit
`file_identifier` for binary buffers, `flatc` needs to be forced into reading
the `.bin` file using the `--raw-binary` option.
The FlatBuffer binary representation does not explicitly encode default values,
therefore they are not present in the resulting JSON unless you specify
The FlatBuffer binary representation does not explicitly encode default values,
therefore they are not present in the resulting JSON unless you specify
`--defaults-json`.
If you intend to process the JSON with other tools, you may consider switching
@ -2993,7 +3163,7 @@ on `--strict-json` so that identifiers are quoted properly.
*Note: The resulting JSON file is not necessarily identical with the original JSON.
If the binary representation contains floating point numbers, floats and doubles
are rounded to 6 and 12 digits, respectively, in order to represent them as
are rounded to 6 and 12 digits, respectively, in order to represent them as
decimals in the JSON document. *
## Advanced Features for Each Language
@ -3009,6 +3179,9 @@ For your chosen language, see:
<div class="language-java">
[Use in Java/C#](@ref flatbuffers_guide_use_java_c-sharp)
</div>
<div class="language-kotlin">
[Use in Kotlin](@ref flatbuffers_guide_use_kotlin)
</div>
<div class="language-csharp">
[Use in Java/C#](@ref flatbuffers_guide_use_java_c-sharp)
</div>

18
include/flatbuffers/code_generators.h
View File

@ -26,7 +26,7 @@ namespace flatbuffers {
// Utility class to assist in generating code through use of text templates.
//
// Example code:
// CodeWriter code;
// CodeWriter code("\t");
// code.SetValue("NAME", "Foo");
// code += "void {{NAME}}() { printf("%s", "{{NAME}}"); }";
// code.SetValue("NAME", "Bar");
@ -38,7 +38,8 @@ namespace flatbuffers {
// void Bar() { printf("%s", "Bar"); }
class CodeWriter {
public:
CodeWriter() {}
CodeWriter(std::string pad = std::string())
: pad_(pad), cur_ident_lvl_(0), ignore_ident_(false) {}
// Clears the current "written" code.
void Clear() {
@ -67,9 +68,22 @@ class CodeWriter {
// Returns the current contents of the CodeWriter as a std::string.
std::string ToString() const { return stream_.str(); }
// Increase ident level for writing code
void IncrementIdentLevel() { cur_ident_lvl_++; }
// Decrease ident level for writing code
void DecrementIdentLevel() {
if (cur_ident_lvl_) cur_ident_lvl_--;
}
private:
std::map<std::string, std::string> value_map_;
std::stringstream stream_;
std::string pad_;
int cur_ident_lvl_;
bool ignore_ident_;
// Add ident padding (tab or space) based on ident level
void AppendIdent(std::stringstream &stream);
};
class BaseGenerator {

47
include/flatbuffers/idl.h
View File

@ -47,26 +47,26 @@ namespace flatbuffers {
// of type tokens.
// clang-format off
#define FLATBUFFERS_GEN_TYPES_SCALAR(TD) \
TD(NONE, "", uint8_t, byte, byte, byte, uint8, u8) \
TD(UTYPE, "", uint8_t, byte, byte, byte, uint8, u8) /* begin scalar/int */ \
TD(BOOL, "bool", uint8_t, boolean,bool, bool, bool, bool) \
TD(CHAR, "byte", int8_t, byte, int8, sbyte, int8, i8) \
TD(UCHAR, "ubyte", uint8_t, byte, byte, byte, uint8, u8) \
TD(SHORT, "short", int16_t, short, int16, short, int16, i16) \
TD(USHORT, "ushort", uint16_t, short, uint16, ushort, uint16, u16) \
TD(INT, "int", int32_t, int, int32, int, int32, i32) \
TD(UINT, "uint", uint32_t, int, uint32, uint, uint32, u32) \
TD(LONG, "long", int64_t, long, int64, long, int64, i64) \
TD(ULONG, "ulong", uint64_t, long, uint64, ulong, uint64, u64) /* end int */ \
TD(FLOAT, "float", float, float, float32, float, float32, f32) /* begin float */ \
TD(DOUBLE, "double", double, double, float64, double, float64, f64) /* end float/scalar */
TD(NONE, "", uint8_t, byte, byte, byte, uint8, u8, UByte) \
TD(UTYPE, "", uint8_t, byte, byte, byte, uint8, u8, UByte) /* begin scalar/int */ \
TD(BOOL, "bool", uint8_t, boolean,bool, bool, bool, bool, Boolean) \
TD(CHAR, "byte", int8_t, byte, int8, sbyte, int8, i8, Byte) \
TD(UCHAR, "ubyte", uint8_t, byte, byte, byte, uint8, u8, UByte) \
TD(SHORT, "short", int16_t, short, int16, short, int16, i16, Short) \
TD(USHORT, "ushort", uint16_t, short, uint16, ushort, uint16, u16, UShort) \
TD(INT, "int", int32_t, int, int32, int, int32, i32, Int) \
TD(UINT, "uint", uint32_t, int, uint32, uint, uint32, u32, UInt) \
TD(LONG, "long", int64_t, long, int64, long, int64, i64, Long) \
TD(ULONG, "ulong", uint64_t, long, uint64, ulong, uint64, u64, ULong) /* end int */ \
TD(FLOAT, "float", float, float, float32, float, float32, f32, Float) /* begin float */ \
TD(DOUBLE, "double", double, double, float64, double, float64, f64, Double) /* end float/scalar */
#define FLATBUFFERS_GEN_TYPES_POINTER(TD) \
TD(STRING, "string", Offset<void>, int, int, StringOffset, int, unused) \
TD(VECTOR, "", Offset<void>, int, int, VectorOffset, int, unused) \
TD(STRUCT, "", Offset<void>, int, int, int, int, unused) \
TD(UNION, "", Offset<void>, int, int, int, int, unused)
TD(STRING, "string", Offset<void>, int, int, StringOffset, int, unused, Int) \
TD(VECTOR, "", Offset<void>, int, int, VectorOffset, int, unused, Int) \
TD(STRUCT, "", Offset<void>, int, int, int, int, unused, Int) \
TD(UNION, "", Offset<void>, int, int, int, int, unused, Int)
#define FLATBUFFERS_GEN_TYPE_ARRAY(TD) \
TD(ARRAY, "", int, int, int, int, int, unused)
TD(ARRAY, "", int, int, int, int, int, unused, Int)
// The fields are:
// - enum
// - FlatBuffers schema type.
@ -76,13 +76,14 @@ namespace flatbuffers {
// - C# / .Net type.
// - Python type.
// - Rust type.
// - Kotlin type.
// using these macros, we can now write code dealing with types just once, e.g.
/*
switch (type) {
#define FLATBUFFERS_TD(ENUM, IDLTYPE, CTYPE, JTYPE, GTYPE, NTYPE, PTYPE, \
RTYPE) \
RTYPE, KTYPE) \
case BASE_TYPE_ ## ENUM: \
// do something specific to CTYPE here
FLATBUFFERS_GEN_TYPES(FLATBUFFERS_TD)
@ -101,14 +102,14 @@ __extension__ // Stop GCC complaining about trailing comma with -Wpendantic.
#endif
enum BaseType {
#define FLATBUFFERS_TD(ENUM, IDLTYPE, CTYPE, JTYPE, GTYPE, NTYPE, PTYPE, \
RTYPE) \
RTYPE, KTYPE) \
BASE_TYPE_ ## ENUM,
FLATBUFFERS_GEN_TYPES(FLATBUFFERS_TD)
#undef FLATBUFFERS_TD
};
#define FLATBUFFERS_TD(ENUM, IDLTYPE, CTYPE, JTYPE, GTYPE, NTYPE, PTYPE, \
RTYPE) \
RTYPE, KTYPE) \
static_assert(sizeof(CTYPE) <= sizeof(largest_scalar_t), \
"define largest_scalar_t as " #CTYPE);
FLATBUFFERS_GEN_TYPES(FLATBUFFERS_TD)
@ -546,6 +547,7 @@ struct IDLOptions {
kLua = 1 << 12,
kLobster = 1 << 13,
kRust = 1 << 14,
kKotlin = 1 << 15,
kMAX
};
@ -1009,6 +1011,9 @@ extern bool GenerateJsonSchema(const Parser &parser,
const std::string &path,
const std::string &file_name);
extern bool GenerateKotlin(const Parser &parser, const std::string &path,
const std::string &file_name);
// Generate Java/C#/.. files from the definitions in the Parser object.
// See idl_gen_general.cpp.
extern bool GenerateGeneral(const Parser &parser,

108
samples/SampleBinary.kt Normal file
View File

@ -0,0 +1,108 @@
/*
* Copyright 2015 Google Inc. All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
// Run this file with the `java_sample.sh` script.
import MyGame.Sample.Color
import MyGame.Sample.Equipment
import MyGame.Sample.Monster
import MyGame.Sample.Vec3
import MyGame.Sample.Weapon
import com.google.flatbuffers.FlatBufferBuilder
class SampleBinary {
companion object {
// Example how to use FlatBuffers to create and read binary buffers.
@JvmStatic
fun main(args: Array<String>) {
val builder = FlatBufferBuilder(0)
// Create some weapons for our Monster ('Sword' and 'Axe').
val weaponOneName = builder.createString("Sword")
val weaponOneDamage: Short = 3
val weaponTwoName = builder.createString("Axe")
val weaponTwoDamage: Short = 5
// Use the `createWeapon()` helper function to create the weapons, since we set every field.
val weaps = IntArray(2)
weaps[0] = Weapon.createWeapon(builder, weaponOneName, weaponOneDamage)
weaps[1] = Weapon.createWeapon(builder, weaponTwoName, weaponTwoDamage)
// Serialize the FlatBuffer data.
val name = builder.createString("Orc")
val treasure = byteArrayOf(0, 1, 2, 3, 4, 5, 6, 7, 8, 9)
val inv = Monster.createInventoryVector(builder, treasure)
val weapons = Monster.createWeaponsVector(builder, weaps)
val pos = Vec3.createVec3(builder, 1.0f, 2.0f, 3.0f)
Monster.startMonster(builder)
Monster.addPos(builder, pos)
Monster.addName(builder, name)
Monster.addColor(builder, Color.Red)
Monster.addHp(builder, 300.toShort())
Monster.addInventory(builder, inv)
Monster.addWeapons(builder, weapons)
Monster.addEquippedType(builder, Equipment.Weapon)
Monster.addEquipped(builder, weaps[1])
val orc = Monster.endMonster(builder)
builder.finish(orc) // You could also call `Monster.finishMonsterBuffer(builder, orc);`.
// We now have a FlatBuffer that can be stored on disk or sent over a network.
// ...Code to store to disk or send over a network goes here...
// Instead, we are going to access it right away, as if we just received it.
val buf = builder.dataBuffer()
// Get access to the root:
val monster = Monster.getRootAsMonster(buf)
// Note: We did not set the `mana` field explicitly, so we get back the default value.
assert(monster.mana == 150.toShort())
assert(monster.hp == 300.toShort())
assert(monster.name.equals("Orc"))
assert(monster.color == Color.Red)
assert(monster.pos!!.x == 1.0f)
assert(monster.pos!!.y == 2.0f)
assert(monster.pos!!.z == 3.0f)
// Get and test the `inventory` FlatBuffer `vector`.
for (i in 0 until monster.inventoryLength) {
assert(monster.inventory(i) == i.toByte().toInt())
}
// Get and test the `weapons` FlatBuffer `vector` of `table`s.
val expectedWeaponNames = arrayOf("Sword", "Axe")
val expectedWeaponDamages = intArrayOf(3, 5)
for (i in 0 until monster.weaponsLength) {
assert(monster.weapons(i)!!.name.equals(expectedWeaponNames[i]))
assert(monster.weapons(i)!!.damage.toInt() == expectedWeaponDamages[i])
}
// Get and test the `equipped` FlatBuffer `union`.
assert(monster.equippedType == Equipment.Weapon)
val equipped = monster.equipped(Weapon()) as Weapon?
assert(equipped!!.name.equals("Axe"))
assert(equipped.damage == 5.toShort())
println("The FlatBuffer was successfully created and verified!")
}
}
}

60
samples/kotlin_sample.sh Executable file
View File

@ -0,0 +1,60 @@
#!/bin/bash
#
# Copyright 2015 Google Inc. All rights reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
#
# Note: This script runs on Mac and Linux. It requires `kotlin` to be installed
# and `flatc` to be built (using `cmake` in the root directory).
sampledir=$(cd $(dirname $BASH_SOURCE) && pwd)
rootdir=$(cd $sampledir/.. && pwd)
currentdir=$(pwd)
if [[ "$sampledir" != "$currentdir" ]]; then
echo Error: This script must be run from inside the $sampledir directory.
echo You executed it from the $currentdir directory.
exit 1
fi
# Run `flatc`. Note: This requires you to compile using `cmake` from the
# root `/flatbuffers` directory.
if [ -e ../flatc ]; then
echo "compiling now"
../flatc --kotlin --gen-mutable monster.fbs
elif [ -e ../Debug/flatc ]; then
../Debug/flatc --kotlin --gen-mutable monster.fbs
else
echo 'flatc' could not be found. Make sure to build FlatBuffers from the \
$rootdir directory.
exit 1
fi
echo Compiling and running the Kotlin sample
all_kt_files=`find $sampledir -name "*.kt" -print`
# Run test
mkdir -v "${sampledir}/kotlin"
echo Compiling Java Runtime
javac ${rootdir}/java/com/google/flatbuffers/*.java -d ${sampledir}/kotlin
echo Compiling Kotlin source
kotlinc -classpath ${sampledir}/../java:${sampledir}/kotlin $all_kt_files SampleBinary.kt -include-runtime -d ${sampledir}/kotlin
# Make jar
echo Making jar
jar cvf ${sampledir}/kotlin/kotlin_sample.jar -C ${sampledir}/kotlin . > /dev/null
echo Running test
kotlin -cp ${sampledir}/kotlin/kotlin_sample.jar SampleBinary
# Cleanup temporary files.
# rm -rf MyGame/
# rm -rf ${sampledir}/kotlin

11
src/code_generators.cpp
View File

@ -29,6 +29,8 @@
namespace flatbuffers {
void CodeWriter::operator+=(std::string text) {
if (!ignore_ident_ && !text.empty()) AppendIdent(stream_);
while (true) {
auto begin = text.find("{{");
if (begin == std::string::npos) { break; }
@ -58,12 +60,21 @@ void CodeWriter::operator+=(std::string text) {
}
if (!text.empty() && string_back(text) == '\\') {
text.pop_back();
ignore_ident_ = true;
stream_ << text;
} else {
ignore_ident_ = false;
stream_ << text << std::endl;
}
}
void CodeWriter::AppendIdent(std::stringstream &stream) {
int lvl = cur_ident_lvl_;
while (lvl--) {
stream.write(pad_.c_str(), static_cast<std::streamsize>(pad_.size()));
}
}
const char *BaseGenerator::FlatBuffersGeneratedWarning() {
return "automatically generated by the FlatBuffers compiler,"
" do not modify";

3
src/flatc_main.cpp
View File

@ -90,6 +90,9 @@ int main(int argc, const char *argv[]) {
{ flatbuffers::GeneratePhp, nullptr, "--php", "PHP", true, nullptr,
flatbuffers::IDLOptions::kPhp, "Generate PHP files for tables/structs",
flatbuffers::GeneralMakeRule },
{ flatbuffers::GenerateKotlin, nullptr, "--kotlin", "Kotlin", true, nullptr,
flatbuffers::IDLOptions::kKotlin, "Generate Kotlin classes for tables/structs",
flatbuffers::GeneralMakeRule },
{ flatbuffers::GenerateJsonSchema, nullptr, "--jsonschema", "JsonSchema",
true, nullptr, flatbuffers::IDLOptions::kJsonSchema,
"Generate Json schema", flatbuffers::GeneralMakeRule },

2
src/idl_gen_cpp.cpp
View File

@ -538,7 +538,7 @@ class CppGenerator : public BaseGenerator {
// clang-format off
static const char *const ctypename[] = {
#define FLATBUFFERS_TD(ENUM, IDLTYPE, CTYPE, JTYPE, GTYPE, NTYPE, PTYPE, \
RTYPE) \
RTYPE, KTYPE) \
#CTYPE,
FLATBUFFERS_GEN_TYPES(FLATBUFFERS_TD)
#undef FLATBUFFERS_TD

4
src/idl_gen_general.cpp
View File

@ -258,7 +258,7 @@ class GeneralGenerator : public BaseGenerator {
// clang-format off
static const char * const java_typename[] = {
#define FLATBUFFERS_TD(ENUM, IDLTYPE, \
CTYPE, JTYPE, GTYPE, NTYPE, PTYPE, RTYPE) \
CTYPE, JTYPE, GTYPE, NTYPE, PTYPE, RTYPE, KTYPE) \
#JTYPE,
FLATBUFFERS_GEN_TYPES(FLATBUFFERS_TD)
#undef FLATBUFFERS_TD
@ -266,7 +266,7 @@ class GeneralGenerator : public BaseGenerator {
static const char * const csharp_typename[] = {
#define FLATBUFFERS_TD(ENUM, IDLTYPE, \
CTYPE, JTYPE, GTYPE, NTYPE, PTYPE, RTYPE) \
CTYPE, JTYPE, GTYPE, NTYPE, PTYPE, RTYPE, KTYPE) \
#NTYPE,
FLATBUFFERS_GEN_TYPES(FLATBUFFERS_TD)
#undef FLATBUFFERS_TD

2
src/idl_gen_go.cpp
View File

@ -827,7 +827,7 @@ class GoGenerator : public BaseGenerator {
static const char *ctypename[] = {
// clang-format off
#define FLATBUFFERS_TD(ENUM, IDLTYPE, \
CTYPE, JTYPE, GTYPE, NTYPE, PTYPE, RTYPE) \
CTYPE, JTYPE, GTYPE, NTYPE, PTYPE, RTYPE, KTYPE) \
#GTYPE,
FLATBUFFERS_GEN_TYPES(FLATBUFFERS_TD)
#undef FLATBUFFERS_TD

1527
src/idl_gen_kotlin.cpp Normal file
View File

File diff suppressed because it is too large Load Diff

2
src/idl_gen_lobster.cpp
View File

@ -83,7 +83,7 @@ class LobsterGenerator : public BaseGenerator {
static const char *ctypename[] = {
// clang-format off
#define FLATBUFFERS_TD(ENUM, IDLTYPE, \
CTYPE, JTYPE, GTYPE, NTYPE, PTYPE, RTYPE) \
CTYPE, JTYPE, GTYPE, NTYPE, PTYPE, RTYPE, KTYPE) \
#PTYPE,
FLATBUFFERS_GEN_TYPES(FLATBUFFERS_TD)
#undef FLATBUFFERS_TD

2
src/idl_gen_lua.cpp
View File

@ -606,7 +606,7 @@ namespace lua {
static const char *ctypename[] = {
// clang-format off
#define FLATBUFFERS_TD(ENUM, IDLTYPE, \
CTYPE, JTYPE, GTYPE, NTYPE, PTYPE, RTYPE) \
CTYPE, JTYPE, GTYPE, NTYPE, PTYPE, RTYPE, KTYPE) \
#PTYPE,
FLATBUFFERS_GEN_TYPES(FLATBUFFERS_TD)
#undef FLATBUFFERS_TD

2
src/idl_gen_php.cpp
View File

@ -862,7 +862,7 @@ class PhpGenerator : public BaseGenerator {
static const char *ctypename[] = {
// clang-format off
#define FLATBUFFERS_TD(ENUM, IDLTYPE, \
CTYPE, JTYPE, GTYPE, NTYPE, PTYPE, RTYPE) \
CTYPE, JTYPE, GTYPE, NTYPE, PTYPE, RTYPE, KTYPE) \
#NTYPE,
FLATBUFFERS_GEN_TYPES(FLATBUFFERS_TD)
#undef FLATBUFFERS_TD

2
src/idl_gen_python.cpp
View File

@ -680,7 +680,7 @@ class PythonGenerator : public BaseGenerator {
static const char *ctypename[] = {
// clang-format off
#define FLATBUFFERS_TD(ENUM, IDLTYPE, \
CTYPE, JTYPE, GTYPE, NTYPE, PTYPE, RTYPE) \
CTYPE, JTYPE, GTYPE, NTYPE, PTYPE, RTYPE, KTYPE) \
#PTYPE,
FLATBUFFERS_GEN_TYPES(FLATBUFFERS_TD)
#undef FLATBUFFERS_TD

4
src/idl_gen_rust.cpp
View File

@ -516,7 +516,7 @@ class RustGenerator : public BaseGenerator {
// clang-format off
static const char * const ctypename[] = {
#define FLATBUFFERS_TD(ENUM, IDLTYPE, CTYPE, JTYPE, GTYPE, NTYPE, PTYPE, \
RTYPE) \
RTYPE, KTYPE) \
#RTYPE,
FLATBUFFERS_GEN_TYPES(FLATBUFFERS_TD)
#undef FLATBUFFERS_TD
@ -538,7 +538,7 @@ class RustGenerator : public BaseGenerator {
static const char *ctypename[] = {
// clang-format off
#define FLATBUFFERS_TD(ENUM, IDLTYPE, CTYPE, JTYPE, GTYPE, NTYPE, PTYPE, \
RTYPE) \
RTYPE, KTYPE) \
#RTYPE,
FLATBUFFERS_GEN_TYPES(FLATBUFFERS_TD)
#undef FLATBUFFERS_TD

8
src/idl_gen_text.cpp
View File

@ -146,7 +146,7 @@ bool Print<const void *>(const void *val, Type type, int indent,
// clang-format off
switch (vec_type.base_type) {
#define FLATBUFFERS_TD(ENUM, IDLTYPE, \
CTYPE, JTYPE, GTYPE, NTYPE, PTYPE, RTYPE) \
CTYPE, JTYPE, GTYPE, NTYPE, PTYPE, RTYPE, KTYPE) \
case BASE_TYPE_ ## ENUM: \
if (!PrintVector<CTYPE>( \
*reinterpret_cast<const Vector<CTYPE> *>(val), \
@ -166,7 +166,7 @@ bool Print<const void *>(const void *val, Type type, int indent,
// clang-format off
switch (vec_type.base_type) {
#define FLATBUFFERS_TD(ENUM, IDLTYPE, \
CTYPE, JTYPE, GTYPE, NTYPE, PTYPE, RTYPE) \
CTYPE, JTYPE, GTYPE, NTYPE, PTYPE, RTYPE, KTYPE) \
case BASE_TYPE_ ## ENUM: \
if (!PrintArray<CTYPE>( \
*reinterpret_cast<const Array<CTYPE, 0xFFFF> *>(val), \
@ -266,7 +266,7 @@ static bool GenStruct(const StructDef &struct_def, const Table *table,
switch (fd.value.type.base_type) {
// clang-format off
#define FLATBUFFERS_TD(ENUM, IDLTYPE, \
CTYPE, JTYPE, GTYPE, NTYPE, PTYPE, RTYPE) \
CTYPE, JTYPE, GTYPE, NTYPE, PTYPE, RTYPE, KTYPE) \
case BASE_TYPE_ ## ENUM: \
if (!GenField<CTYPE>(fd, table, struct_def.fixed, \
opts, indent + Indent(opts), _text)) { \
@ -277,7 +277,7 @@ static bool GenStruct(const StructDef &struct_def, const Table *table,
#undef FLATBUFFERS_TD
// Generate drop-thru case statements for all pointer types:
#define FLATBUFFERS_TD(ENUM, IDLTYPE, \
CTYPE, JTYPE, GTYPE, NTYPE, PTYPE, RTYPE) \
CTYPE, JTYPE, GTYPE, NTYPE, PTYPE, RTYPE, KTYPE) \
case BASE_TYPE_ ## ENUM:
FLATBUFFERS_GEN_TYPES_POINTER(FLATBUFFERS_TD)
FLATBUFFERS_GEN_TYPE_ARRAY(FLATBUFFERS_TD)

21
src/idl_parser.cpp
View File

@ -29,7 +29,7 @@ namespace flatbuffers {
// Reflects the version at the compiling time of binary(lib/dll/so).
const char *FLATBUFFERS_VERSION() {
// clang-format off
return
return
FLATBUFFERS_STRING(FLATBUFFERS_VERSION_MAJOR) "."
FLATBUFFERS_STRING(FLATBUFFERS_VERSION_MINOR) "."
FLATBUFFERS_STRING(FLATBUFFERS_VERSION_REVISION);
@ -41,7 +41,7 @@ const double kPi = 3.14159265358979323846;
const char *const kTypeNames[] = {
// clang-format off
#define FLATBUFFERS_TD(ENUM, IDLTYPE, \
CTYPE, JTYPE, GTYPE, NTYPE, PTYPE, RTYPE) \
CTYPE, JTYPE, GTYPE, NTYPE, PTYPE, RTYPE, KTYPE) \
IDLTYPE,
FLATBUFFERS_GEN_TYPES(FLATBUFFERS_TD)
#undef FLATBUFFERS_TD
@ -52,7 +52,7 @@ const char *const kTypeNames[] = {
const char kTypeSizes[] = {
// clang-format off
#define FLATBUFFERS_TD(ENUM, IDLTYPE, \
CTYPE, JTYPE, GTYPE, NTYPE, PTYPE, RTYPE) \
CTYPE, JTYPE, GTYPE, NTYPE, PTYPE, RTYPE, KTYPE) \
sizeof(CTYPE),
FLATBUFFERS_GEN_TYPES(FLATBUFFERS_TD)
#undef FLATBUFFERS_TD
@ -212,7 +212,7 @@ static std::string TokenToString(int t) {
FLATBUFFERS_GEN_TOKENS(FLATBUFFERS_TOKEN)
#undef FLATBUFFERS_TOKEN
#define FLATBUFFERS_TD(ENUM, IDLTYPE, \
CTYPE, JTYPE, GTYPE, NTYPE, PTYPE, RTYPE) \
CTYPE, JTYPE, GTYPE, NTYPE, PTYPE, RTYPE, KTYPE) \
IDLTYPE,
FLATBUFFERS_GEN_TYPES(FLATBUFFERS_TD)
#undef FLATBUFFERS_TD
@ -1169,7 +1169,7 @@ CheckedError Parser::ParseTable(const StructDef &struct_def, std::string *value,
switch (field_value.type.base_type) {
// clang-format off
#define FLATBUFFERS_TD(ENUM, IDLTYPE, \
CTYPE, JTYPE, GTYPE, NTYPE, PTYPE, RTYPE) \
CTYPE, JTYPE, GTYPE, NTYPE, PTYPE, RTYPE, KTYPE) \
case BASE_TYPE_ ## ENUM: \
builder_.Pad(field->padding); \
if (struct_def.fixed) { \
@ -1186,7 +1186,7 @@ CheckedError Parser::ParseTable(const StructDef &struct_def, std::string *value,
FLATBUFFERS_GEN_TYPES_SCALAR(FLATBUFFERS_TD);
#undef FLATBUFFERS_TD
#define FLATBUFFERS_TD(ENUM, IDLTYPE, \
CTYPE, JTYPE, GTYPE, NTYPE, PTYPE, RTYPE) \
CTYPE, JTYPE, GTYPE, NTYPE, PTYPE, RTYPE, KTYPE) \
case BASE_TYPE_ ## ENUM: \
builder_.Pad(field->padding); \
if (IsStruct(field->value.type)) { \
@ -1267,7 +1267,7 @@ CheckedError Parser::ParseVector(const Type &type, uoffset_t *ovalue,
switch (val.type.base_type) {
// clang-format off
#define FLATBUFFERS_TD(ENUM, IDLTYPE, \
CTYPE, JTYPE, GTYPE, NTYPE, PTYPE, RTYPE) \
CTYPE, JTYPE, GTYPE, NTYPE, PTYPE, RTYPE, KTYPE) \
case BASE_TYPE_ ## ENUM: \
if (IsStruct(val.type)) SerializeStruct(*val.type.struct_def, val); \
else { \
@ -1313,7 +1313,7 @@ CheckedError Parser::ParseArray(Value &array) {
// clang-format off
switch (val.type.base_type) {
#define FLATBUFFERS_TD(ENUM, IDLTYPE, \
CTYPE, JTYPE, GTYPE, NTYPE, PTYPE, RTYPE) \
CTYPE, JTYPE, GTYPE, NTYPE, PTYPE, RTYPE, KTYPE) \
case BASE_TYPE_ ## ENUM: \
if (IsStruct(val.type)) { \
SerializeStruct(builder, *val.type.struct_def, val); \
@ -1661,7 +1661,7 @@ CheckedError Parser::ParseSingleValue(const std::string *name, Value &e,
// clang-format off
switch (match_type) {
#define FLATBUFFERS_TD(ENUM, IDLTYPE, \
CTYPE, JTYPE, GTYPE, NTYPE, PTYPE, RTYPE) \
CTYPE, JTYPE, GTYPE, NTYPE, PTYPE, RTYPE, KTYPE) \
case BASE_TYPE_ ## ENUM: {\
CTYPE val; \
ECHECK(atot(e.constant.c_str(), *this, &val)); \
@ -1897,7 +1897,7 @@ struct EnumValBuilder {
// clang-format off
switch (enum_def.underlying_type.base_type) {
#define FLATBUFFERS_TD(ENUM, IDLTYPE, CTYPE, JTYPE, GTYPE, NTYPE, \
PTYPE, RTYPE) \
PTYPE, RTYPE, KTYPE) \
case BASE_TYPE_##ENUM: { \
if (!IsInteger(BASE_TYPE_##ENUM)) break; \
return ValidateImpl<BASE_TYPE_##ENUM, CTYPE>(ev, next ? 1 : 0); \
@ -2091,6 +2091,7 @@ bool Parser::SupportsAdvancedUnionFeatures() const {
(opts.lang_to_generate & ~(IDLOptions::kCpp | IDLOptions::kJs |
IDLOptions::kTs | IDLOptions::kPhp |
IDLOptions::kJava | IDLOptions::kCSharp |
IDLOptions::kKotlin |
IDLOptions::kBinary)) == 0;
}

460
tests/KotlinTest.kt Normal file
View File

@ -0,0 +1,460 @@
/*
* Copyright 2014 Google Inc. All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
import MyGame.Example.*
import com.google.flatbuffers.ByteBufferUtil
import com.google.flatbuffers.FlatBufferBuilder
import NamespaceA.*
import NamespaceA.NamespaceB.*
import NamespaceA.NamespaceB.TableInNestedNS
import java.io.File
import java.io.FileOutputStream
import java.io.InputStream
import java.io.RandomAccessFile
import java.nio.ByteBuffer
import java.nio.ByteOrder
import java.nio.channels.FileChannel
import com.google.flatbuffers.Constants.SIZE_PREFIX_LENGTH
@kotlin.ExperimentalUnsignedTypes
class KotlinTest {
companion object {
@JvmStatic
fun main(args: Array<String>) {
// First, let's test reading a FlatBuffer generated by C++ code:
// This file was generated from monsterdata_test.json
val data = RandomAccessFile(File("monsterdata_test.mon"), "r").use {
val temp = ByteArray(it.length().toInt())
it.readFully(temp)
temp
}
// Now test it:
val bb = ByteBuffer.wrap(data)
TestBuffer(bb)
// Second, let's create a FlatBuffer from scratch in Java, and test it also.
// We use an initial size of 1 to exercise the reallocation algorithm,
// normally a size larger than the typical FlatBuffer you generate would be
// better for performance.
val fbb = FlatBufferBuilder(1)
TestBuilderBasics(fbb, true)
TestBuilderBasics(fbb, false)
TestExtendedBuffer(fbb.dataBuffer().asReadOnlyBuffer())
TestNamespaceNesting()
TestNestedFlatBuffer()
TestCreateByteVector()
TestCreateUninitializedVector()
TestByteBufferFactory()
TestSizedInputStream()
TestVectorOfUnions()
println("FlatBuffers test: completed successfully")
}
fun TestEnums() {
assert(Color.name(Color.Red.toInt()) == "Red")
assert(Color.name(Color.Blue.toInt()) == "Blue")
assert(Any_.name(Any_.NONE.toInt()) == "NONE")
assert(Any_.name(Any_.Monster.toInt()) == "Monster")
}
fun TestBuffer(bb: ByteBuffer) {
assert(Monster.MonsterBufferHasIdentifier(bb) == true)
val monster = Monster.getRootAsMonster(bb)
assert(monster.hp == 80.toShort())
assert(monster.mana == 150.toShort()) // default
assert(monster.name == "MyMonster")
// monster.friendly() // can't access, deprecated
val pos = monster.pos!!
assert(pos.x == 1.0f)
assert(pos.y == 2.0f)
assert(pos.z == 3.0f)
assert(pos.test1 == 3.0)
// issue: int != byte
assert(pos.test2 == Color.Green)
val t = pos.test3!!
assert(t.a == 5.toShort())
assert(t.b == 6.toByte())
assert(monster.testType == Any_.Monster)
val monster2 = Monster()
assert(monster.test(monster2) != null == true)
assert(monster2.name == "Fred")
assert(monster.inventoryLength == 5)
var invsum = 0u
for (i in 0 until monster.inventoryLength)
invsum += monster.inventory(i)
assert(invsum == 10u)
// Alternative way of accessing a vector:
val ibb = monster.inventoryAsByteBuffer
invsum = 0u
while (ibb.position() < ibb.limit())
invsum += ibb.get().toUInt()
assert(invsum == 10u)
val test_0 = monster.test4(0)!!
val test_1 = monster.test4(1)!!
assert(monster.test4Length == 2)
assert(test_0.a + test_0.b + test_1.a + test_1.b == 100)
assert(monster.testarrayofstringLength == 2)
assert(monster.testarrayofstring(0) == "test1")
assert(monster.testarrayofstring(1) == "test2")
assert(monster.testbool == true)
}
// this method checks additional fields not present in the binary buffer read from file
// these new tests are performed on top of the regular tests
fun TestExtendedBuffer(bb: ByteBuffer) {
TestBuffer(bb)
val monster = Monster.getRootAsMonster(bb)
assert(monster.testhashu32Fnv1 == (1u + Integer.MAX_VALUE.toUInt()))
}
fun TestNamespaceNesting() {
// reference / manipulate these to verify compilation
val fbb = FlatBufferBuilder(1)
TableInNestedNS.startTableInNestedNS(fbb)
TableInNestedNS.addFoo(fbb, 1234)
val nestedTableOff = TableInNestedNS.endTableInNestedNS(fbb)
TableInFirstNS.startTableInFirstNS(fbb)
TableInFirstNS.addFooTable(fbb, nestedTableOff)
}
fun TestNestedFlatBuffer() {
val nestedMonsterName = "NestedMonsterName"
val nestedMonsterHp: Short = 600
val nestedMonsterMana: Short = 1024
var fbb1: FlatBufferBuilder? = FlatBufferBuilder(16)
val str1 = fbb1!!.createString(nestedMonsterName)
Monster.startMonster(fbb1)
Monster.addName(fbb1, str1)
Monster.addHp(fbb1, nestedMonsterHp)
Monster.addMana(fbb1, nestedMonsterMana)
val monster1 = Monster.endMonster(fbb1)
Monster.finishMonsterBuffer(fbb1, monster1)
val fbb1Bytes = fbb1.sizedByteArray()
val fbb2 = FlatBufferBuilder(16)
val str2 = fbb2.createString("My Monster")
val nestedBuffer = Monster.createTestnestedflatbufferVector(fbb2, fbb1Bytes.asUByteArray())
Monster.startMonster(fbb2)
Monster.addName(fbb2, str2)
Monster.addHp(fbb2, 50.toShort())
Monster.addMana(fbb2, 32.toShort())
Monster.addTestnestedflatbuffer(fbb2, nestedBuffer)
val monster = Monster.endMonster(fbb2)
Monster.finishMonsterBuffer(fbb2, monster)
// Now test the data extracted from the nested buffer
val mons = Monster.getRootAsMonster(fbb2.dataBuffer())
val nestedMonster = mons.testnestedflatbufferAsMonster!!
assert(nestedMonsterMana == nestedMonster.mana)
assert(nestedMonsterHp == nestedMonster.hp)
assert(nestedMonsterName == nestedMonster.name)
}
fun TestCreateByteVector() {
val fbb = FlatBufferBuilder(16)
val str = fbb.createString("MyMonster")
val inventory = byteArrayOf(0, 1, 2, 3, 4)
val vec = fbb.createByteVector(inventory)
Monster.startMonster(fbb)
Monster.addInventory(fbb, vec)
Monster.addName(fbb, str)
val monster1 = Monster.endMonster(fbb)
Monster.finishMonsterBuffer(fbb, monster1)
val monsterObject = Monster.getRootAsMonster(fbb.dataBuffer())
assert(monsterObject.inventory(1) == inventory[1].toUByte())
assert(monsterObject.inventoryLength == inventory.size)
assert(ByteBuffer.wrap(inventory) == monsterObject.inventoryAsByteBuffer)
}
fun TestCreateUninitializedVector() {
val fbb = FlatBufferBuilder(16)
val str = fbb.createString("MyMonster")
val inventory = byteArrayOf(0, 1, 2, 3, 4)
val bb = fbb.createUnintializedVector(1, inventory.size, 1)
for (i in inventory) {
bb.put(i)
}
val vec = fbb.endVector()
Monster.startMonster(fbb)
Monster.addInventory(fbb, vec)
Monster.addName(fbb, str)
val monster1 = Monster.endMonster(fbb)
Monster.finishMonsterBuffer(fbb, monster1)
val monsterObject = Monster.getRootAsMonster(fbb.dataBuffer())
assert(monsterObject.inventory(1) == inventory[1].toUByte())
assert(monsterObject.inventoryLength == inventory.size)
assert(ByteBuffer.wrap(inventory) == monsterObject.inventoryAsByteBuffer)
}
fun TestByteBufferFactory() {
class MappedByteBufferFactory : FlatBufferBuilder.ByteBufferFactory() {
override fun newByteBuffer(capacity: Int): ByteBuffer? {
var bb: ByteBuffer?
try {
bb = RandomAccessFile("javatest.bin", "rw").channel.map(
FileChannel.MapMode.READ_WRITE,
0,
capacity.toLong()
).order(ByteOrder.LITTLE_ENDIAN)
} catch (e: Throwable) {
println("FlatBuffers test: couldn't map ByteBuffer to a file")
bb = null
}
return bb
}
}
val fbb = FlatBufferBuilder(1, MappedByteBufferFactory())
TestBuilderBasics(fbb, false)
}
fun TestSizedInputStream() {
// Test on default FlatBufferBuilder that uses HeapByteBuffer
val fbb = FlatBufferBuilder(1)
TestBuilderBasics(fbb, false)
val `in` = fbb.sizedInputStream()
val array = fbb.sizedByteArray()
var count = 0
var currentVal = 0
while (currentVal != -1 && count < array.size) {
try {
currentVal = `in`.read()
} catch (e: java.io.IOException) {
println("FlatBuffers test: couldn't read from InputStream")
return
}
assert(currentVal.toByte() == array[count])
count++
}
assert(count == array.size)
}
fun TestBuilderBasics(fbb: FlatBufferBuilder, sizePrefix: Boolean) {
val names = intArrayOf(fbb.createString("Frodo"), fbb.createString("Barney"), fbb.createString("Wilma"))
val off = IntArray(3)
Monster.startMonster(fbb)
Monster.addName(fbb, names[0])
off[0] = Monster.endMonster(fbb)
Monster.startMonster(fbb)
Monster.addName(fbb, names[1])
off[1] = Monster.endMonster(fbb)
Monster.startMonster(fbb)
Monster.addName(fbb, names[2])
off[2] = Monster.endMonster(fbb)
val sortMons = fbb.createSortedVectorOfTables(Monster(), off)
// We set up the same values as monsterdata.json:
val str = fbb.createString("MyMonster")
val inv = Monster.createInventoryVector(fbb, byteArrayOf(0, 1, 2, 3, 4).asUByteArray())
val fred = fbb.createString("Fred")
Monster.startMonster(fbb)
Monster.addName(fbb, fred)
val mon2 = Monster.endMonster(fbb)
Monster.startTest4Vector(fbb, 2)
Test.createTest(fbb, 10.toShort(), 20.toByte())
Test.createTest(fbb, 30.toShort(), 40.toByte())
val test4 = fbb.endVector()
val testArrayOfString =
Monster.createTestarrayofstringVector(fbb, intArrayOf(fbb.createString("test1"), fbb.createString("test2")))
Monster.startMonster(fbb)
Monster.addPos(
fbb, Vec3.createVec3(
fbb, 1.0f, 2.0f, 3.0f, 3.0,
Color.Green, 5.toShort(), 6.toByte()
)
)
Monster.addHp(fbb, 80.toShort())
Monster.addName(fbb, str)
Monster.addInventory(fbb, inv)
Monster.addTestType(fbb, Any_.Monster)
Monster.addTest(fbb, mon2)
Monster.addTest4(fbb, test4)
Monster.addTestarrayofstring(fbb, testArrayOfString)
Monster.addTestbool(fbb, true)
Monster.addTesthashu32Fnv1(fbb, UInt.MAX_VALUE + 1u)
Monster.addTestarrayoftables(fbb, sortMons)
val mon = Monster.endMonster(fbb)
if (sizePrefix) {
Monster.finishSizePrefixedMonsterBuffer(fbb, mon)
} else {
Monster.finishMonsterBuffer(fbb, mon)
}
// Write the result to a file for debugging purposes:
// Note that the binaries are not necessarily identical, since the JSON
// parser may serialize in a slightly different order than the above
// Java code. They are functionally equivalent though.
try {
val filename = "monsterdata_java_wire" + (if (sizePrefix) "_sp" else "") + ".mon"
val fc = FileOutputStream(filename).channel
fc.write(fbb.dataBuffer().duplicate())
fc.close()
} catch (e: java.io.IOException) {
println("FlatBuffers test: couldn't write file")
return
}
// Test it:
var dataBuffer = fbb.dataBuffer()
if (sizePrefix) {
assert(
ByteBufferUtil.getSizePrefix(dataBuffer) + SIZE_PREFIX_LENGTH ==
dataBuffer.remaining()
)
dataBuffer = ByteBufferUtil.removeSizePrefix(dataBuffer)
}
TestExtendedBuffer(dataBuffer)
// Make sure it also works with read only ByteBuffers. This is slower,
// since creating strings incurs an additional copy
// (see Table.__string).
TestExtendedBuffer(dataBuffer.asReadOnlyBuffer())
TestEnums()
//Attempt to mutate Monster fields and check whether the buffer has been mutated properly
// revert to original values after testing
val monster = Monster.getRootAsMonster(dataBuffer)
// mana is optional and does not exist in the buffer so the mutation should fail
// the mana field should retain its default value
assert(monster.mutateMana(10.toShort()) == false)
assert(monster.mana == 150.toShort())
// Accessing a vector of sorted by the key tables
assert(monster.testarrayoftables(0)!!.name == "Barney")
assert(monster.testarrayoftables(1)!!.name == "Frodo")
assert(monster.testarrayoftables(2)!!.name == "Wilma")
// Example of searching for a table by the key
assert(monster.testarrayoftablesByKey("Frodo")!!.name == "Frodo")
assert(monster.testarrayoftablesByKey("Barney")!!.name == "Barney")
assert(monster.testarrayoftablesByKey("Wilma")!!.name == "Wilma")
// testType is an existing field and mutating it should succeed
assert(monster.testType == Any_.Monster)
assert(monster.mutateTestType(Any_.NONE) == true)
assert(monster.testType == Any_.NONE)
assert(monster.mutateTestType(Any_.Monster) == true)
assert(monster.testType == Any_.Monster)
//mutate the inventory vector
assert(monster.mutateInventory(0, 1u) == true)
assert(monster.mutateInventory(1, 2u) == true)
assert(monster.mutateInventory(2, 3u) == true)
assert(monster.mutateInventory(3, 4u) == true)
assert(monster.mutateInventory(4, 5u) == true)
for (i in 0 until monster.inventoryLength) {
assert(monster.inventory(i) == (i.toUByte() + 1u).toUByte())
}
//reverse mutation
assert(monster.mutateInventory(0, 0u) == true)
assert(monster.mutateInventory(1, 1u) == true)
assert(monster.mutateInventory(2, 2u) == true)
assert(monster.mutateInventory(3, 3u) == true)
assert(monster.mutateInventory(4, 4u) == true)
// get a struct field and edit one of its fields
val pos = monster.pos!!
assert(pos.x == 1.0f)
pos.mutateX(55.0f)
assert(pos.x == 55.0f)
pos.mutateX(1.0f)
assert(pos.x == 1.0f)
}
fun TestVectorOfUnions() {
val fbb = FlatBufferBuilder()
val swordAttackDamage = 1
val characterVector = intArrayOf(Attacker.createAttacker(fbb, swordAttackDamage))
val characterTypeVector = ubyteArrayOf(Character_.MuLan)
Movie.finishMovieBuffer(
fbb,
Movie.createMovie(
fbb,
0u,
0,
Movie.createCharactersTypeVector(fbb, characterTypeVector),
Movie.createCharactersVector(fbb, characterVector)
)
)
val movie = Movie.getRootAsMovie(fbb.dataBuffer())
assert(movie.charactersTypeLength == characterTypeVector.size)
assert(movie.charactersLength == characterVector.size)
assert(movie.charactersType(0) == characterTypeVector[0])
assert((movie.characters(Attacker(), 0) as Attacker).swordAttackDamage == swordAttackDamage)
}
}
}

46
tests/KotlinTest.sh Executable file
View File

@ -0,0 +1,46 @@
#!/bin/sh
# Copyright 2014 Google Inc. All rights reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
echo Compile then run the Kotlin test.
testdir=$(dirname $0)
targetdir="${testdir}/kotlin"
if [[ -e "${targetdir}" ]]; then
echo "cleaning target"
rm -rf "${targetdir}"
fi
mkdir -v "${targetdir}"
if ! find "${testdir}/../java" -type f -name "*.class" -delete; then
echo "failed to clean .class files from java directory" >&2
exit 1
fi
all_kt_files=`find . -name "*.kt" -print`
# Compile java FlatBuffer library
javac ${testdir}/../java/com/google/flatbuffers/*.java -d $targetdir
# Compile Kotlin files
kotlinc $all_kt_files -classpath $targetdir -include-runtime -d $targetdir
# Make jar
jar cvf ${testdir}/kotlin_test.jar -C $targetdir . > /dev/null
# Run test
kotlin -cp ${testdir}/kotlin_test.jar KotlinTest
# clean up
rm -rf $targetdir
rm ${testdir}/kotlin_test.jar

32
tests/MyGame/Example/Ability.kt Normal file
View File

@ -0,0 +1,32 @@
// automatically generated by the FlatBuffers compiler, do not modify
package MyGame.Example
import java.nio.*
import kotlin.math.sign
import com.google.flatbuffers.*
@Suppress("unused")
@ExperimentalUnsignedTypes
class Ability : Struct() {
fun __init(_i: Int, _bb: ByteBuffer) {
__reset(_i, _bb)
}
fun __assign(_i: Int, _bb: ByteBuffer) : Ability {
__init(_i, _bb)
return this
}
val id : UInt get() = bb.getInt(bb_pos + 0).toUInt()
fun mutateId(id: UInt) : ByteBuffer = bb.putInt(bb_pos + 0, id.toInt())
val distance : UInt get() = bb.getInt(bb_pos + 4).toUInt()
fun mutateDistance(distance: UInt) : ByteBuffer = bb.putInt(bb_pos + 4, distance.toInt())
companion object {
fun createAbility(builder: FlatBufferBuilder, id: UInt, distance: UInt) : Int {
builder.prep(4, 8)
builder.putInt(distance.toInt())
builder.putInt(id.toInt())
return builder.offset()
}
}
}

16
tests/MyGame/Example/Any.kt Normal file
View File

@ -0,0 +1,16 @@
// automatically generated by the FlatBuffers compiler, do not modify
package MyGame.Example
@Suppress("unused")
@ExperimentalUnsignedTypes
class Any_ private constructor() {
companion object {
const val NONE: UByte = 0u
const val Monster: UByte = 1u
const val TestSimpleTableWithEnum: UByte = 2u
const val MyGameExample2Monster: UByte = 3u
val names : Array<String> = arrayOf("NONE", "Monster", "TestSimpleTableWithEnum", "MyGame_Example2_Monster")
fun name(e: Int) : String = names[e]
}
}

16
tests/MyGame/Example/AnyAmbiguousAliases.kt Normal file
View File

@ -0,0 +1,16 @@
// automatically generated by the FlatBuffers compiler, do not modify
package MyGame.Example
@Suppress("unused")
@ExperimentalUnsignedTypes
class AnyAmbiguousAliases private constructor() {
companion object {
const val NONE: UByte = 0u
const val M1: UByte = 1u
const val M2: UByte = 2u
const val M3: UByte = 3u
val names : Array<String> = arrayOf("NONE", "M1", "M2", "M3")
fun name(e: Int) : String = names[e]
}
}

16
tests/MyGame/Example/AnyUniqueAliases.kt Normal file
View File

@ -0,0 +1,16 @@
// automatically generated by the FlatBuffers compiler, do not modify
package MyGame.Example
@Suppress("unused")
@ExperimentalUnsignedTypes
class AnyUniqueAliases private constructor() {
companion object {
const val NONE: UByte = 0u
const val M: UByte = 1u
const val TS: UByte = 2u
const val M2: UByte = 3u
val names : Array<String> = arrayOf("NONE", "M", "TS", "M2")
fun name(e: Int) : String = names[e]
}
}

25
tests/MyGame/Example/Color.kt Normal file
View File

@ -0,0 +1,25 @@
// automatically generated by the FlatBuffers compiler, do not modify
package MyGame.Example
/**
* Composite components of Monster color.
*/
@Suppress("unused")
@ExperimentalUnsignedTypes
class Color private constructor() {
companion object {
const val Red: UByte = 1u
/**
* \brief color Green
* Green is bit_flag with value (1u << 1)
*/
const val Green: UByte = 2u
/**
* \brief color Blue (1u << 3)
*/
const val Blue: UByte = 8u
val names : Array<String> = arrayOf("Red", "Green", "", "", "", "", "", "Blue")
fun name(e: Int) : String = names[e - Red.toInt()]
}
}

974
tests/MyGame/Example/Monster.kt Normal file
View File

@ -0,0 +1,974 @@
// automatically generated by the FlatBuffers compiler, do not modify
package MyGame.Example
import java.nio.*
import kotlin.math.sign
import com.google.flatbuffers.*
/**
* an example documentation comment: monster object
*/
@Suppress("unused")
@ExperimentalUnsignedTypes
class Monster : Table() {
fun __init(_i: Int, _bb: ByteBuffer) {
__reset(_i, _bb)
}
fun __assign(_i: Int, _bb: ByteBuffer) : Monster {
__init(_i, _bb)
return this
}
val pos : MyGame.Example.Vec3? get() = pos(MyGame.Example.Vec3())
fun pos(obj: MyGame.Example.Vec3) : MyGame.Example.Vec3? {
val o = __offset(4)
return if (o != 0) {
obj.__assign(o + bb_pos, bb)
} else {
null
}
}
val mana : Short
get() {
val o = __offset(6)
return if(o != 0) bb.getShort(o + bb_pos) else 150
}
fun mutateMana(mana: Short) : Boolean {
val o = __offset(6)
return if (o != 0) {
bb.putShort(o + bb_pos, mana)
true
} else {
false
}
}
val hp : Short
get() {
val o = __offset(8)
return if(o != 0) bb.getShort(o + bb_pos) else 100
}
fun mutateHp(hp: Short) : Boolean {
val o = __offset(8)
return if (o != 0) {
bb.putShort(o + bb_pos, hp)
true
} else {
false
}
}
val name : String?
get() {
val o = __offset(10)
return if (o != 0) __string(o + bb_pos) else null
}
val nameAsByteBuffer : ByteBuffer get() = __vector_as_bytebuffer(10, 1)
fun nameInByteBuffer(_bb: ByteBuffer) : ByteBuffer = __vector_in_bytebuffer(_bb, 10, 1)
fun inventory(j: Int) : UByte {
val o = __offset(14)
return if (o != 0) {
bb.get(__vector(o) + j * 1).toUByte()
} else {
0u
}
}
val inventoryLength : Int
get() {
val o = __offset(14); return if (o != 0) __vector_len(o) else 0
}
val inventoryAsByteBuffer : ByteBuffer get() = __vector_as_bytebuffer(14, 1)
fun inventoryInByteBuffer(_bb: ByteBuffer) : ByteBuffer = __vector_in_bytebuffer(_bb, 14, 1)
fun mutateInventory(j: Int, inventory: UByte) : Boolean {
val o = __offset(14)
return if (o != 0) {
bb.put(__vector(o) + j * 1, inventory.toByte())
true
} else {
false
}
}
val color : UByte
get() {
val o = __offset(16)
return if(o != 0) bb.get(o + bb_pos).toUByte() else 8u
}
fun mutateColor(color: UByte) : Boolean {
val o = __offset(16)
return if (o != 0) {
bb.put(o + bb_pos, color.toByte())
true
} else {
false
}
}
val testType : UByte
get() {
val o = __offset(18)
return if(o != 0) bb.get(o + bb_pos).toUByte() else 0u
}
fun mutateTestType(testType: UByte) : Boolean {
val o = __offset(18)
return if (o != 0) {
bb.put(o + bb_pos, testType.toByte())
true
} else {
false
}
}
fun test(obj: Table) : Table? {
val o = __offset(20); return if (o != 0) __union(obj, o) else null
}
fun test4(j: Int) : MyGame.Example.Test? = test4(MyGame.Example.Test(), j)
fun test4(obj: MyGame.Example.Test, j: Int) : MyGame.Example.Test? {
val o = __offset(22)
return if (o != 0) {
obj.__assign(__vector(o) + j * 4, bb)
} else {
null
}
}
val test4Length : Int
get() {
val o = __offset(22); return if (o != 0) __vector_len(o) else 0
}
fun testarrayofstring(j: Int) : String? {
val o = __offset(24)
return if (o != 0) {
__string(__vector(o) + j * 4)
} else {
null
}
}
val testarrayofstringLength : Int
get() {
val o = __offset(24); return if (o != 0) __vector_len(o) else 0
}
/**
* an example documentation comment: this will end up in the generated code
* multiline too
*/
fun testarrayoftables(j: Int) : MyGame.Example.Monster? = testarrayoftables(MyGame.Example.Monster(), j)
fun testarrayoftables(obj: MyGame.Example.Monster, j: Int) : MyGame.Example.Monster? {
val o = __offset(26)
return if (o != 0) {
obj.__assign(__indirect(__vector(o) + j * 4), bb)
} else {
null
}
}
val testarrayoftablesLength : Int
get() {
val o = __offset(26); return if (o != 0) __vector_len(o) else 0
}
fun testarrayoftablesByKey(key: String) : MyGame.Example.Monster? {
val o = __offset(26)
return if (o != 0) {
MyGame.Example.Monster.__lookup_by_key(null, __vector(o), key, bb)
} else {
null
}
}
fun testarrayoftablesByKey(obj: MyGame.Example.Monster, key: String) : MyGame.Example.Monster? {
val o = __offset(26)
return if (o != 0) {
MyGame.Example.Monster.__lookup_by_key(obj, __vector(o), key, bb)
} else {
null
}
}
val enemy : MyGame.Example.Monster? get() = enemy(MyGame.Example.Monster())
fun enemy(obj: MyGame.Example.Monster) : MyGame.Example.Monster? {
val o = __offset(28)
return if (o != 0) {
obj.__assign(__indirect(o + bb_pos), bb)
} else {
null
}
}
fun testnestedflatbuffer(j: Int) : UByte {
val o = __offset(30)
return if (o != 0) {
bb.get(__vector(o) + j * 1).toUByte()
} else {
0u
}
}
val testnestedflatbufferLength : Int
get() {
val o = __offset(30); return if (o != 0) __vector_len(o) else 0
}
val testnestedflatbufferAsByteBuffer : ByteBuffer get() = __vector_as_bytebuffer(30, 1)
fun testnestedflatbufferInByteBuffer(_bb: ByteBuffer) : ByteBuffer = __vector_in_bytebuffer(_bb, 30, 1)
val testnestedflatbufferAsMonster : MyGame.Example.Monster? get() = testnestedflatbufferAsMonster(MyGame.Example.Monster())
fun testnestedflatbufferAsMonster(obj: MyGame.Example.Monster) : MyGame.Example.Monster? {
val o = __offset(30)
return if (o != 0) {
obj.__assign(__indirect(__vector(o)), bb)
} else {
null
}
}
fun mutateTestnestedflatbuffer(j: Int, testnestedflatbuffer: UByte) : Boolean {
val o = __offset(30)
return if (o != 0) {
bb.put(__vector(o) + j * 1, testnestedflatbuffer.toByte())
true
} else {
false
}
}
val testempty : MyGame.Example.Stat? get() = testempty(MyGame.Example.Stat())
fun testempty(obj: MyGame.Example.Stat) : MyGame.Example.Stat? {
val o = __offset(32)
return if (o != 0) {
obj.__assign(__indirect(o + bb_pos), bb)
} else {
null
}
}
val testbool : Boolean
get() {
val o = __offset(34)
return if(o != 0) 0.toByte() != bb.get(o + bb_pos) else false
}
fun mutateTestbool(testbool: Boolean) : Boolean {
val o = __offset(34)
return if (o != 0) {
bb.put(o + bb_pos, (if(testbool) 1 else 0).toByte())
true
} else {
false
}
}
val testhashs32Fnv1 : Int
get() {
val o = __offset(36)
return if(o != 0) bb.getInt(o + bb_pos) else 0
}
fun mutateTesthashs32Fnv1(testhashs32Fnv1: Int) : Boolean {
val o = __offset(36)
return if (o != 0) {
bb.putInt(o + bb_pos, testhashs32Fnv1)
true
} else {
false
}
}
val testhashu32Fnv1 : UInt
get() {
val o = __offset(38)
return if(o != 0) bb.getInt(o + bb_pos).toUInt() else 0u
}
fun mutateTesthashu32Fnv1(testhashu32Fnv1: UInt) : Boolean {
val o = __offset(38)
return if (o != 0) {
bb.putInt(o + bb_pos, testhashu32Fnv1.toInt())
true
} else {
false
}
}
val testhashs64Fnv1 : Long
get() {
val o = __offset(40)
return if(o != 0) bb.getLong(o + bb_pos) else 0L
}
fun mutateTesthashs64Fnv1(testhashs64Fnv1: Long) : Boolean {
val o = __offset(40)
return if (o != 0) {
bb.putLong(o + bb_pos, testhashs64Fnv1)
true
} else {
false
}
}
val testhashu64Fnv1 : ULong
get() {
val o = __offset(42)
return if(o != 0) bb.getLong(o + bb_pos).toULong() else 0UL
}
fun mutateTesthashu64Fnv1(testhashu64Fnv1: ULong) : Boolean {
val o = __offset(42)
return if (o != 0) {
bb.putLong(o + bb_pos, testhashu64Fnv1.toLong())
true
} else {
false
}
}
val testhashs32Fnv1a : Int
get() {
val o = __offset(44)
return if(o != 0) bb.getInt(o + bb_pos) else 0
}
fun mutateTesthashs32Fnv1a(testhashs32Fnv1a: Int) : Boolean {
val o = __offset(44)
return if (o != 0) {
bb.putInt(o + bb_pos, testhashs32Fnv1a)
true
} else {
false
}
}
val testhashu32Fnv1a : UInt
get() {
val o = __offset(46)
return if(o != 0) bb.getInt(o + bb_pos).toUInt() else 0u
}
fun mutateTesthashu32Fnv1a(testhashu32Fnv1a: UInt) : Boolean {
val o = __offset(46)
return if (o != 0) {
bb.putInt(o + bb_pos, testhashu32Fnv1a.toInt())
true
} else {
false
}
}
val testhashs64Fnv1a : Long
get() {
val o = __offset(48)
return if(o != 0) bb.getLong(o + bb_pos) else 0L
}
fun mutateTesthashs64Fnv1a(testhashs64Fnv1a: Long) : Boolean {
val o = __offset(48)
return if (o != 0) {
bb.putLong(o + bb_pos, testhashs64Fnv1a)
true
} else {
false
}
}
val testhashu64Fnv1a : ULong
get() {
val o = __offset(50)
return if(o != 0) bb.getLong(o + bb_pos).toULong() else 0UL
}
fun mutateTesthashu64Fnv1a(testhashu64Fnv1a: ULong) : Boolean {
val o = __offset(50)
return if (o != 0) {
bb.putLong(o + bb_pos, testhashu64Fnv1a.toLong())
true
} else {
false
}
}
fun testarrayofbools(j: Int) : Boolean {
val o = __offset(52)
return if (o != 0) {
0.toByte() != bb.get(__vector(o) + j * 1)
} else {
false
}
}
val testarrayofboolsLength : Int
get() {
val o = __offset(52); return if (o != 0) __vector_len(o) else 0
}
val testarrayofboolsAsByteBuffer : ByteBuffer get() = __vector_as_bytebuffer(52, 1)
fun testarrayofboolsInByteBuffer(_bb: ByteBuffer) : ByteBuffer = __vector_in_bytebuffer(_bb, 52, 1)
fun mutateTestarrayofbools(j: Int, testarrayofbools: Boolean) : Boolean {
val o = __offset(52)
return if (o != 0) {
bb.put(__vector(o) + j * 1, (if(testarrayofbools) 1 else 0).toByte())
true
} else {
false
}
}
val testf : Float
get() {
val o = __offset(54)
return if(o != 0) bb.getFloat(o + bb_pos) else 3.14159f
}
fun mutateTestf(testf: Float) : Boolean {
val o = __offset(54)
return if (o != 0) {
bb.putFloat(o + bb_pos, testf)
true
} else {
false
}
}
val testf2 : Float
get() {
val o = __offset(56)
return if(o != 0) bb.getFloat(o + bb_pos) else 3.0f
}
fun mutateTestf2(testf2: Float) : Boolean {
val o = __offset(56)
return if (o != 0) {
bb.putFloat(o + bb_pos, testf2)
true
} else {
false
}
}
val testf3 : Float
get() {
val o = __offset(58)
return if(o != 0) bb.getFloat(o + bb_pos) else 0.0f
}
fun mutateTestf3(testf3: Float) : Boolean {
val o = __offset(58)
return if (o != 0) {
bb.putFloat(o + bb_pos, testf3)
true
} else {
false
}
}
fun testarrayofstring2(j: Int) : String? {
val o = __offset(60)
return if (o != 0) {
__string(__vector(o) + j * 4)
} else {
null
}
}
val testarrayofstring2Length : Int
get() {
val o = __offset(60); return if (o != 0) __vector_len(o) else 0
}
fun testarrayofsortedstruct(j: Int) : MyGame.Example.Ability? = testarrayofsortedstruct(MyGame.Example.Ability(), j)
fun testarrayofsortedstruct(obj: MyGame.Example.Ability, j: Int) : MyGame.Example.Ability? {
val o = __offset(62)
return if (o != 0) {
obj.__assign(__vector(o) + j * 8, bb)
} else {
null
}
}
val testarrayofsortedstructLength : Int
get() {
val o = __offset(62); return if (o != 0) __vector_len(o) else 0
}
fun flex(j: Int) : UByte {
val o = __offset(64)
return if (o != 0) {
bb.get(__vector(o) + j * 1).toUByte()
} else {
0u
}
}
val flexLength : Int
get() {
val o = __offset(64); return if (o != 0) __vector_len(o) else 0
}
val flexAsByteBuffer : ByteBuffer get() = __vector_as_bytebuffer(64, 1)
fun flexInByteBuffer(_bb: ByteBuffer) : ByteBuffer = __vector_in_bytebuffer(_bb, 64, 1)
fun mutateFlex(j: Int, flex: UByte) : Boolean {
val o = __offset(64)
return if (o != 0) {
bb.put(__vector(o) + j * 1, flex.toByte())
true
} else {
false
}
}
fun test5(j: Int) : MyGame.Example.Test? = test5(MyGame.Example.Test(), j)
fun test5(obj: MyGame.Example.Test, j: Int) : MyGame.Example.Test? {
val o = __offset(66)
return if (o != 0) {
obj.__assign(__vector(o) + j * 4, bb)
} else {
null
}
}
val test5Length : Int
get() {
val o = __offset(66); return if (o != 0) __vector_len(o) else 0
}
fun vectorOfLongs(j: Int) : Long {
val o = __offset(68)
return if (o != 0) {
bb.getLong(__vector(o) + j * 8)
} else {
0
}
}
val vectorOfLongsLength : Int
get() {
val o = __offset(68); return if (o != 0) __vector_len(o) else 0
}
val vectorOfLongsAsByteBuffer : ByteBuffer get() = __vector_as_bytebuffer(68, 8)
fun vectorOfLongsInByteBuffer(_bb: ByteBuffer) : ByteBuffer = __vector_in_bytebuffer(_bb, 68, 8)
fun mutateVectorOfLongs(j: Int, vectorOfLongs: Long) : Boolean {
val o = __offset(68)
return if (o != 0) {
bb.putLong(__vector(o) + j * 8, vectorOfLongs)
true
} else {
false
}
}
fun vectorOfDoubles(j: Int) : Double {
val o = __offset(70)
return if (o != 0) {
bb.getDouble(__vector(o) + j * 8)
} else {
0.0
}
}
val vectorOfDoublesLength : Int
get() {
val o = __offset(70); return if (o != 0) __vector_len(o) else 0
}
val vectorOfDoublesAsByteBuffer : ByteBuffer get() = __vector_as_bytebuffer(70, 8)
fun vectorOfDoublesInByteBuffer(_bb: ByteBuffer) : ByteBuffer = __vector_in_bytebuffer(_bb, 70, 8)
fun mutateVectorOfDoubles(j: Int, vectorOfDoubles: Double) : Boolean {
val o = __offset(70)
return if (o != 0) {
bb.putDouble(__vector(o) + j * 8, vectorOfDoubles)
true
} else {
false
}
}
val parentNamespaceTest : MyGame.InParentNamespace? get() = parentNamespaceTest(MyGame.InParentNamespace())
fun parentNamespaceTest(obj: MyGame.InParentNamespace) : MyGame.InParentNamespace? {
val o = __offset(72)
return if (o != 0) {
obj.__assign(__indirect(o + bb_pos), bb)
} else {
null
}
}
fun vectorOfReferrables(j: Int) : MyGame.Example.Referrable? = vectorOfReferrables(MyGame.Example.Referrable(), j)
fun vectorOfReferrables(obj: MyGame.Example.Referrable, j: Int) : MyGame.Example.Referrable? {
val o = __offset(74)
return if (o != 0) {
obj.__assign(__indirect(__vector(o) + j * 4), bb)
} else {
null
}
}
val vectorOfReferrablesLength : Int
get() {
val o = __offset(74); return if (o != 0) __vector_len(o) else 0
}
fun vectorOfReferrablesByKey(key: ULong) : MyGame.Example.Referrable? {
val o = __offset(74)
return if (o != 0) {
MyGame.Example.Referrable.__lookup_by_key(null, __vector(o), key, bb)
} else {
null
}
}
fun vectorOfReferrablesByKey(obj: MyGame.Example.Referrable, key: ULong) : MyGame.Example.Referrable? {
val o = __offset(74)
return if (o != 0) {
MyGame.Example.Referrable.__lookup_by_key(obj, __vector(o), key, bb)
} else {
null
}
}
val singleWeakReference : ULong
get() {
val o = __offset(76)
return if(o != 0) bb.getLong(o + bb_pos).toULong() else 0UL
}
fun mutateSingleWeakReference(singleWeakReference: ULong) : Boolean {
val o = __offset(76)
return if (o != 0) {
bb.putLong(o + bb_pos, singleWeakReference.toLong())
true
} else {
false
}
}
fun vectorOfWeakReferences(j: Int) : ULong {
val o = __offset(78)
return if (o != 0) {
bb.getLong(__vector(o) + j * 8).toULong()
} else {
0uL
}
}
val vectorOfWeakReferencesLength : Int
get() {
val o = __offset(78); return if (o != 0) __vector_len(o) else 0
}
val vectorOfWeakReferencesAsByteBuffer : ByteBuffer get() = __vector_as_bytebuffer(78, 8)
fun vectorOfWeakReferencesInByteBuffer(_bb: ByteBuffer) : ByteBuffer = __vector_in_bytebuffer(_bb, 78, 8)
fun mutateVectorOfWeakReferences(j: Int, vectorOfWeakReferences: ULong) : Boolean {
val o = __offset(78)
return if (o != 0) {
bb.putLong(__vector(o) + j * 8, vectorOfWeakReferences.toLong())
true
} else {
false
}
}
fun vectorOfStrongReferrables(j: Int) : MyGame.Example.Referrable? = vectorOfStrongReferrables(MyGame.Example.Referrable(), j)
fun vectorOfStrongReferrables(obj: MyGame.Example.Referrable, j: Int) : MyGame.Example.Referrable? {
val o = __offset(80)
return if (o != 0) {
obj.__assign(__indirect(__vector(o) + j * 4), bb)
} else {
null
}
}
val vectorOfStrongReferrablesLength : Int
get() {
val o = __offset(80); return if (o != 0) __vector_len(o) else 0
}
fun vectorOfStrongReferrablesByKey(key: ULong) : MyGame.Example.Referrable? {
val o = __offset(80)
return if (o != 0) {
MyGame.Example.Referrable.__lookup_by_key(null, __vector(o), key, bb)
} else {
null
}
}
fun vectorOfStrongReferrablesByKey(obj: MyGame.Example.Referrable, key: ULong) : MyGame.Example.Referrable? {
val o = __offset(80)
return if (o != 0) {
MyGame.Example.Referrable.__lookup_by_key(obj, __vector(o), key, bb)
} else {
null
}
}
val coOwningReference : ULong
get() {
val o = __offset(82)
return if(o != 0) bb.getLong(o + bb_pos).toULong() else 0UL
}
fun mutateCoOwningReference(coOwningReference: ULong) : Boolean {
val o = __offset(82)
return if (o != 0) {
bb.putLong(o + bb_pos, coOwningReference.toLong())
true
} else {
false
}
}
fun vectorOfCoOwningReferences(j: Int) : ULong {
val o = __offset(84)
return if (o != 0) {
bb.getLong(__vector(o) + j * 8).toULong()
} else {
0uL
}
}
val vectorOfCoOwningReferencesLength : Int
get() {
val o = __offset(84); return if (o != 0) __vector_len(o) else 0
}
val vectorOfCoOwningReferencesAsByteBuffer : ByteBuffer get() = __vector_as_bytebuffer(84, 8)
fun vectorOfCoOwningReferencesInByteBuffer(_bb: ByteBuffer) : ByteBuffer = __vector_in_bytebuffer(_bb, 84, 8)
fun mutateVectorOfCoOwningReferences(j: Int, vectorOfCoOwningReferences: ULong) : Boolean {
val o = __offset(84)
return if (o != 0) {
bb.putLong(__vector(o) + j * 8, vectorOfCoOwningReferences.toLong())
true
} else {
false
}
}
val nonOwningReference : ULong
get() {
val o = __offset(86)
return if(o != 0) bb.getLong(o + bb_pos).toULong() else 0UL
}
fun mutateNonOwningReference(nonOwningReference: ULong) : Boolean {
val o = __offset(86)
return if (o != 0) {
bb.putLong(o + bb_pos, nonOwningReference.toLong())
true
} else {
false
}
}
fun vectorOfNonOwningReferences(j: Int) : ULong {
val o = __offset(88)
return if (o != 0) {
bb.getLong(__vector(o) + j * 8).toULong()
} else {
0uL
}
}
val vectorOfNonOwningReferencesLength : Int
get() {
val o = __offset(88); return if (o != 0) __vector_len(o) else 0
}
val vectorOfNonOwningReferencesAsByteBuffer : ByteBuffer get() = __vector_as_bytebuffer(88, 8)
fun vectorOfNonOwningReferencesInByteBuffer(_bb: ByteBuffer) : ByteBuffer = __vector_in_bytebuffer(_bb, 88, 8)
fun mutateVectorOfNonOwningReferences(j: Int, vectorOfNonOwningReferences: ULong) : Boolean {
val o = __offset(88)
return if (o != 0) {
bb.putLong(__vector(o) + j * 8, vectorOfNonOwningReferences.toLong())
true
} else {
false
}
}
val anyUniqueType : UByte
get() {
val o = __offset(90)
return if(o != 0) bb.get(o + bb_pos).toUByte() else 0u
}
fun mutateAnyUniqueType(anyUniqueType: UByte) : Boolean {
val o = __offset(90)
return if (o != 0) {
bb.put(o + bb_pos, anyUniqueType.toByte())
true
} else {
false
}
}
fun anyUnique(obj: Table) : Table? {
val o = __offset(92); return if (o != 0) __union(obj, o) else null
}
val anyAmbiguousType : UByte
get() {
val o = __offset(94)
return if(o != 0) bb.get(o + bb_pos).toUByte() else 0u
}
fun mutateAnyAmbiguousType(anyAmbiguousType: UByte) : Boolean {
val o = __offset(94)
return if (o != 0) {
bb.put(o + bb_pos, anyAmbiguousType.toByte())
true
} else {
false
}
}
fun anyAmbiguous(obj: Table) : Table? {
val o = __offset(96); return if (o != 0) __union(obj, o) else null
}
fun vectorOfEnums(j: Int) : UByte {
val o = __offset(98)
return if (o != 0) {
bb.get(__vector(o) + j * 1).toUByte()
} else {
0u
}
}
val vectorOfEnumsLength : Int
get() {
val o = __offset(98); return if (o != 0) __vector_len(o) else 0
}
val vectorOfEnumsAsByteBuffer : ByteBuffer get() = __vector_as_bytebuffer(98, 1)
fun vectorOfEnumsInByteBuffer(_bb: ByteBuffer) : ByteBuffer = __vector_in_bytebuffer(_bb, 98, 1)
fun mutateVectorOfEnums(j: Int, vectorOfEnums: UByte) : Boolean {
val o = __offset(98)
return if (o != 0) {
bb.put(__vector(o) + j * 1, vectorOfEnums.toByte())
true
} else {
false
}
}
override fun keysCompare(o1: Int, o2: Int, _bb: ByteBuffer) : Int {
return compareStrings(__offset(10, o1, _bb), __offset(10, o2, _bb), _bb)
}
companion object {
fun validateVersion() = Constants.FLATBUFFERS_1_11_1()
fun getRootAsMonster(_bb: ByteBuffer): Monster = getRootAsMonster(_bb, Monster())
fun getRootAsMonster(_bb: ByteBuffer, obj: Monster): Monster {
_bb.order(ByteOrder.LITTLE_ENDIAN)
return (obj.__assign(_bb.getInt(_bb.position()) + _bb.position(), _bb))
}
fun MonsterBufferHasIdentifier(_bb: ByteBuffer) : Boolean = __has_identifier(_bb, "MONS")
fun startMonster(builder: FlatBufferBuilder) = builder.startTable(48)
fun addPos(builder: FlatBufferBuilder, pos: Int) = builder.addStruct(0, pos, 0)
fun addMana(builder: FlatBufferBuilder, mana: Short) = builder.addShort(1, mana, 150)
fun addHp(builder: FlatBufferBuilder, hp: Short) = builder.addShort(2, hp, 100)
fun addName(builder: FlatBufferBuilder, name: Int) = builder.addOffset(3, name, 0)
fun addInventory(builder: FlatBufferBuilder, inventory: Int) = builder.addOffset(5, inventory, 0)
fun createInventoryVector(builder: FlatBufferBuilder, data: UByteArray) : Int {
builder.startVector(1, data.size, 1)
for (i in data.size - 1 downTo 0) {
builder.addByte(data[i].toByte())
}
return builder.endVector()
}
fun startInventoryVector(builder: FlatBufferBuilder, numElems: Int) = builder.startVector(1, numElems, 1)
fun addColor(builder: FlatBufferBuilder, color: UByte) = builder.addByte(6, color.toByte(), 8)
fun addTestType(builder: FlatBufferBuilder, testType: UByte) = builder.addByte(7, testType.toByte(), 0)
fun addTest(builder: FlatBufferBuilder, test: Int) = builder.addOffset(8, test, 0)
fun addTest4(builder: FlatBufferBuilder, test4: Int) = builder.addOffset(9, test4, 0)
fun startTest4Vector(builder: FlatBufferBuilder, numElems: Int) = builder.startVector(4, numElems, 2)
fun addTestarrayofstring(builder: FlatBufferBuilder, testarrayofstring: Int) = builder.addOffset(10, testarrayofstring, 0)
fun createTestarrayofstringVector(builder: FlatBufferBuilder, data: IntArray) : Int {
builder.startVector(4, data.size, 4)
for (i in data.size - 1 downTo 0) {
builder.addOffset(data[i])
}
return builder.endVector()
}
fun startTestarrayofstringVector(builder: FlatBufferBuilder, numElems: Int) = builder.startVector(4, numElems, 4)
fun addTestarrayoftables(builder: FlatBufferBuilder, testarrayoftables: Int) = builder.addOffset(11, testarrayoftables, 0)
fun createTestarrayoftablesVector(builder: FlatBufferBuilder, data: IntArray) : Int {
builder.startVector(4, data.size, 4)
for (i in data.size - 1 downTo 0) {
builder.addOffset(data[i])
}
return builder.endVector()
}
fun startTestarrayoftablesVector(builder: FlatBufferBuilder, numElems: Int) = builder.startVector(4, numElems, 4)
fun addEnemy(builder: FlatBufferBuilder, enemy: Int) = builder.addOffset(12, enemy, 0)
fun addTestnestedflatbuffer(builder: FlatBufferBuilder, testnestedflatbuffer: Int) = builder.addOffset(13, testnestedflatbuffer, 0)
fun createTestnestedflatbufferVector(builder: FlatBufferBuilder, data: UByteArray) : Int {
builder.startVector(1, data.size, 1)
for (i in data.size - 1 downTo 0) {
builder.addByte(data[i].toByte())
}
return builder.endVector()
}
fun startTestnestedflatbufferVector(builder: FlatBufferBuilder, numElems: Int) = builder.startVector(1, numElems, 1)
fun addTestempty(builder: FlatBufferBuilder, testempty: Int) = builder.addOffset(14, testempty, 0)
fun addTestbool(builder: FlatBufferBuilder, testbool: Boolean) = builder.addBoolean(15, testbool, false)
fun addTesthashs32Fnv1(builder: FlatBufferBuilder, testhashs32Fnv1: Int) = builder.addInt(16, testhashs32Fnv1, 0)
fun addTesthashu32Fnv1(builder: FlatBufferBuilder, testhashu32Fnv1: UInt) = builder.addInt(17, testhashu32Fnv1.toInt(), 0)
fun addTesthashs64Fnv1(builder: FlatBufferBuilder, testhashs64Fnv1: Long) = builder.addLong(18, testhashs64Fnv1, 0L)
fun addTesthashu64Fnv1(builder: FlatBufferBuilder, testhashu64Fnv1: ULong) = builder.addLong(19, testhashu64Fnv1.toLong(), 0)
fun addTesthashs32Fnv1a(builder: FlatBufferBuilder, testhashs32Fnv1a: Int) = builder.addInt(20, testhashs32Fnv1a, 0)
fun addTesthashu32Fnv1a(builder: FlatBufferBuilder, testhashu32Fnv1a: UInt) = builder.addInt(21, testhashu32Fnv1a.toInt(), 0)
fun addTesthashs64Fnv1a(builder: FlatBufferBuilder, testhashs64Fnv1a: Long) = builder.addLong(22, testhashs64Fnv1a, 0L)
fun addTesthashu64Fnv1a(builder: FlatBufferBuilder, testhashu64Fnv1a: ULong) = builder.addLong(23, testhashu64Fnv1a.toLong(), 0)
fun addTestarrayofbools(builder: FlatBufferBuilder, testarrayofbools: Int) = builder.addOffset(24, testarrayofbools, 0)
fun createTestarrayofboolsVector(builder: FlatBufferBuilder, data: BooleanArray) : Int {
builder.startVector(1, data.size, 1)
for (i in data.size - 1 downTo 0) {
builder.addBoolean(data[i])
}
return builder.endVector()
}
fun startTestarrayofboolsVector(builder: FlatBufferBuilder, numElems: Int) = builder.startVector(1, numElems, 1)
fun addTestf(builder: FlatBufferBuilder, testf: Float) = builder.addFloat(25, testf, 3.14159)
fun addTestf2(builder: FlatBufferBuilder, testf2: Float) = builder.addFloat(26, testf2, 3.0)
fun addTestf3(builder: FlatBufferBuilder, testf3: Float) = builder.addFloat(27, testf3, 0.0)
fun addTestarrayofstring2(builder: FlatBufferBuilder, testarrayofstring2: Int) = builder.addOffset(28, testarrayofstring2, 0)
fun createTestarrayofstring2Vector(builder: FlatBufferBuilder, data: IntArray) : Int {
builder.startVector(4, data.size, 4)
for (i in data.size - 1 downTo 0) {
builder.addOffset(data[i])
}
return builder.endVector()
}
fun startTestarrayofstring2Vector(builder: FlatBufferBuilder, numElems: Int) = builder.startVector(4, numElems, 4)
fun addTestarrayofsortedstruct(builder: FlatBufferBuilder, testarrayofsortedstruct: Int) = builder.addOffset(29, testarrayofsortedstruct, 0)
fun startTestarrayofsortedstructVector(builder: FlatBufferBuilder, numElems: Int) = builder.startVector(8, numElems, 4)
fun addFlex(builder: FlatBufferBuilder, flex: Int) = builder.addOffset(30, flex, 0)
fun createFlexVector(builder: FlatBufferBuilder, data: UByteArray) : Int {
builder.startVector(1, data.size, 1)
for (i in data.size - 1 downTo 0) {
builder.addByte(data[i].toByte())
}
return builder.endVector()
}
fun startFlexVector(builder: FlatBufferBuilder, numElems: Int) = builder.startVector(1, numElems, 1)
fun addTest5(builder: FlatBufferBuilder, test5: Int) = builder.addOffset(31, test5, 0)
fun startTest5Vector(builder: FlatBufferBuilder, numElems: Int) = builder.startVector(4, numElems, 2)
fun addVectorOfLongs(builder: FlatBufferBuilder, vectorOfLongs: Int) = builder.addOffset(32, vectorOfLongs, 0)
fun createVectorOfLongsVector(builder: FlatBufferBuilder, data: LongArray) : Int {
builder.startVector(8, data.size, 8)
for (i in data.size - 1 downTo 0) {
builder.addLong(data[i])
}
return builder.endVector()
}
fun startVectorOfLongsVector(builder: FlatBufferBuilder, numElems: Int) = builder.startVector(8, numElems, 8)
fun addVectorOfDoubles(builder: FlatBufferBuilder, vectorOfDoubles: Int) = builder.addOffset(33, vectorOfDoubles, 0)
fun createVectorOfDoublesVector(builder: FlatBufferBuilder, data: DoubleArray) : Int {
builder.startVector(8, data.size, 8)
for (i in data.size - 1 downTo 0) {
builder.addDouble(data[i])
}
return builder.endVector()
}
fun startVectorOfDoublesVector(builder: FlatBufferBuilder, numElems: Int) = builder.startVector(8, numElems, 8)
fun addParentNamespaceTest(builder: FlatBufferBuilder, parentNamespaceTest: Int) = builder.addOffset(34, parentNamespaceTest, 0)
fun addVectorOfReferrables(builder: FlatBufferBuilder, vectorOfReferrables: Int) = builder.addOffset(35, vectorOfReferrables, 0)
fun createVectorOfReferrablesVector(builder: FlatBufferBuilder, data: IntArray) : Int {
builder.startVector(4, data.size, 4)
for (i in data.size - 1 downTo 0) {
builder.addOffset(data[i])
}
return builder.endVector()
}
fun startVectorOfReferrablesVector(builder: FlatBufferBuilder, numElems: Int) = builder.startVector(4, numElems, 4)
fun addSingleWeakReference(builder: FlatBufferBuilder, singleWeakReference: ULong) = builder.addLong(36, singleWeakReference.toLong(), 0)
fun addVectorOfWeakReferences(builder: FlatBufferBuilder, vectorOfWeakReferences: Int) = builder.addOffset(37, vectorOfWeakReferences, 0)
fun createVectorOfWeakReferencesVector(builder: FlatBufferBuilder, data: ULongArray) : Int {
builder.startVector(8, data.size, 8)
for (i in data.size - 1 downTo 0) {
builder.addLong(data[i].toLong())
}
return builder.endVector()
}
fun startVectorOfWeakReferencesVector(builder: FlatBufferBuilder, numElems: Int) = builder.startVector(8, numElems, 8)
fun addVectorOfStrongReferrables(builder: FlatBufferBuilder, vectorOfStrongReferrables: Int) = builder.addOffset(38, vectorOfStrongReferrables, 0)
fun createVectorOfStrongReferrablesVector(builder: FlatBufferBuilder, data: IntArray) : Int {
builder.startVector(4, data.size, 4)
for (i in data.size - 1 downTo 0) {
builder.addOffset(data[i])
}
return builder.endVector()
}
fun startVectorOfStrongReferrablesVector(builder: FlatBufferBuilder, numElems: Int) = builder.startVector(4, numElems, 4)
fun addCoOwningReference(builder: FlatBufferBuilder, coOwningReference: ULong) = builder.addLong(39, coOwningReference.toLong(), 0)
fun addVectorOfCoOwningReferences(builder: FlatBufferBuilder, vectorOfCoOwningReferences: Int) = builder.addOffset(40, vectorOfCoOwningReferences, 0)
fun createVectorOfCoOwningReferencesVector(builder: FlatBufferBuilder, data: ULongArray) : Int {
builder.startVector(8, data.size, 8)
for (i in data.size - 1 downTo 0) {
builder.addLong(data[i].toLong())
}
return builder.endVector()
}
fun startVectorOfCoOwningReferencesVector(builder: FlatBufferBuilder, numElems: Int) = builder.startVector(8, numElems, 8)
fun addNonOwningReference(builder: FlatBufferBuilder, nonOwningReference: ULong) = builder.addLong(41, nonOwningReference.toLong(), 0)
fun addVectorOfNonOwningReferences(builder: FlatBufferBuilder, vectorOfNonOwningReferences: Int) = builder.addOffset(42, vectorOfNonOwningReferences, 0)
fun createVectorOfNonOwningReferencesVector(builder: FlatBufferBuilder, data: ULongArray) : Int {
builder.startVector(8, data.size, 8)
for (i in data.size - 1 downTo 0) {
builder.addLong(data[i].toLong())
}
return builder.endVector()
}
fun startVectorOfNonOwningReferencesVector(builder: FlatBufferBuilder, numElems: Int) = builder.startVector(8, numElems, 8)
fun addAnyUniqueType(builder: FlatBufferBuilder, anyUniqueType: UByte) = builder.addByte(43, anyUniqueType.toByte(), 0)
fun addAnyUnique(builder: FlatBufferBuilder, anyUnique: Int) = builder.addOffset(44, anyUnique, 0)
fun addAnyAmbiguousType(builder: FlatBufferBuilder, anyAmbiguousType: UByte) = builder.addByte(45, anyAmbiguousType.toByte(), 0)
fun addAnyAmbiguous(builder: FlatBufferBuilder, anyAmbiguous: Int) = builder.addOffset(46, anyAmbiguous, 0)
fun addVectorOfEnums(builder: FlatBufferBuilder, vectorOfEnums: Int) = builder.addOffset(47, vectorOfEnums, 0)
fun createVectorOfEnumsVector(builder: FlatBufferBuilder, data: UByteArray) : Int {
builder.startVector(1, data.size, 1)
for (i in data.size - 1 downTo 0) {
builder.addByte(data[i].toByte())
}
return builder.endVector()
}
fun startVectorOfEnumsVector(builder: FlatBufferBuilder, numElems: Int) = builder.startVector(1, numElems, 1)
fun endMonster(builder: FlatBufferBuilder) : Int {
val o = builder.endTable()
builder.required(o, 10)
return o
}
fun finishMonsterBuffer(builder: FlatBufferBuilder, offset: Int) = builder.finish(offset, "MONS")
fun finishSizePrefixedMonsterBuffer(builder: FlatBufferBuilder, offset: Int) = builder.finishSizePrefixed(offset, "MONS")
fun __lookup_by_key(obj: Monster?, vectorLocation: Int, key: String, bb: ByteBuffer) : Monster? {
val byteKey = key.toByteArray(Table.UTF8_CHARSET.get()!!)
var span = bb.getInt(vectorLocation - 4)
var start = 0
while (span != 0) {
var middle = span / 2
val tableOffset = __indirect(vectorLocation + 4 * (start + middle), bb)
val comp = compareStrings(__offset(10, bb.capacity() - tableOffset, bb), byteKey, bb)
when {
comp > 0 -> span = middle
comp < 0 -> {
middle++
start += middle
span -= middle
}
else -> {
return (obj ?: Monster()).__assign(tableOffset, bb)
}
}
}
return null
}
}
}

80
tests/MyGame/Example/Referrable.kt Normal file
View File

@ -0,0 +1,80 @@
// automatically generated by the FlatBuffers compiler, do not modify
package MyGame.Example
import java.nio.*
import kotlin.math.sign
import com.google.flatbuffers.*
@Suppress("unused")
@ExperimentalUnsignedTypes
class Referrable : Table() {
fun __init(_i: Int, _bb: ByteBuffer) {
__reset(_i, _bb)
}
fun __assign(_i: Int, _bb: ByteBuffer) : Referrable {
__init(_i, _bb)
return this
}
val id : ULong
get() {
val o = __offset(4)
return if(o != 0) bb.getLong(o + bb_pos).toULong() else 0UL
}
fun mutateId(id: ULong) : Boolean {
val o = __offset(4)
return if (o != 0) {
bb.putLong(o + bb_pos, id.toLong())
true
} else {
false
}
}
override fun keysCompare(o1: Int, o2: Int, _bb: ByteBuffer) : Int {
val val_1 = _bb.getLong(__offset(4, o1, _bb))
val val_2 = _bb.getLong(__offset(4, o2, _bb))
return (val_1 - val_2).sign
}
companion object {
fun validateVersion() = Constants.FLATBUFFERS_1_11_1()
fun getRootAsReferrable(_bb: ByteBuffer): Referrable = getRootAsReferrable(_bb, Referrable())
fun getRootAsReferrable(_bb: ByteBuffer, obj: Referrable): Referrable {
_bb.order(ByteOrder.LITTLE_ENDIAN)
return (obj.__assign(_bb.getInt(_bb.position()) + _bb.position(), _bb))
}
fun createReferrable(builder: FlatBufferBuilder, id: ULong) : Int {
builder.startTable(1)
addId(builder, id)
return endReferrable(builder)
}
fun startReferrable(builder: FlatBufferBuilder) = builder.startTable(1)
fun addId(builder: FlatBufferBuilder, id: ULong) = builder.addLong(0, id.toLong(), 0)
fun endReferrable(builder: FlatBufferBuilder) : Int {
val o = builder.endTable()
return o
}
fun __lookup_by_key(obj: Referrable?, vectorLocation: Int, key: ULong, bb: ByteBuffer) : Referrable? {
var span = bb.getInt(vectorLocation - 4)
var start = 0
while (span != 0) {
var middle = span / 2
val tableOffset = __indirect(vectorLocation + 4 * (start + middle), bb)
val value = bb.getLong(__offset(4, bb.capacity() - tableOffset, bb)).toULong()
val comp = value.compareTo(key)
when {
comp > 0 -> span = middle
comp < 0 -> {
middle++
start += middle
span -= middle
}
else -> {
return (obj ?: Referrable()).__assign(tableOffset, bb)
}
}
}
return null
}
}
}

78
tests/MyGame/Example/Stat.kt Normal file
View File

@ -0,0 +1,78 @@
// automatically generated by the FlatBuffers compiler, do not modify
package MyGame.Example
import java.nio.*
import kotlin.math.sign
import com.google.flatbuffers.*
@Suppress("unused")
@ExperimentalUnsignedTypes
class Stat : Table() {
fun __init(_i: Int, _bb: ByteBuffer) {
__reset(_i, _bb)
}
fun __assign(_i: Int, _bb: ByteBuffer) : Stat {
__init(_i, _bb)
return this
}
val id : String?
get() {
val o = __offset(4)
return if (o != 0) __string(o + bb_pos) else null
}
val idAsByteBuffer : ByteBuffer get() = __vector_as_bytebuffer(4, 1)
fun idInByteBuffer(_bb: ByteBuffer) : ByteBuffer = __vector_in_bytebuffer(_bb, 4, 1)
val val_ : Long
get() {
val o = __offset(6)
return if(o != 0) bb.getLong(o + bb_pos) else 0L
}
fun mutateVal_(val_: Long) : Boolean {
val o = __offset(6)
return if (o != 0) {
bb.putLong(o + bb_pos, val_)
true
} else {
false
}
}
val count : UShort
get() {
val o = __offset(8)
return if(o != 0) bb.getShort(o + bb_pos).toUShort() else 0u
}
fun mutateCount(count: UShort) : Boolean {
val o = __offset(8)
return if (o != 0) {
bb.putShort(o + bb_pos, count.toShort())
true
} else {
false
}
}
companion object {
fun validateVersion() = Constants.FLATBUFFERS_1_11_1()
fun getRootAsStat(_bb: ByteBuffer): Stat = getRootAsStat(_bb, Stat())
fun getRootAsStat(_bb: ByteBuffer, obj: Stat): Stat {
_bb.order(ByteOrder.LITTLE_ENDIAN)
return (obj.__assign(_bb.getInt(_bb.position()) + _bb.position(), _bb))
}
fun createStat(builder: FlatBufferBuilder, idOffset: Int, val_: Long, count: UShort) : Int {
builder.startTable(3)
addVal_(builder, val_)
addId(builder, idOffset)
addCount(builder, count)
return endStat(builder)
}
fun startStat(builder: FlatBufferBuilder) = builder.startTable(3)
fun addId(builder: FlatBufferBuilder, id: Int) = builder.addOffset(0, id, 0)
fun addVal_(builder: FlatBufferBuilder, val_: Long) = builder.addLong(1, val_, 0L)
fun addCount(builder: FlatBufferBuilder, count: UShort) = builder.addShort(2, count.toShort(), 0)
fun endStat(builder: FlatBufferBuilder) : Int {
val o = builder.endTable()
return o
}
}
}

33
tests/MyGame/Example/Test.kt Normal file
View File

@ -0,0 +1,33 @@
// automatically generated by the FlatBuffers compiler, do not modify
package MyGame.Example
import java.nio.*
import kotlin.math.sign
import com.google.flatbuffers.*
@Suppress("unused")
@ExperimentalUnsignedTypes
class Test : Struct() {
fun __init(_i: Int, _bb: ByteBuffer) {
__reset(_i, _bb)
}
fun __assign(_i: Int, _bb: ByteBuffer) : Test {
__init(_i, _bb)
return this
}
val a : Short get() = bb.getShort(bb_pos + 0)
fun mutateA(a: Short) : ByteBuffer = bb.putShort(bb_pos + 0, a)
val b : Byte get() = bb.get(bb_pos + 2)
fun mutateB(b: Byte) : ByteBuffer = bb.put(bb_pos + 2, b)
companion object {
fun createTest(builder: FlatBufferBuilder, a: Short, b: Byte) : Int {
builder.prep(2, 4)
builder.pad(1)
builder.putByte(b)
builder.putShort(a)
return builder.offset()
}
}
}

14
tests/MyGame/Example/TestEnum.kt Normal file
View File

@ -0,0 +1,14 @@
// automatically generated by the FlatBuffers compiler, do not modify
package MyGame.Example
@Suppress("unused")
class TestEnum private constructor() {
companion object {
const val A: Byte = 0
const val B: Byte = 1
const val C: Byte = 2
val names : Array<String> = arrayOf("A", "B", "C")
fun name(e: Int) : String = names[e]
}
}

53
tests/MyGame/Example/TestSimpleTableWithEnum.kt Normal file
View File

@ -0,0 +1,53 @@
// automatically generated by the FlatBuffers compiler, do not modify
package MyGame.Example
import java.nio.*
import kotlin.math.sign
import com.google.flatbuffers.*
@Suppress("unused")
@ExperimentalUnsignedTypes
class TestSimpleTableWithEnum : Table() {
fun __init(_i: Int, _bb: ByteBuffer) {
__reset(_i, _bb)
}
fun __assign(_i: Int, _bb: ByteBuffer) : TestSimpleTableWithEnum {
__init(_i, _bb)
return this
}
val color : UByte
get() {
val o = __offset(4)
return if(o != 0) bb.get(o + bb_pos).toUByte() else 2u
}
fun mutateColor(color: UByte) : Boolean {
val o = __offset(4)
return if (o != 0) {
bb.put(o + bb_pos, color.toByte())
true
} else {
false
}
}
companion object {
fun validateVersion() = Constants.FLATBUFFERS_1_11_1()
fun getRootAsTestSimpleTableWithEnum(_bb: ByteBuffer): TestSimpleTableWithEnum = getRootAsTestSimpleTableWithEnum(_bb, TestSimpleTableWithEnum())
fun getRootAsTestSimpleTableWithEnum(_bb: ByteBuffer, obj: TestSimpleTableWithEnum): TestSimpleTableWithEnum {
_bb.order(ByteOrder.LITTLE_ENDIAN)
return (obj.__assign(_bb.getInt(_bb.position()) + _bb.position(), _bb))
}
fun createTestSimpleTableWithEnum(builder: FlatBufferBuilder, color: UByte) : Int {
builder.startTable(1)
addColor(builder, color)
return endTestSimpleTableWithEnum(builder)
}
fun startTestSimpleTableWithEnum(builder: FlatBufferBuilder) = builder.startTable(1)
fun addColor(builder: FlatBufferBuilder, color: UByte) = builder.addByte(0, color.toByte(), 2)
fun endTestSimpleTableWithEnum(builder: FlatBufferBuilder) : Int {
val o = builder.endTable()
return o
}
}
}

263
tests/MyGame/Example/TypeAliases.kt Normal file
View File

@ -0,0 +1,263 @@
// automatically generated by the FlatBuffers compiler, do not modify
package MyGame.Example
import java.nio.*
import kotlin.math.sign
import com.google.flatbuffers.*
@Suppress("unused")
@ExperimentalUnsignedTypes
class TypeAliases : Table() {
fun __init(_i: Int, _bb: ByteBuffer) {
__reset(_i, _bb)
}
fun __assign(_i: Int, _bb: ByteBuffer) : TypeAliases {
__init(_i, _bb)
return this
}
val i8 : Byte
get() {
val o = __offset(4)
return if(o != 0) bb.get(o + bb_pos) else 0
}
fun mutateI8(i8: Byte) : Boolean {
val o = __offset(4)
return if (o != 0) {
bb.put(o + bb_pos, i8)
true
} else {
false
}
}
val u8 : UByte
get() {
val o = __offset(6)
return if(o != 0) bb.get(o + bb_pos).toUByte() else 0u
}
fun mutateU8(u8: UByte) : Boolean {
val o = __offset(6)
return if (o != 0) {
bb.put(o + bb_pos, u8.toByte())
true
} else {
false
}
}
val i16 : Short
get() {
val o = __offset(8)
return if(o != 0) bb.getShort(o + bb_pos) else 0
}
fun mutateI16(i16: Short) : Boolean {
val o = __offset(8)
return if (o != 0) {
bb.putShort(o + bb_pos, i16)
true
} else {
false
}
}
val u16 : UShort
get() {
val o = __offset(10)
return if(o != 0) bb.getShort(o + bb_pos).toUShort() else 0u
}
fun mutateU16(u16: UShort) : Boolean {
val o = __offset(10)
return if (o != 0) {
bb.putShort(o + bb_pos, u16.toShort())
true
} else {
false
}
}
val i32 : Int
get() {
val o = __offset(12)
return if(o != 0) bb.getInt(o + bb_pos) else 0
}
fun mutateI32(i32: Int) : Boolean {
val o = __offset(12)
return if (o != 0) {
bb.putInt(o + bb_pos, i32)
true
} else {
false
}
}
val u32 : UInt
get() {
val o = __offset(14)
return if(o != 0) bb.getInt(o + bb_pos).toUInt() else 0u
}
fun mutateU32(u32: UInt) : Boolean {
val o = __offset(14)
return if (o != 0) {
bb.putInt(o + bb_pos, u32.toInt())
true
} else {
false
}
}
val i64 : Long
get() {
val o = __offset(16)
return if(o != 0) bb.getLong(o + bb_pos) else 0L
}
fun mutateI64(i64: Long) : Boolean {
val o = __offset(16)
return if (o != 0) {
bb.putLong(o + bb_pos, i64)
true
} else {
false
}
}
val u64 : ULong
get() {
val o = __offset(18)
return if(o != 0) bb.getLong(o + bb_pos).toULong() else 0UL
}
fun mutateU64(u64: ULong) : Boolean {
val o = __offset(18)
return if (o != 0) {
bb.putLong(o + bb_pos, u64.toLong())
true
} else {
false
}
}
val f32 : Float
get() {
val o = __offset(20)
return if(o != 0) bb.getFloat(o + bb_pos) else 0.0f
}
fun mutateF32(f32: Float) : Boolean {
val o = __offset(20)
return if (o != 0) {
bb.putFloat(o + bb_pos, f32)
true
} else {
false
}
}
val f64 : Double
get() {
val o = __offset(22)
return if(o != 0) bb.getDouble(o + bb_pos) else 0.0
}
fun mutateF64(f64: Double) : Boolean {
val o = __offset(22)
return if (o != 0) {
bb.putDouble(o + bb_pos, f64)
true
} else {
false
}
}
fun v8(j: Int) : Byte {
val o = __offset(24)
return if (o != 0) {
bb.get(__vector(o) + j * 1)
} else {
0
}
}
val v8Length : Int
get() {
val o = __offset(24); return if (o != 0) __vector_len(o) else 0
}
val v8AsByteBuffer : ByteBuffer get() = __vector_as_bytebuffer(24, 1)
fun v8InByteBuffer(_bb: ByteBuffer) : ByteBuffer = __vector_in_bytebuffer(_bb, 24, 1)
fun mutateV8(j: Int, v8: Byte) : Boolean {
val o = __offset(24)
return if (o != 0) {
bb.put(__vector(o) + j * 1, v8)
true
} else {
false
}
}
fun vf64(j: Int) : Double {
val o = __offset(26)
return if (o != 0) {
bb.getDouble(__vector(o) + j * 8)
} else {
0.0
}
}
val vf64Length : Int
get() {
val o = __offset(26); return if (o != 0) __vector_len(o) else 0
}
val vf64AsByteBuffer : ByteBuffer get() = __vector_as_bytebuffer(26, 8)
fun vf64InByteBuffer(_bb: ByteBuffer) : ByteBuffer = __vector_in_bytebuffer(_bb, 26, 8)
fun mutateVf64(j: Int, vf64: Double) : Boolean {
val o = __offset(26)
return if (o != 0) {
bb.putDouble(__vector(o) + j * 8, vf64)
true
} else {
false
}
}
companion object {
fun validateVersion() = Constants.FLATBUFFERS_1_11_1()
fun getRootAsTypeAliases(_bb: ByteBuffer): TypeAliases = getRootAsTypeAliases(_bb, TypeAliases())
fun getRootAsTypeAliases(_bb: ByteBuffer, obj: TypeAliases): TypeAliases {
_bb.order(ByteOrder.LITTLE_ENDIAN)
return (obj.__assign(_bb.getInt(_bb.position()) + _bb.position(), _bb))
}
fun createTypeAliases(builder: FlatBufferBuilder, i8: Byte, u8: UByte, i16: Short, u16: UShort, i32: Int, u32: UInt, i64: Long, u64: ULong, f32: Float, f64: Double, v8Offset: Int, vf64Offset: Int) : Int {
builder.startTable(12)
addF64(builder, f64)
addU64(builder, u64)
addI64(builder, i64)
addVf64(builder, vf64Offset)
addV8(builder, v8Offset)
addF32(builder, f32)
addU32(builder, u32)
addI32(builder, i32)
addU16(builder, u16)
addI16(builder, i16)
addU8(builder, u8)
addI8(builder, i8)
return endTypeAliases(builder)
}
fun startTypeAliases(builder: FlatBufferBuilder) = builder.startTable(12)
fun addI8(builder: FlatBufferBuilder, i8: Byte) = builder.addByte(0, i8, 0)
fun addU8(builder: FlatBufferBuilder, u8: UByte) = builder.addByte(1, u8.toByte(), 0)
fun addI16(builder: FlatBufferBuilder, i16: Short) = builder.addShort(2, i16, 0)
fun addU16(builder: FlatBufferBuilder, u16: UShort) = builder.addShort(3, u16.toShort(), 0)
fun addI32(builder: FlatBufferBuilder, i32: Int) = builder.addInt(4, i32, 0)
fun addU32(builder: FlatBufferBuilder, u32: UInt) = builder.addInt(5, u32.toInt(), 0)
fun addI64(builder: FlatBufferBuilder, i64: Long) = builder.addLong(6, i64, 0L)
fun addU64(builder: FlatBufferBuilder, u64: ULong) = builder.addLong(7, u64.toLong(), 0)
fun addF32(builder: FlatBufferBuilder, f32: Float) = builder.addFloat(8, f32, 0.0)
fun addF64(builder: FlatBufferBuilder, f64: Double) = builder.addDouble(9, f64, 0.0)
fun addV8(builder: FlatBufferBuilder, v8: Int) = builder.addOffset(10, v8, 0)
fun createV8Vector(builder: FlatBufferBuilder, data: ByteArray) : Int {
builder.startVector(1, data.size, 1)
for (i in data.size - 1 downTo 0) {
builder.addByte(data[i])
}
return builder.endVector()
}
fun startV8Vector(builder: FlatBufferBuilder, numElems: Int) = builder.startVector(1, numElems, 1)
fun addVf64(builder: FlatBufferBuilder, vf64: Int) = builder.addOffset(11, vf64, 0)
fun createVf64Vector(builder: FlatBufferBuilder, data: DoubleArray) : Int {
builder.startVector(8, data.size, 8)
for (i in data.size - 1 downTo 0) {
builder.addDouble(data[i])
}
return builder.endVector()
}
fun startVf64Vector(builder: FlatBufferBuilder, numElems: Int) = builder.startVector(8, numElems, 8)
fun endTypeAliases(builder: FlatBufferBuilder) : Int {
val o = builder.endTable()
return o
}
}
}

50
tests/MyGame/Example/Vec3.kt Normal file
View File

@ -0,0 +1,50 @@
// automatically generated by the FlatBuffers compiler, do not modify
package MyGame.Example
import java.nio.*
import kotlin.math.sign
import com.google.flatbuffers.*
@Suppress("unused")
@ExperimentalUnsignedTypes
class Vec3 : Struct() {
fun __init(_i: Int, _bb: ByteBuffer) {
__reset(_i, _bb)
}
fun __assign(_i: Int, _bb: ByteBuffer) : Vec3 {
__init(_i, _bb)
return this
}
val x : Float get() = bb.getFloat(bb_pos + 0)
fun mutateX(x: Float) : ByteBuffer = bb.putFloat(bb_pos + 0, x)
val y : Float get() = bb.getFloat(bb_pos + 4)
fun mutateY(y: Float) : ByteBuffer = bb.putFloat(bb_pos + 4, y)
val z : Float get() = bb.getFloat(bb_pos + 8)
fun mutateZ(z: Float) : ByteBuffer = bb.putFloat(bb_pos + 8, z)
val test1 : Double get() = bb.getDouble(bb_pos + 16)
fun mutateTest1(test1: Double) : ByteBuffer = bb.putDouble(bb_pos + 16, test1)
val test2 : UByte get() = bb.get(bb_pos + 24).toUByte()
fun mutateTest2(test2: UByte) : ByteBuffer = bb.put(bb_pos + 24, test2.toByte())
val test3 : MyGame.Example.Test? get() = test3(MyGame.Example.Test())
fun test3(obj: MyGame.Example.Test) : MyGame.Example.Test? = obj.__assign(bb_pos + 26, bb)
companion object {
fun createVec3(builder: FlatBufferBuilder, x: Float, y: Float, z: Float, test1: Double, test2: UByte, test3_a: Short, test3_b: Byte) : Int {
builder.prep(8, 32)
builder.pad(2)
builder.prep(2, 4)
builder.pad(1)
builder.putByte(test3_b)
builder.putShort(test3_a)
builder.pad(1)
builder.putByte(test2.toByte())
builder.putDouble(test1)
builder.pad(4)
builder.putFloat(z)
builder.putFloat(y)
builder.putFloat(x)
return builder.offset()
}
}
}

33
tests/MyGame/Example2/Monster.kt Normal file
View File

@ -0,0 +1,33 @@
// automatically generated by the FlatBuffers compiler, do not modify
package MyGame.Example2
import java.nio.*
import kotlin.math.sign
import com.google.flatbuffers.*
@Suppress("unused")
@ExperimentalUnsignedTypes
class Monster : Table() {
fun __init(_i: Int, _bb: ByteBuffer) {
__reset(_i, _bb)
}
fun __assign(_i: Int, _bb: ByteBuffer) : Monster {
__init(_i, _bb)
return this
}
companion object {
fun validateVersion() = Constants.FLATBUFFERS_1_11_1()
fun getRootAsMonster(_bb: ByteBuffer): Monster = getRootAsMonster(_bb, Monster())
fun getRootAsMonster(_bb: ByteBuffer, obj: Monster): Monster {
_bb.order(ByteOrder.LITTLE_ENDIAN)
return (obj.__assign(_bb.getInt(_bb.position()) + _bb.position(), _bb))
}
fun startMonster(builder: FlatBufferBuilder) = builder.startTable(0)
fun endMonster(builder: FlatBufferBuilder) : Int {
val o = builder.endTable()
return o
}
}
}

33
tests/MyGame/InParentNamespace.kt Normal file
View File

@ -0,0 +1,33 @@
// automatically generated by the FlatBuffers compiler, do not modify
package MyGame
import java.nio.*
import kotlin.math.sign
import com.google.flatbuffers.*
@Suppress("unused")
@ExperimentalUnsignedTypes
class InParentNamespace : Table() {
fun __init(_i: Int, _bb: ByteBuffer) {
__reset(_i, _bb)
}
fun __assign(_i: Int, _bb: ByteBuffer) : InParentNamespace {
__init(_i, _bb)
return this
}
companion object {
fun validateVersion() = Constants.FLATBUFFERS_1_11_1()
fun getRootAsInParentNamespace(_bb: ByteBuffer): InParentNamespace = getRootAsInParentNamespace(_bb, InParentNamespace())
fun getRootAsInParentNamespace(_bb: ByteBuffer, obj: InParentNamespace): InParentNamespace {
_bb.order(ByteOrder.LITTLE_ENDIAN)
return (obj.__assign(_bb.getInt(_bb.position()) + _bb.position(), _bb))
}
fun startInParentNamespace(builder: FlatBufferBuilder) = builder.startTable(0)
fun endInParentNamespace(builder: FlatBufferBuilder) : Int {
val o = builder.endTable()
return o
}
}
}

202
tests/MyGame/MonsterExtra.kt Normal file
View File

@ -0,0 +1,202 @@
// automatically generated by the FlatBuffers compiler, do not modify
package MyGame
import java.nio.*
import kotlin.math.sign
import com.google.flatbuffers.*
@Suppress("unused")
@ExperimentalUnsignedTypes
class MonsterExtra : Table() {
fun __init(_i: Int, _bb: ByteBuffer) {
__reset(_i, _bb)
}
fun __assign(_i: Int, _bb: ByteBuffer) : MonsterExtra {
__init(_i, _bb)
return this
}
val testfNan : Float
get() {
val o = __offset(4)
return if(o != 0) bb.getFloat(o + bb_pos) else Float.NaN
}
fun mutateTestfNan(testfNan: Float) : Boolean {
val o = __offset(4)
return if (o != 0) {
bb.putFloat(o + bb_pos, testfNan)
true
} else {
false
}
}
val testfPinf : Float
get() {
val o = __offset(6)
return if(o != 0) bb.getFloat(o + bb_pos) else Float.POSITIVE_INFINITY
}
fun mutateTestfPinf(testfPinf: Float) : Boolean {
val o = __offset(6)
return if (o != 0) {
bb.putFloat(o + bb_pos, testfPinf)
true
} else {
false
}
}
val testfNinf : Float
get() {
val o = __offset(8)
return if(o != 0) bb.getFloat(o + bb_pos) else Float.NEGATIVE_INFINITY
}
fun mutateTestfNinf(testfNinf: Float) : Boolean {
val o = __offset(8)
return if (o != 0) {
bb.putFloat(o + bb_pos, testfNinf)
true
} else {
false
}
}
val testdNan : Double
get() {
val o = __offset(10)
return if(o != 0) bb.getDouble(o + bb_pos) else Double.NaN
}
fun mutateTestdNan(testdNan: Double) : Boolean {
val o = __offset(10)
return if (o != 0) {
bb.putDouble(o + bb_pos, testdNan)
true
} else {
false
}
}
val testdPinf : Double
get() {
val o = __offset(12)
return if(o != 0) bb.getDouble(o + bb_pos) else Double.POSITIVE_INFINITY
}
fun mutateTestdPinf(testdPinf: Double) : Boolean {
val o = __offset(12)
return if (o != 0) {
bb.putDouble(o + bb_pos, testdPinf)
true
} else {
false
}
}
val testdNinf : Double
get() {
val o = __offset(14)
return if(o != 0) bb.getDouble(o + bb_pos) else Double.NEGATIVE_INFINITY
}
fun mutateTestdNinf(testdNinf: Double) : Boolean {
val o = __offset(14)
return if (o != 0) {
bb.putDouble(o + bb_pos, testdNinf)
true
} else {
false
}
}
fun testfVec(j: Int) : Float {
val o = __offset(16)
return if (o != 0) {
bb.getFloat(__vector(o) + j * 4)
} else {
0.0f
}
}
val testfVecLength : Int
get() {
val o = __offset(16); return if (o != 0) __vector_len(o) else 0
}
val testfVecAsByteBuffer : ByteBuffer get() = __vector_as_bytebuffer(16, 4)
fun testfVecInByteBuffer(_bb: ByteBuffer) : ByteBuffer = __vector_in_bytebuffer(_bb, 16, 4)
fun mutateTestfVec(j: Int, testfVec: Float) : Boolean {
val o = __offset(16)
return if (o != 0) {
bb.putFloat(__vector(o) + j * 4, testfVec)
true
} else {
false
}
}
fun testdVec(j: Int) : Double {
val o = __offset(18)
return if (o != 0) {
bb.getDouble(__vector(o) + j * 8)
} else {
0.0
}
}
val testdVecLength : Int
get() {
val o = __offset(18); return if (o != 0) __vector_len(o) else 0
}
val testdVecAsByteBuffer : ByteBuffer get() = __vector_as_bytebuffer(18, 8)
fun testdVecInByteBuffer(_bb: ByteBuffer) : ByteBuffer = __vector_in_bytebuffer(_bb, 18, 8)
fun mutateTestdVec(j: Int, testdVec: Double) : Boolean {
val o = __offset(18)
return if (o != 0) {
bb.putDouble(__vector(o) + j * 8, testdVec)
true
} else {
false
}
}
companion object {
fun validateVersion() = Constants.FLATBUFFERS_1_11_1()
fun getRootAsMonsterExtra(_bb: ByteBuffer): MonsterExtra = getRootAsMonsterExtra(_bb, MonsterExtra())
fun getRootAsMonsterExtra(_bb: ByteBuffer, obj: MonsterExtra): MonsterExtra {
_bb.order(ByteOrder.LITTLE_ENDIAN)
return (obj.__assign(_bb.getInt(_bb.position()) + _bb.position(), _bb))
}
fun MonsterExtraBufferHasIdentifier(_bb: ByteBuffer) : Boolean = __has_identifier(_bb, "MONE")
fun createMonsterExtra(builder: FlatBufferBuilder, testfNan: Float, testfPinf: Float, testfNinf: Float, testdNan: Double, testdPinf: Double, testdNinf: Double, testfVecOffset: Int, testdVecOffset: Int) : Int {
builder.startTable(8)
addTestdNinf(builder, testdNinf)
addTestdPinf(builder, testdPinf)
addTestdNan(builder, testdNan)
addTestdVec(builder, testdVecOffset)
addTestfVec(builder, testfVecOffset)
addTestfNinf(builder, testfNinf)
addTestfPinf(builder, testfPinf)
addTestfNan(builder, testfNan)
return endMonsterExtra(builder)
}
fun startMonsterExtra(builder: FlatBufferBuilder) = builder.startTable(8)
fun addTestfNan(builder: FlatBufferBuilder, testfNan: Float) = builder.addFloat(0, testfNan, Double.NaN)
fun addTestfPinf(builder: FlatBufferBuilder, testfPinf: Float) = builder.addFloat(1, testfPinf, Double.POSITIVE_INFINITY)
fun addTestfNinf(builder: FlatBufferBuilder, testfNinf: Float) = builder.addFloat(2, testfNinf, Double.NEGATIVE_INFINITY)
fun addTestdNan(builder: FlatBufferBuilder, testdNan: Double) = builder.addDouble(3, testdNan, Double.NaN)
fun addTestdPinf(builder: FlatBufferBuilder, testdPinf: Double) = builder.addDouble(4, testdPinf, Double.POSITIVE_INFINITY)
fun addTestdNinf(builder: FlatBufferBuilder, testdNinf: Double) = builder.addDouble(5, testdNinf, Double.NEGATIVE_INFINITY)
fun addTestfVec(builder: FlatBufferBuilder, testfVec: Int) = builder.addOffset(6, testfVec, 0)
fun createTestfVecVector(builder: FlatBufferBuilder, data: FloatArray) : Int {
builder.startVector(4, data.size, 4)
for (i in data.size - 1 downTo 0) {
builder.addFloat(data[i])
}
return builder.endVector()
}
fun startTestfVecVector(builder: FlatBufferBuilder, numElems: Int) = builder.startVector(4, numElems, 4)
fun addTestdVec(builder: FlatBufferBuilder, testdVec: Int) = builder.addOffset(7, testdVec, 0)
fun createTestdVecVector(builder: FlatBufferBuilder, data: DoubleArray) : Int {
builder.startVector(8, data.size, 8)
for (i in data.size - 1 downTo 0) {
builder.addDouble(data[i])
}
return builder.endVector()
}
fun startTestdVecVector(builder: FlatBufferBuilder, numElems: Int) = builder.startVector(8, numElems, 8)
fun endMonsterExtra(builder: FlatBufferBuilder) : Int {
val o = builder.endTable()
return o
}
fun finishMonsterExtraBuffer(builder: FlatBufferBuilder, offset: Int) = builder.finish(offset, "MONE")
fun finishSizePrefixedMonsterExtraBuffer(builder: FlatBufferBuilder, offset: Int) = builder.finishSizePrefixed(offset, "MONE")
}
}

4
tests/TestAll.sh
View File

@ -2,6 +2,10 @@ echo "************************ Java:"
sh JavaTest.sh
echo "************************ Kotlin:"
sh KotlinTest.sh
echo "************************ Go:"
sh GoTest.sh

10
tests/generate_code.sh
View File

@ -15,16 +15,16 @@
# limitations under the License.
set -e
../flatc --cpp --java --csharp --dart --go --binary --lobster --lua --python --js --ts --php --rust --grpc --gen-mutable --reflect-names --gen-object-api --gen-compare --no-includes --cpp-ptr-type flatbuffers::unique_ptr --no-fb-import -I include_test monster_test.fbs monsterdata_test.json
../flatc --cpp --java --csharp --dart --go --binary --lobster --lua --python --js --ts --php --rust --gen-mutable --reflect-names --no-fb-import --cpp-ptr-type flatbuffers::unique_ptr -o namespace_test namespace_test/namespace_test1.fbs namespace_test/namespace_test2.fbs
../flatc --cpp --java --csharp --js --ts --php --gen-mutable --reflect-names --gen-object-api --gen-compare --cpp-ptr-type flatbuffers::unique_ptr -o union_vector ./union_vector/union_vector.fbs
../flatc --cpp --java --kotlin --csharp --dart --go --binary --lobster --lua --python --js --ts --php --rust --grpc --gen-mutable --reflect-names --gen-object-api --gen-compare --no-includes --cpp-ptr-type flatbuffers::unique_ptr --no-fb-import -I include_test monster_test.fbs monsterdata_test.json
../flatc --cpp --java --kotlin --csharp --dart --go --binary --lobster --lua --python --js --ts --php --rust --gen-mutable --reflect-names --no-fb-import --cpp-ptr-type flatbuffers::unique_ptr -o namespace_test namespace_test/namespace_test1.fbs namespace_test/namespace_test2.fbs
../flatc --cpp --java --kotlin --csharp --js --ts --php --gen-mutable --reflect-names --gen-object-api --gen-compare --cpp-ptr-type flatbuffers::unique_ptr -o union_vector ./union_vector/union_vector.fbs
../flatc -b --schema --bfbs-comments --bfbs-builtins -I include_test monster_test.fbs
../flatc -b --schema --bfbs-comments --bfbs-builtins -I include_test arrays_test.fbs
../flatc --jsonschema --schema -I include_test monster_test.fbs
../flatc --cpp --java --csharp --python --gen-mutable --reflect-names --gen-object-api --gen-compare --no-includes monster_extra.fbs monsterdata_extra.json
../flatc --cpp --java --kotlin --csharp --python --gen-mutable --reflect-names --gen-object-api --gen-compare --no-includes monster_extra.fbs monsterdata_extra.json
../flatc --cpp --java --csharp --python --gen-mutable --reflect-names --gen-object-api --gen-compare --no-includes --scoped-enums --jsonschema --cpp-ptr-type flatbuffers::unique_ptr arrays_test.fbs
cd ../samples
../flatc --cpp --lobster --gen-mutable --reflect-names --gen-object-api --gen-compare --cpp-ptr-type flatbuffers::unique_ptr monster.fbs
../flatc --cpp --kotlin --lobster --gen-mutable --reflect-names --gen-object-api --gen-compare --cpp-ptr-type flatbuffers::unique_ptr monster.fbs
../flatc -b --schema --bfbs-comments --bfbs-builtins monster.fbs
cd ../reflection
./generate_code.sh

15
tests/namespace_test/NamespaceA/NamespaceB/EnumInNestedNS.kt Normal file
View File

@ -0,0 +1,15 @@
// automatically generated by the FlatBuffers compiler, do not modify
package NamespaceA.NamespaceB
@Suppress("unused")
@ExperimentalUnsignedTypes
class EnumInNestedNS private constructor() {
companion object {
const val A: Byte = 0
const val B: Byte = 1
const val C: Byte = 2
val names : Array<String> = arrayOf("A", "B", "C")
fun name(e: Int) : String = names[e]
}
}

32
tests/namespace_test/NamespaceA/NamespaceB/StructInNestedNS.kt Normal file
View File

@ -0,0 +1,32 @@
// automatically generated by the FlatBuffers compiler, do not modify
package NamespaceA.NamespaceB
import java.nio.*
import kotlin.math.sign
import com.google.flatbuffers.*
@Suppress("unused")
@ExperimentalUnsignedTypes
class StructInNestedNS : Struct() {
fun __init(_i: Int, _bb: ByteBuffer) {
__reset(_i, _bb)
}
fun __assign(_i: Int, _bb: ByteBuffer) : StructInNestedNS {
__init(_i, _bb)
return this
}
val a : Int get() = bb.getInt(bb_pos + 0)
fun mutateA(a: Int) : ByteBuffer = bb.putInt(bb_pos + 0, a)
val b : Int get() = bb.getInt(bb_pos + 4)
fun mutateB(b: Int) : ByteBuffer = bb.putInt(bb_pos + 4, b)
companion object {
fun createStructInNestedNS(builder: FlatBufferBuilder, a: Int, b: Int) : Int {
builder.prep(4, 8)
builder.putInt(b)
builder.putInt(a)
return builder.offset()
}
}
}

53
tests/namespace_test/NamespaceA/NamespaceB/TableInNestedNS.kt Normal file
View File

@ -0,0 +1,53 @@
// automatically generated by the FlatBuffers compiler, do not modify
package NamespaceA.NamespaceB
import java.nio.*
import kotlin.math.sign
import com.google.flatbuffers.*
@Suppress("unused")
@ExperimentalUnsignedTypes
class TableInNestedNS : Table() {
fun __init(_i: Int, _bb: ByteBuffer) {
__reset(_i, _bb)
}
fun __assign(_i: Int, _bb: ByteBuffer) : TableInNestedNS {
__init(_i, _bb)
return this
}
val foo : Int
get() {
val o = __offset(4)
return if(o != 0) bb.getInt(o + bb_pos) else 0
}
fun mutateFoo(foo: Int) : Boolean {
val o = __offset(4)
return if (o != 0) {
bb.putInt(o + bb_pos, foo)
true
} else {
false
}
}
companion object {
fun validateVersion() = Constants.FLATBUFFERS_1_11_1()
fun getRootAsTableInNestedNS(_bb: ByteBuffer): TableInNestedNS = getRootAsTableInNestedNS(_bb, TableInNestedNS())
fun getRootAsTableInNestedNS(_bb: ByteBuffer, obj: TableInNestedNS): TableInNestedNS {
_bb.order(ByteOrder.LITTLE_ENDIAN)
return (obj.__assign(_bb.getInt(_bb.position()) + _bb.position(), _bb))
}
fun createTableInNestedNS(builder: FlatBufferBuilder, foo: Int) : Int {
builder.startTable(1)
addFoo(builder, foo)
return endTableInNestedNS(builder)
}
fun startTableInNestedNS(builder: FlatBufferBuilder) = builder.startTable(1)
fun addFoo(builder: FlatBufferBuilder, foo: Int) = builder.addInt(0, foo, 0)
fun endTableInNestedNS(builder: FlatBufferBuilder) : Int {
val o = builder.endTable()
return o
}
}
}

48
tests/namespace_test/NamespaceA/SecondTableInA.kt Normal file
View File

@ -0,0 +1,48 @@
// automatically generated by the FlatBuffers compiler, do not modify
package NamespaceA
import java.nio.*
import kotlin.math.sign
import com.google.flatbuffers.*
@Suppress("unused")
@ExperimentalUnsignedTypes
class SecondTableInA : Table() {
fun __init(_i: Int, _bb: ByteBuffer) {
__reset(_i, _bb)
}
fun __assign(_i: Int, _bb: ByteBuffer) : SecondTableInA {
__init(_i, _bb)
return this
}
val referToC : NamespaceC.TableInC? get() = referToC(NamespaceC.TableInC())
fun referToC(obj: NamespaceC.TableInC) : NamespaceC.TableInC? {
val o = __offset(4)
return if (o != 0) {
obj.__assign(__indirect(o + bb_pos), bb)
} else {
null
}
}
companion object {
fun validateVersion() = Constants.FLATBUFFERS_1_11_1()
fun getRootAsSecondTableInA(_bb: ByteBuffer): SecondTableInA = getRootAsSecondTableInA(_bb, SecondTableInA())
fun getRootAsSecondTableInA(_bb: ByteBuffer, obj: SecondTableInA): SecondTableInA {
_bb.order(ByteOrder.LITTLE_ENDIAN)
return (obj.__assign(_bb.getInt(_bb.position()) + _bb.position(), _bb))
}
fun createSecondTableInA(builder: FlatBufferBuilder, referToCOffset: Int) : Int {
builder.startTable(1)
addReferToC(builder, referToCOffset)
return endSecondTableInA(builder)
}
fun startSecondTableInA(builder: FlatBufferBuilder) = builder.startTable(1)
fun addReferToC(builder: FlatBufferBuilder, referToC: Int) = builder.addOffset(0, referToC, 0)
fun endSecondTableInA(builder: FlatBufferBuilder) : Int {
val o = builder.endTable()
return o
}
}
}

68
tests/namespace_test/NamespaceA/TableInFirstNS.kt Normal file
View File

@ -0,0 +1,68 @@
// automatically generated by the FlatBuffers compiler, do not modify
package NamespaceA
import java.nio.*
import kotlin.math.sign
import com.google.flatbuffers.*
@Suppress("unused")
@ExperimentalUnsignedTypes
class TableInFirstNS : Table() {
fun __init(_i: Int, _bb: ByteBuffer) {
__reset(_i, _bb)
}
fun __assign(_i: Int, _bb: ByteBuffer) : TableInFirstNS {
__init(_i, _bb)
return this
}
val fooTable : NamespaceA.NamespaceB.TableInNestedNS? get() = fooTable(NamespaceA.NamespaceB.TableInNestedNS())
fun fooTable(obj: NamespaceA.NamespaceB.TableInNestedNS) : NamespaceA.NamespaceB.TableInNestedNS? {
val o = __offset(4)
return if (o != 0) {
obj.__assign(__indirect(o + bb_pos), bb)
} else {
null
}
}
val fooEnum : Byte
get() {
val o = __offset(6)
return if(o != 0) bb.get(o + bb_pos) else 0
}
fun mutateFooEnum(fooEnum: Byte) : Boolean {
val o = __offset(6)
return if (o != 0) {
bb.put(o + bb_pos, fooEnum)
true
} else {
false
}
}
val fooStruct : NamespaceA.NamespaceB.StructInNestedNS? get() = fooStruct(NamespaceA.NamespaceB.StructInNestedNS())
fun fooStruct(obj: NamespaceA.NamespaceB.StructInNestedNS) : NamespaceA.NamespaceB.StructInNestedNS? {
val o = __offset(8)
return if (o != 0) {
obj.__assign(o + bb_pos, bb)
} else {
null
}
}
companion object {
fun validateVersion() = Constants.FLATBUFFERS_1_11_1()
fun getRootAsTableInFirstNS(_bb: ByteBuffer): TableInFirstNS = getRootAsTableInFirstNS(_bb, TableInFirstNS())
fun getRootAsTableInFirstNS(_bb: ByteBuffer, obj: TableInFirstNS): TableInFirstNS {
_bb.order(ByteOrder.LITTLE_ENDIAN)
return (obj.__assign(_bb.getInt(_bb.position()) + _bb.position(), _bb))
}
fun startTableInFirstNS(builder: FlatBufferBuilder) = builder.startTable(3)
fun addFooTable(builder: FlatBufferBuilder, fooTable: Int) = builder.addOffset(0, fooTable, 0)
fun addFooEnum(builder: FlatBufferBuilder, fooEnum: Byte) = builder.addByte(1, fooEnum, 0)
fun addFooStruct(builder: FlatBufferBuilder, fooStruct: Int) = builder.addStruct(2, fooStruct, 0)
fun endTableInFirstNS(builder: FlatBufferBuilder) : Int {
val o = builder.endTable()
return o
}
}
}

59
tests/namespace_test/NamespaceC/TableInC.kt Normal file
View File

@ -0,0 +1,59 @@
// automatically generated by the FlatBuffers compiler, do not modify
package NamespaceC
import java.nio.*
import kotlin.math.sign
import com.google.flatbuffers.*
@Suppress("unused")
@ExperimentalUnsignedTypes
class TableInC : Table() {
fun __init(_i: Int, _bb: ByteBuffer) {
__reset(_i, _bb)
}
fun __assign(_i: Int, _bb: ByteBuffer) : TableInC {
__init(_i, _bb)
return this
}
val referToA1 : NamespaceA.TableInFirstNS? get() = referToA1(NamespaceA.TableInFirstNS())
fun referToA1(obj: NamespaceA.TableInFirstNS) : NamespaceA.TableInFirstNS? {
val o = __offset(4)
return if (o != 0) {
obj.__assign(__indirect(o + bb_pos), bb)
} else {
null
}
}
val referToA2 : NamespaceA.SecondTableInA? get() = referToA2(NamespaceA.SecondTableInA())
fun referToA2(obj: NamespaceA.SecondTableInA) : NamespaceA.SecondTableInA? {
val o = __offset(6)
return if (o != 0) {
obj.__assign(__indirect(o + bb_pos), bb)
} else {
null
}
}
companion object {
fun validateVersion() = Constants.FLATBUFFERS_1_11_1()
fun getRootAsTableInC(_bb: ByteBuffer): TableInC = getRootAsTableInC(_bb, TableInC())
fun getRootAsTableInC(_bb: ByteBuffer, obj: TableInC): TableInC {
_bb.order(ByteOrder.LITTLE_ENDIAN)
return (obj.__assign(_bb.getInt(_bb.position()) + _bb.position(), _bb))
}
fun createTableInC(builder: FlatBufferBuilder, referToA1Offset: Int, referToA2Offset: Int) : Int {
builder.startTable(2)
addReferToA2(builder, referToA2Offset)
addReferToA1(builder, referToA1Offset)
return endTableInC(builder)
}
fun startTableInC(builder: FlatBufferBuilder) = builder.startTable(2)
fun addReferToA1(builder: FlatBufferBuilder, referToA1: Int) = builder.addOffset(0, referToA1, 0)
fun addReferToA2(builder: FlatBufferBuilder, referToA2: Int) = builder.addOffset(1, referToA2, 0)
fun endTableInC(builder: FlatBufferBuilder) : Int {
val o = builder.endTable()
return o
}
}
}

51
tests/union_vector/Attacker.kt Normal file
View File

@ -0,0 +1,51 @@
// automatically generated by the FlatBuffers compiler, do not modify
import java.nio.*
import kotlin.math.sign
import com.google.flatbuffers.*
@Suppress("unused")
@ExperimentalUnsignedTypes
class Attacker : Table() {
fun __init(_i: Int, _bb: ByteBuffer) {
__reset(_i, _bb)
}
fun __assign(_i: Int, _bb: ByteBuffer) : Attacker {
__init(_i, _bb)
return this
}
val swordAttackDamage : Int
get() {
val o = __offset(4)
return if(o != 0) bb.getInt(o + bb_pos) else 0
}
fun mutateSwordAttackDamage(swordAttackDamage: Int) : Boolean {
val o = __offset(4)
return if (o != 0) {
bb.putInt(o + bb_pos, swordAttackDamage)
true
} else {
false
}
}
companion object {
fun validateVersion() = Constants.FLATBUFFERS_1_11_1()
fun getRootAsAttacker(_bb: ByteBuffer): Attacker = getRootAsAttacker(_bb, Attacker())
fun getRootAsAttacker(_bb: ByteBuffer, obj: Attacker): Attacker {
_bb.order(ByteOrder.LITTLE_ENDIAN)
return (obj.__assign(_bb.getInt(_bb.position()) + _bb.position(), _bb))
}
fun createAttacker(builder: FlatBufferBuilder, swordAttackDamage: Int) : Int {
builder.startTable(1)
addSwordAttackDamage(builder, swordAttackDamage)
return endAttacker(builder)
}
fun startAttacker(builder: FlatBufferBuilder) = builder.startTable(1)
fun addSwordAttackDamage(builder: FlatBufferBuilder, swordAttackDamage: Int) = builder.addInt(0, swordAttackDamage, 0)
fun endAttacker(builder: FlatBufferBuilder) : Int {
val o = builder.endTable()
return o
}
}
}

27
tests/union_vector/BookReader.kt Normal file
View File

@ -0,0 +1,27 @@
// automatically generated by the FlatBuffers compiler, do not modify
import java.nio.*
import kotlin.math.sign
import com.google.flatbuffers.*
@Suppress("unused")
@ExperimentalUnsignedTypes
class BookReader : Struct() {
fun __init(_i: Int, _bb: ByteBuffer) {
__reset(_i, _bb)
}
fun __assign(_i: Int, _bb: ByteBuffer) : BookReader {
__init(_i, _bb)
return this
}
val booksRead : Int get() = bb.getInt(bb_pos + 0)
fun mutateBooksRead(booksRead: Int) : ByteBuffer = bb.putInt(bb_pos + 0, booksRead)
companion object {
fun createBookReader(builder: FlatBufferBuilder, booksRead: Int) : Int {
builder.prep(4, 4)
builder.putInt(booksRead)
return builder.offset()
}
}
}

17
tests/union_vector/Character.kt Normal file
View File

@ -0,0 +1,17 @@
// automatically generated by the FlatBuffers compiler, do not modify
@Suppress("unused")
@ExperimentalUnsignedTypes
class Character_ private constructor() {
companion object {
const val NONE: UByte = 0u
const val MuLan: UByte = 1u
const val Rapunzel: UByte = 2u
const val Belle: UByte = 3u
const val BookFan: UByte = 4u
const val Other: UByte = 5u
const val Unused: UByte = 6u
val names : Array<String> = arrayOf("NONE", "MuLan", "Rapunzel", "Belle", "BookFan", "Other", "Unused")
fun name(e: Int) : String = names[e]
}
}

114
tests/union_vector/Movie.kt Normal file
View File

@ -0,0 +1,114 @@
// automatically generated by the FlatBuffers compiler, do not modify
import java.nio.*
import kotlin.math.sign
import com.google.flatbuffers.*
@Suppress("unused")
@ExperimentalUnsignedTypes
class Movie : Table() {
fun __init(_i: Int, _bb: ByteBuffer) {
__reset(_i, _bb)
}
fun __assign(_i: Int, _bb: ByteBuffer) : Movie {
__init(_i, _bb)
return this
}
val mainCharacterType : UByte
get() {
val o = __offset(4)
return if(o != 0) bb.get(o + bb_pos).toUByte() else 0u
}
fun mutateMainCharacterType(mainCharacterType: UByte) : Boolean {
val o = __offset(4)
return if (o != 0) {
bb.put(o + bb_pos, mainCharacterType.toByte())
true
} else {
false
}
}
fun mainCharacter(obj: Table) : Table? {
val o = __offset(6); return if (o != 0) __union(obj, o) else null
}
fun charactersType(j: Int) : UByte {
val o = __offset(8)
return if (o != 0) {
bb.get(__vector(o) + j * 1).toUByte()
} else {
0u
}
}
val charactersTypeLength : Int
get() {
val o = __offset(8); return if (o != 0) __vector_len(o) else 0
}
val charactersTypeAsByteBuffer : ByteBuffer get() = __vector_as_bytebuffer(8, 1)
fun charactersTypeInByteBuffer(_bb: ByteBuffer) : ByteBuffer = __vector_in_bytebuffer(_bb, 8, 1)
fun mutateCharactersType(j: Int, charactersType: UByte) : Boolean {
val o = __offset(8)
return if (o != 0) {
bb.put(__vector(o) + j * 1, charactersType.toByte())
true
} else {
false
}
}
fun characters(obj: Table, j: Int) : Table? {
val o = __offset(10)
return if (o != 0) {
__union(obj, __vector(o) + j * 4 - bb_pos)
} else {
null
}
}
val charactersLength : Int
get() {
val o = __offset(10); return if (o != 0) __vector_len(o) else 0
}
companion object {
fun validateVersion() = Constants.FLATBUFFERS_1_11_1()
fun getRootAsMovie(_bb: ByteBuffer): Movie = getRootAsMovie(_bb, Movie())
fun getRootAsMovie(_bb: ByteBuffer, obj: Movie): Movie {
_bb.order(ByteOrder.LITTLE_ENDIAN)
return (obj.__assign(_bb.getInt(_bb.position()) + _bb.position(), _bb))
}
fun MovieBufferHasIdentifier(_bb: ByteBuffer) : Boolean = __has_identifier(_bb, "MOVI")
fun createMovie(builder: FlatBufferBuilder, mainCharacterType: UByte, mainCharacterOffset: Int, charactersTypeOffset: Int, charactersOffset: Int) : Int {
builder.startTable(4)
addCharacters(builder, charactersOffset)
addCharactersType(builder, charactersTypeOffset)
addMainCharacter(builder, mainCharacterOffset)
addMainCharacterType(builder, mainCharacterType)
return endMovie(builder)
}
fun startMovie(builder: FlatBufferBuilder) = builder.startTable(4)
fun addMainCharacterType(builder: FlatBufferBuilder, mainCharacterType: UByte) = builder.addByte(0, mainCharacterType.toByte(), 0)
fun addMainCharacter(builder: FlatBufferBuilder, mainCharacter: Int) = builder.addOffset(1, mainCharacter, 0)
fun addCharactersType(builder: FlatBufferBuilder, charactersType: Int) = builder.addOffset(2, charactersType, 0)
fun createCharactersTypeVector(builder: FlatBufferBuilder, data: UByteArray) : Int {
builder.startVector(1, data.size, 1)
for (i in data.size - 1 downTo 0) {
builder.addByte(data[i].toByte())
}
return builder.endVector()
}
fun startCharactersTypeVector(builder: FlatBufferBuilder, numElems: Int) = builder.startVector(1, numElems, 1)
fun addCharacters(builder: FlatBufferBuilder, characters: Int) = builder.addOffset(3, characters, 0)
fun createCharactersVector(builder: FlatBufferBuilder, data: IntArray) : Int {
builder.startVector(4, data.size, 4)
for (i in data.size - 1 downTo 0) {
builder.addOffset(data[i])
}
return builder.endVector()
}
fun startCharactersVector(builder: FlatBufferBuilder, numElems: Int) = builder.startVector(4, numElems, 4)
fun endMovie(builder: FlatBufferBuilder) : Int {
val o = builder.endTable()
return o
}
fun finishMovieBuffer(builder: FlatBufferBuilder, offset: Int) = builder.finish(offset, "MOVI")
fun finishSizePrefixedMovieBuffer(builder: FlatBufferBuilder, offset: Int) = builder.finishSizePrefixed(offset, "MOVI")
}
}

27
tests/union_vector/Rapunzel.kt Normal file
View File

@ -0,0 +1,27 @@
// automatically generated by the FlatBuffers compiler, do not modify
import java.nio.*
import kotlin.math.sign
import com.google.flatbuffers.*
@Suppress("unused")
@ExperimentalUnsignedTypes
class Rapunzel : Struct() {
fun __init(_i: Int, _bb: ByteBuffer) {
__reset(_i, _bb)
}
fun __assign(_i: Int, _bb: ByteBuffer) : Rapunzel {
__init(_i, _bb)
return this
}
val hairLength : Int get() = bb.getInt(bb_pos + 0)
fun mutateHairLength(hairLength: Int) : ByteBuffer = bb.putInt(bb_pos + 0, hairLength)
companion object {
fun createRapunzel(builder: FlatBufferBuilder, hairLength: Int) : Int {
builder.prep(4, 4)
builder.putInt(hairLength)
return builder.offset()
}
}
}