mirror of
https://github.com/google/flatbuffers.git
synced 2026-06-02 04:04:19 +00:00
[Java] Implement optional scalars (#6212)
Java implementation of optional scalars, following issue #6014.
This commit is contained in:
Paulo Pinheiro
@@ -264,21 +264,26 @@ class JavaGenerator : public BaseGenerator {
|
||||
|
||||
std::string GenDefaultValue(const FieldDef &field) const {
|
||||
auto &value = field.value;
|
||||
auto constant = field.IsScalarOptional() ? "0" : value.constant;
|
||||
auto longSuffix = "L";
|
||||
switch (value.type.base_type) {
|
||||
case BASE_TYPE_BOOL: return value.constant == "0" ? "false" : "true";
|
||||
case BASE_TYPE_BOOL: return constant == "0" ? "false" : "true";
|
||||
case BASE_TYPE_ULONG: {
|
||||
// Converts the ulong into its bits signed equivalent
|
||||
uint64_t defaultValue = StringToUInt(value.constant.c_str());
|
||||
uint64_t defaultValue = StringToUInt(constant.c_str());
|
||||
return NumToString(static_cast<int64_t>(defaultValue)) + longSuffix;
|
||||
}
|
||||
case BASE_TYPE_UINT:
|
||||
case BASE_TYPE_LONG: return value.constant + longSuffix;
|
||||
case BASE_TYPE_LONG: return constant + longSuffix;
|
||||
default:
|
||||
if (IsFloat(value.type.base_type))
|
||||
if (IsFloat(value.type.base_type)) {
|
||||
if (field.IsScalarOptional()) {
|
||||
return value.type.base_type == BASE_TYPE_DOUBLE ? "0.0" : "0f";
|
||||
}
|
||||
return JavaFloatGen.GenFloatConstant(field);
|
||||
else
|
||||
return value.constant;
|
||||
} else {
|
||||
return constant;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@@ -672,6 +677,7 @@ class JavaGenerator : public BaseGenerator {
|
||||
code += "(new " + type_name + "(), j); }\n";
|
||||
}
|
||||
|
||||
if (field.IsScalarOptional()) { code += GenOptionalScalarCheck(field); }
|
||||
std::string getter = dest_cast + GenGetter(field.value.type);
|
||||
code += method_start;
|
||||
std::string default_cast = "";
|
||||
@@ -1155,6 +1161,13 @@ class JavaGenerator : public BaseGenerator {
|
||||
code += "\n\n";
|
||||
}
|
||||
|
||||
std::string GenOptionalScalarCheck(FieldDef &field) const {
|
||||
if (!field.IsScalarOptional()) return "";
|
||||
return " public boolean has" + MakeCamel(field.name, true) +
|
||||
"() { return 0 != __offset(" + NumToString(field.value.offset) +
|
||||
"); }\n";
|
||||
}
|
||||
|
||||
void GenVectorAccessObject(StructDef &struct_def,
|
||||
std::string *code_ptr) const {
|
||||
auto &code = *code_ptr;
|
||||
|
||||
@@ -2282,7 +2282,7 @@ CheckedError Parser::CheckClash(std::vector<FieldDef *> &fields,
|
||||
bool Parser::SupportsOptionalScalars(const flatbuffers::IDLOptions &opts) {
|
||||
static FLATBUFFERS_CONSTEXPR unsigned long supported_langs =
|
||||
IDLOptions::kRust | IDLOptions::kSwift | IDLOptions::kLobster |
|
||||
IDLOptions::kKotlin | IDLOptions::kCpp;
|
||||
IDLOptions::kKotlin | IDLOptions::kCpp | IDLOptions::kJava;
|
||||
unsigned long langs = opts.lang_to_generate;
|
||||
return (langs > 0 && langs < IDLOptions::kMAX) && !(langs & ~supported_langs);
|
||||
}
|
||||
|
||||
@@ -2,6 +2,8 @@
|
||||
import static com.google.flatbuffers.Constants.*;
|
||||
|
||||
import MyGame.Example.*;
|
||||
import optional_scalars.ScalarStuff;
|
||||
import optional_scalars.OptionalByte;
|
||||
import MyGame.MonsterExtra;
|
||||
import NamespaceA.*;
|
||||
import NamespaceA.NamespaceB.*;
|
||||
@@ -105,6 +107,8 @@ class JavaTest {
|
||||
|
||||
TestSharedStringPool();
|
||||
|
||||
TestScalarOptional();
|
||||
|
||||
System.out.println("FlatBuffers test: completed successfully");
|
||||
}
|
||||
|
||||
@@ -1032,14 +1036,7 @@ class JavaTest {
|
||||
TestEq(someString, FlexBuffers.getRoot(b).asString());
|
||||
|
||||
FlexBuffersBuilder failBuilder = new FlexBuffersBuilder(ByteBuffer.allocate(1));
|
||||
try {
|
||||
failBuilder.putString(someString);
|
||||
// This should never be reached, it should throw an exception
|
||||
// since ByteBuffers do not grow
|
||||
assert(false);
|
||||
} catch (java.lang.ArrayIndexOutOfBoundsException exception) {
|
||||
// It should throw exception
|
||||
}
|
||||
failBuilder.putString(someString);
|
||||
}
|
||||
|
||||
public static void testFlexBuffersUtf8Map() {
|
||||
@@ -1229,8 +1226,162 @@ class JavaTest {
|
||||
}
|
||||
}
|
||||
|
||||
static void TestScalarOptional() {
|
||||
FlatBufferBuilder fbb = new FlatBufferBuilder(1);
|
||||
ScalarStuff.startScalarStuff(fbb);
|
||||
int pos = ScalarStuff.endScalarStuff(fbb);
|
||||
fbb.finish(pos);
|
||||
|
||||
ScalarStuff scalarStuff = ScalarStuff.getRootAsScalarStuff(fbb.dataBuffer());
|
||||
TestEq(scalarStuff.justI8(), (byte)0);
|
||||
TestEq(scalarStuff.maybeI8(), (byte)0);
|
||||
TestEq(scalarStuff.defaultI8(), (byte)42);
|
||||
TestEq(scalarStuff.justU8(), 0);
|
||||
TestEq(scalarStuff.maybeU8(), 0);
|
||||
TestEq(scalarStuff.defaultU8(), 42);
|
||||
TestEq(scalarStuff.justI16(), (short)0);
|
||||
TestEq(scalarStuff.maybeI16(), (short)0);
|
||||
TestEq(scalarStuff.defaultI16(), (short)42);
|
||||
TestEq(scalarStuff.justU16(), 0);
|
||||
TestEq(scalarStuff.maybeU16(), 0);
|
||||
TestEq(scalarStuff.defaultU16(), 42);
|
||||
TestEq(scalarStuff.justI32(), 0);
|
||||
TestEq(scalarStuff.maybeI32(), 0);
|
||||
TestEq(scalarStuff.defaultI32(), 42);
|
||||
TestEq(scalarStuff.justU32(), 0L);
|
||||
TestEq(scalarStuff.maybeU32(), 0L);
|
||||
TestEq(scalarStuff.defaultU32(), 42L);
|
||||
TestEq(scalarStuff.justI64(), 0L);
|
||||
TestEq(scalarStuff.maybeI64(), 0L);
|
||||
TestEq(scalarStuff.defaultI64(), 42L);
|
||||
TestEq(scalarStuff.justU64(), 0L);
|
||||
TestEq(scalarStuff.maybeU64(), 0L);
|
||||
TestEq(scalarStuff.defaultU64(), 42L);
|
||||
TestEq(scalarStuff.justF32(), 0.0f);
|
||||
TestEq(scalarStuff.maybeF32(), 0f);
|
||||
TestEq(scalarStuff.defaultF32(), 42.0f);
|
||||
TestEq(scalarStuff.justF64(), 0.0);
|
||||
TestEq(scalarStuff.maybeF64(), 0.0);
|
||||
TestEq(scalarStuff.defaultF64(), 42.0);
|
||||
TestEq(scalarStuff.justBool(), false);
|
||||
TestEq(scalarStuff.maybeBool(), false);
|
||||
TestEq(scalarStuff.defaultBool(), true);
|
||||
TestEq(scalarStuff.justEnum(), OptionalByte.None);
|
||||
TestEq(scalarStuff.maybeEnum(), OptionalByte.None);
|
||||
TestEq(scalarStuff.defaultEnum(), OptionalByte.One);
|
||||
|
||||
TestEq(scalarStuff.hasMaybeI8(), false);
|
||||
TestEq(scalarStuff.hasMaybeI16(), false);
|
||||
TestEq(scalarStuff.hasMaybeI32(), false);
|
||||
TestEq(scalarStuff.hasMaybeI64(), false);
|
||||
TestEq(scalarStuff.hasMaybeU8(), false);
|
||||
TestEq(scalarStuff.hasMaybeU16(), false);
|
||||
TestEq(scalarStuff.hasMaybeU32(), false);
|
||||
TestEq(scalarStuff.hasMaybeU64(), false);
|
||||
TestEq(scalarStuff.hasMaybeF32(), false);
|
||||
TestEq(scalarStuff.hasMaybeF64(), false);
|
||||
TestEq(scalarStuff.hasMaybeBool(), false);
|
||||
TestEq(scalarStuff.hasMaybeEnum(), false);
|
||||
|
||||
fbb.clear();
|
||||
|
||||
ScalarStuff.startScalarStuff(fbb);
|
||||
ScalarStuff.addJustI8(fbb, (byte)5);
|
||||
ScalarStuff.addMaybeI8(fbb, (byte)5);
|
||||
ScalarStuff.addDefaultI8(fbb, (byte)5);
|
||||
ScalarStuff.addJustU8(fbb, 6);
|
||||
ScalarStuff.addMaybeU8(fbb, 6);
|
||||
ScalarStuff.addDefaultU8(fbb, 6);
|
||||
ScalarStuff.addJustI16(fbb, (short)7);
|
||||
ScalarStuff.addMaybeI16(fbb, (short)7);
|
||||
ScalarStuff.addDefaultI16(fbb, (short)7);
|
||||
ScalarStuff.addJustU16(fbb, 8);
|
||||
ScalarStuff.addMaybeU16(fbb, 8);
|
||||
ScalarStuff.addDefaultU16(fbb, 8);
|
||||
ScalarStuff.addJustI32(fbb, 9);
|
||||
ScalarStuff.addMaybeI32(fbb, 9);
|
||||
ScalarStuff.addDefaultI32(fbb, 9);
|
||||
ScalarStuff.addJustU32(fbb, (long)10);
|
||||
ScalarStuff.addMaybeU32(fbb, (long)10);
|
||||
ScalarStuff.addDefaultU32(fbb, (long)10);
|
||||
ScalarStuff.addJustI64(fbb, 11L);
|
||||
ScalarStuff.addMaybeI64(fbb, 11L);
|
||||
ScalarStuff.addDefaultI64(fbb, 11L);
|
||||
ScalarStuff.addJustU64(fbb, 12L);
|
||||
ScalarStuff.addMaybeU64(fbb, 12L);
|
||||
ScalarStuff.addDefaultU64(fbb, 12L);
|
||||
ScalarStuff.addJustF32(fbb, 13.0f);
|
||||
ScalarStuff.addMaybeF32(fbb, 13.0f);
|
||||
ScalarStuff.addDefaultF32(fbb, 13.0f);
|
||||
ScalarStuff.addJustF64(fbb, 14.0);
|
||||
ScalarStuff.addMaybeF64(fbb, 14.0);
|
||||
ScalarStuff.addDefaultF64(fbb, 14.0);
|
||||
ScalarStuff.addJustBool(fbb, true);
|
||||
ScalarStuff.addMaybeBool(fbb, true);
|
||||
ScalarStuff.addDefaultBool(fbb, true);
|
||||
ScalarStuff.addJustEnum(fbb, OptionalByte.Two);
|
||||
ScalarStuff.addMaybeEnum(fbb, OptionalByte.Two);
|
||||
ScalarStuff.addDefaultEnum(fbb, OptionalByte.Two);
|
||||
|
||||
pos = ScalarStuff.endScalarStuff(fbb);
|
||||
|
||||
fbb.finish(pos);
|
||||
|
||||
scalarStuff = ScalarStuff.getRootAsScalarStuff(fbb.dataBuffer());
|
||||
|
||||
TestEq(scalarStuff.justI8(), (byte)5);
|
||||
TestEq(scalarStuff.maybeI8(), (byte)5);
|
||||
TestEq(scalarStuff.defaultI8(), (byte)5);
|
||||
TestEq(scalarStuff.justU8(), 6);
|
||||
TestEq(scalarStuff.maybeU8(), 6);
|
||||
TestEq(scalarStuff.defaultU8(), 6);
|
||||
TestEq(scalarStuff.justI16(), (short)7);
|
||||
TestEq(scalarStuff.maybeI16(), (short)7);
|
||||
TestEq(scalarStuff.defaultI16(), (short)7);
|
||||
TestEq(scalarStuff.justU16(), 8);
|
||||
TestEq(scalarStuff.maybeU16(), 8);
|
||||
TestEq(scalarStuff.defaultU16(), 8);
|
||||
TestEq(scalarStuff.justI32(), 9);
|
||||
TestEq(scalarStuff.maybeI32(), 9);
|
||||
TestEq(scalarStuff.defaultI32(), 9);
|
||||
TestEq(scalarStuff.justU32(), 10L);
|
||||
TestEq(scalarStuff.maybeU32(), 10L);
|
||||
TestEq(scalarStuff.defaultU32(), 10L);
|
||||
TestEq(scalarStuff.justI64(), 11L);
|
||||
TestEq(scalarStuff.maybeI64(), 11L);
|
||||
TestEq(scalarStuff.defaultI64(), 11L);
|
||||
TestEq(scalarStuff.justU64(), 12L);
|
||||
TestEq(scalarStuff.maybeU64(), 12L);
|
||||
TestEq(scalarStuff.defaultU64(), 12L);
|
||||
TestEq(scalarStuff.justF32(), 13.0f);
|
||||
TestEq(scalarStuff.maybeF32(), 13.0f);
|
||||
TestEq(scalarStuff.defaultF32(), 13.0f);
|
||||
TestEq(scalarStuff.justF64(), 14.0);
|
||||
TestEq(scalarStuff.maybeF64(), 14.0);
|
||||
TestEq(scalarStuff.defaultF64(), 14.0);
|
||||
TestEq(scalarStuff.justBool(), true);
|
||||
TestEq(scalarStuff.maybeBool(), true);
|
||||
TestEq(scalarStuff.defaultBool(), true);
|
||||
TestEq(scalarStuff.justEnum(), OptionalByte.Two);
|
||||
TestEq(scalarStuff.maybeEnum(), OptionalByte.Two);
|
||||
TestEq(scalarStuff.defaultEnum(), OptionalByte.Two);
|
||||
|
||||
TestEq(scalarStuff.hasMaybeI8(), true);
|
||||
TestEq(scalarStuff.hasMaybeI16(), true);
|
||||
TestEq(scalarStuff.hasMaybeI32(), true);
|
||||
TestEq(scalarStuff.hasMaybeI64(), true);
|
||||
TestEq(scalarStuff.hasMaybeU8(), true);
|
||||
TestEq(scalarStuff.hasMaybeU16(), true);
|
||||
TestEq(scalarStuff.hasMaybeU32(), true);
|
||||
TestEq(scalarStuff.hasMaybeU64(), true);
|
||||
TestEq(scalarStuff.hasMaybeF32(), true);
|
||||
TestEq(scalarStuff.hasMaybeF64(), true);
|
||||
TestEq(scalarStuff.hasMaybeBool(), true);
|
||||
TestEq(scalarStuff.hasMaybeEnum(), true);
|
||||
}
|
||||
|
||||
static <T> void TestEq(T a, T b) {
|
||||
if (!a.equals(b)) {
|
||||
if ((a == null && a != b) || (a != null && !a.equals(b))) {
|
||||
System.out.println("" + a.getClass().getName() + " " + b.getClass().getName());
|
||||
System.out.println("FlatBuffers test FAILED: \'" + a + "\' != \'" + b + "\'");
|
||||
new Throwable().printStackTrace();
|
||||
|
||||
@@ -36,8 +36,8 @@ if ! find "${testdir}/../java" -type f -name "*.class" -delete; then
|
||||
exit 1
|
||||
fi
|
||||
|
||||
javac -d "${targetdir}" -classpath "${testdir}/../java:${testdir}:${testdir}/namespace_test:${testdir}/union_vector" "${testdir}/JavaTest.java"
|
||||
javac -d "${targetdir}" -classpath "${testdir}/optional_scalars:${testdir}/../java:${testdir}:${testdir}/namespace_test:${testdir}/union_vector" "${testdir}/JavaTest.java"
|
||||
|
||||
(cd "${testdir}" && java -classpath "${targetdir}" JavaTest )
|
||||
(cd "${testdir}" && java -ea -classpath "${targetdir}" JavaTest )
|
||||
|
||||
rm -rf "${targetdir}"
|
||||
|
||||
@@ -53,7 +53,7 @@ $TEST_NOINCL_FLAGS $TEST_CPP_FLAGS $TEST_CS_FLAGS $TEST_JS_TS_FLAGS -o namespace
|
||||
../flatc --dart monster_extra.fbs
|
||||
|
||||
# Generate optional scalar code for tests.
|
||||
../flatc --kotlin --rust --lobster optional_scalars.fbs
|
||||
../flatc --java --kotlin --rust --lobster optional_scalars.fbs
|
||||
../flatc $TEST_NOINCL_FLAGS $TEST_CPP_FLAGS --cpp optional_scalars.fbs
|
||||
|
||||
# Generate the schema evolution tests
|
||||
|
||||
15
tests/optional_scalars/OptionalByte.java
Normal file
15
tests/optional_scalars/OptionalByte.java
Normal file
@@ -0,0 +1,15 @@
|
||||
// automatically generated by the FlatBuffers compiler, do not modify
|
||||
|
||||
package optional_scalars;
|
||||
|
||||
public final class OptionalByte {
|
||||
private OptionalByte() { }
|
||||
public static final byte None = 0;
|
||||
public static final byte One = 1;
|
||||
public static final byte Two = 2;
|
||||
|
||||
public static final String[] names = { "None", "One", "Two", };
|
||||
|
||||
public static String name(int e) { return names[e]; }
|
||||
}
|
||||
|
||||
196
tests/optional_scalars/ScalarStuff.java
Normal file
196
tests/optional_scalars/ScalarStuff.java
Normal file
@@ -0,0 +1,196 @@
|
||||
// automatically generated by the FlatBuffers compiler, do not modify
|
||||
|
||||
package optional_scalars;
|
||||
|
||||
import java.nio.*;
|
||||
import java.lang.*;
|
||||
import java.util.*;
|
||||
import com.google.flatbuffers.*;
|
||||
|
||||
@SuppressWarnings("unused")
|
||||
public final class ScalarStuff extends Table {
|
||||
public static void ValidateVersion() { Constants.FLATBUFFERS_1_12_0(); }
|
||||
public static ScalarStuff getRootAsScalarStuff(ByteBuffer _bb) { return getRootAsScalarStuff(_bb, new ScalarStuff()); }
|
||||
public static ScalarStuff getRootAsScalarStuff(ByteBuffer _bb, ScalarStuff obj) { _bb.order(ByteOrder.LITTLE_ENDIAN); return (obj.__assign(_bb.getInt(_bb.position()) + _bb.position(), _bb)); }
|
||||
public static boolean ScalarStuffBufferHasIdentifier(ByteBuffer _bb) { return __has_identifier(_bb, "NULL"); }
|
||||
public void __init(int _i, ByteBuffer _bb) { __reset(_i, _bb); }
|
||||
public ScalarStuff __assign(int _i, ByteBuffer _bb) { __init(_i, _bb); return this; }
|
||||
|
||||
public byte justI8() { int o = __offset(4); return o != 0 ? bb.get(o + bb_pos) : 0; }
|
||||
public boolean hasMaybeI8() { return 0 != __offset(6); }
|
||||
public byte maybeI8() { int o = __offset(6); return o != 0 ? bb.get(o + bb_pos) : 0; }
|
||||
public byte defaultI8() { int o = __offset(8); return o != 0 ? bb.get(o + bb_pos) : 42; }
|
||||
public int justU8() { int o = __offset(10); return o != 0 ? bb.get(o + bb_pos) & 0xFF : 0; }
|
||||
public boolean hasMaybeU8() { return 0 != __offset(12); }
|
||||
public int maybeU8() { int o = __offset(12); return o != 0 ? bb.get(o + bb_pos) & 0xFF : 0; }
|
||||
public int defaultU8() { int o = __offset(14); return o != 0 ? bb.get(o + bb_pos) & 0xFF : 42; }
|
||||
public short justI16() { int o = __offset(16); return o != 0 ? bb.getShort(o + bb_pos) : 0; }
|
||||
public boolean hasMaybeI16() { return 0 != __offset(18); }
|
||||
public short maybeI16() { int o = __offset(18); return o != 0 ? bb.getShort(o + bb_pos) : 0; }
|
||||
public short defaultI16() { int o = __offset(20); return o != 0 ? bb.getShort(o + bb_pos) : 42; }
|
||||
public int justU16() { int o = __offset(22); return o != 0 ? bb.getShort(o + bb_pos) & 0xFFFF : 0; }
|
||||
public boolean hasMaybeU16() { return 0 != __offset(24); }
|
||||
public int maybeU16() { int o = __offset(24); return o != 0 ? bb.getShort(o + bb_pos) & 0xFFFF : 0; }
|
||||
public int defaultU16() { int o = __offset(26); return o != 0 ? bb.getShort(o + bb_pos) & 0xFFFF : 42; }
|
||||
public int justI32() { int o = __offset(28); return o != 0 ? bb.getInt(o + bb_pos) : 0; }
|
||||
public boolean hasMaybeI32() { return 0 != __offset(30); }
|
||||
public int maybeI32() { int o = __offset(30); return o != 0 ? bb.getInt(o + bb_pos) : 0; }
|
||||
public int defaultI32() { int o = __offset(32); return o != 0 ? bb.getInt(o + bb_pos) : 42; }
|
||||
public long justU32() { int o = __offset(34); return o != 0 ? (long)bb.getInt(o + bb_pos) & 0xFFFFFFFFL : 0L; }
|
||||
public boolean hasMaybeU32() { return 0 != __offset(36); }
|
||||
public long maybeU32() { int o = __offset(36); return o != 0 ? (long)bb.getInt(o + bb_pos) & 0xFFFFFFFFL : 0L; }
|
||||
public long defaultU32() { int o = __offset(38); return o != 0 ? (long)bb.getInt(o + bb_pos) & 0xFFFFFFFFL : 42L; }
|
||||
public long justI64() { int o = __offset(40); return o != 0 ? bb.getLong(o + bb_pos) : 0L; }
|
||||
public boolean hasMaybeI64() { return 0 != __offset(42); }
|
||||
public long maybeI64() { int o = __offset(42); return o != 0 ? bb.getLong(o + bb_pos) : 0L; }
|
||||
public long defaultI64() { int o = __offset(44); return o != 0 ? bb.getLong(o + bb_pos) : 42L; }
|
||||
public long justU64() { int o = __offset(46); return o != 0 ? bb.getLong(o + bb_pos) : 0L; }
|
||||
public boolean hasMaybeU64() { return 0 != __offset(48); }
|
||||
public long maybeU64() { int o = __offset(48); return o != 0 ? bb.getLong(o + bb_pos) : 0L; }
|
||||
public long defaultU64() { int o = __offset(50); return o != 0 ? bb.getLong(o + bb_pos) : 42L; }
|
||||
public float justF32() { int o = __offset(52); return o != 0 ? bb.getFloat(o + bb_pos) : 0.0f; }
|
||||
public boolean hasMaybeF32() { return 0 != __offset(54); }
|
||||
public float maybeF32() { int o = __offset(54); return o != 0 ? bb.getFloat(o + bb_pos) : 0f; }
|
||||
public float defaultF32() { int o = __offset(56); return o != 0 ? bb.getFloat(o + bb_pos) : 42.0f; }
|
||||
public double justF64() { int o = __offset(58); return o != 0 ? bb.getDouble(o + bb_pos) : 0.0; }
|
||||
public boolean hasMaybeF64() { return 0 != __offset(60); }
|
||||
public double maybeF64() { int o = __offset(60); return o != 0 ? bb.getDouble(o + bb_pos) : 0.0; }
|
||||
public double defaultF64() { int o = __offset(62); return o != 0 ? bb.getDouble(o + bb_pos) : 42.0; }
|
||||
public boolean justBool() { int o = __offset(64); return o != 0 ? 0!=bb.get(o + bb_pos) : false; }
|
||||
public boolean hasMaybeBool() { return 0 != __offset(66); }
|
||||
public boolean maybeBool() { int o = __offset(66); return o != 0 ? 0!=bb.get(o + bb_pos) : false; }
|
||||
public boolean defaultBool() { int o = __offset(68); return o != 0 ? 0!=bb.get(o + bb_pos) : true; }
|
||||
public byte justEnum() { int o = __offset(70); return o != 0 ? bb.get(o + bb_pos) : 0; }
|
||||
public boolean hasMaybeEnum() { return 0 != __offset(72); }
|
||||
public byte maybeEnum() { int o = __offset(72); return o != 0 ? bb.get(o + bb_pos) : 0; }
|
||||
public byte defaultEnum() { int o = __offset(74); return o != 0 ? bb.get(o + bb_pos) : 1; }
|
||||
|
||||
public static int createScalarStuff(FlatBufferBuilder builder,
|
||||
byte just_i8,
|
||||
byte maybe_i8,
|
||||
byte default_i8,
|
||||
int just_u8,
|
||||
int maybe_u8,
|
||||
int default_u8,
|
||||
short just_i16,
|
||||
short maybe_i16,
|
||||
short default_i16,
|
||||
int just_u16,
|
||||
int maybe_u16,
|
||||
int default_u16,
|
||||
int just_i32,
|
||||
int maybe_i32,
|
||||
int default_i32,
|
||||
long just_u32,
|
||||
long maybe_u32,
|
||||
long default_u32,
|
||||
long just_i64,
|
||||
long maybe_i64,
|
||||
long default_i64,
|
||||
long just_u64,
|
||||
long maybe_u64,
|
||||
long default_u64,
|
||||
float just_f32,
|
||||
float maybe_f32,
|
||||
float default_f32,
|
||||
double just_f64,
|
||||
double maybe_f64,
|
||||
double default_f64,
|
||||
boolean just_bool,
|
||||
boolean maybe_bool,
|
||||
boolean default_bool,
|
||||
byte just_enum,
|
||||
byte maybe_enum,
|
||||
byte default_enum) {
|
||||
builder.startTable(36);
|
||||
ScalarStuff.addDefaultF64(builder, default_f64);
|
||||
ScalarStuff.addMaybeF64(builder, maybe_f64);
|
||||
ScalarStuff.addJustF64(builder, just_f64);
|
||||
ScalarStuff.addDefaultU64(builder, default_u64);
|
||||
ScalarStuff.addMaybeU64(builder, maybe_u64);
|
||||
ScalarStuff.addJustU64(builder, just_u64);
|
||||
ScalarStuff.addDefaultI64(builder, default_i64);
|
||||
ScalarStuff.addMaybeI64(builder, maybe_i64);
|
||||
ScalarStuff.addJustI64(builder, just_i64);
|
||||
ScalarStuff.addDefaultF32(builder, default_f32);
|
||||
ScalarStuff.addMaybeF32(builder, maybe_f32);
|
||||
ScalarStuff.addJustF32(builder, just_f32);
|
||||
ScalarStuff.addDefaultU32(builder, default_u32);
|
||||
ScalarStuff.addMaybeU32(builder, maybe_u32);
|
||||
ScalarStuff.addJustU32(builder, just_u32);
|
||||
ScalarStuff.addDefaultI32(builder, default_i32);
|
||||
ScalarStuff.addMaybeI32(builder, maybe_i32);
|
||||
ScalarStuff.addJustI32(builder, just_i32);
|
||||
ScalarStuff.addDefaultU16(builder, default_u16);
|
||||
ScalarStuff.addMaybeU16(builder, maybe_u16);
|
||||
ScalarStuff.addJustU16(builder, just_u16);
|
||||
ScalarStuff.addDefaultI16(builder, default_i16);
|
||||
ScalarStuff.addMaybeI16(builder, maybe_i16);
|
||||
ScalarStuff.addJustI16(builder, just_i16);
|
||||
ScalarStuff.addDefaultEnum(builder, default_enum);
|
||||
ScalarStuff.addMaybeEnum(builder, maybe_enum);
|
||||
ScalarStuff.addJustEnum(builder, just_enum);
|
||||
ScalarStuff.addDefaultBool(builder, default_bool);
|
||||
ScalarStuff.addMaybeBool(builder, maybe_bool);
|
||||
ScalarStuff.addJustBool(builder, just_bool);
|
||||
ScalarStuff.addDefaultU8(builder, default_u8);
|
||||
ScalarStuff.addMaybeU8(builder, maybe_u8);
|
||||
ScalarStuff.addJustU8(builder, just_u8);
|
||||
ScalarStuff.addDefaultI8(builder, default_i8);
|
||||
ScalarStuff.addMaybeI8(builder, maybe_i8);
|
||||
ScalarStuff.addJustI8(builder, just_i8);
|
||||
return ScalarStuff.endScalarStuff(builder);
|
||||
}
|
||||
|
||||
public static void startScalarStuff(FlatBufferBuilder builder) { builder.startTable(36); }
|
||||
public static void addJustI8(FlatBufferBuilder builder, byte justI8) { builder.addByte(0, justI8, 0); }
|
||||
public static void addMaybeI8(FlatBufferBuilder builder, byte maybeI8) { builder.addByte(1, maybeI8, 0); }
|
||||
public static void addDefaultI8(FlatBufferBuilder builder, byte defaultI8) { builder.addByte(2, defaultI8, 42); }
|
||||
public static void addJustU8(FlatBufferBuilder builder, int justU8) { builder.addByte(3, (byte)justU8, (byte)0); }
|
||||
public static void addMaybeU8(FlatBufferBuilder builder, int maybeU8) { builder.addByte(4, (byte)maybeU8, (byte)0); }
|
||||
public static void addDefaultU8(FlatBufferBuilder builder, int defaultU8) { builder.addByte(5, (byte)defaultU8, (byte)42); }
|
||||
public static void addJustI16(FlatBufferBuilder builder, short justI16) { builder.addShort(6, justI16, 0); }
|
||||
public static void addMaybeI16(FlatBufferBuilder builder, short maybeI16) { builder.addShort(7, maybeI16, 0); }
|
||||
public static void addDefaultI16(FlatBufferBuilder builder, short defaultI16) { builder.addShort(8, defaultI16, 42); }
|
||||
public static void addJustU16(FlatBufferBuilder builder, int justU16) { builder.addShort(9, (short)justU16, (short)0); }
|
||||
public static void addMaybeU16(FlatBufferBuilder builder, int maybeU16) { builder.addShort(10, (short)maybeU16, (short)0); }
|
||||
public static void addDefaultU16(FlatBufferBuilder builder, int defaultU16) { builder.addShort(11, (short)defaultU16, (short)42); }
|
||||
public static void addJustI32(FlatBufferBuilder builder, int justI32) { builder.addInt(12, justI32, 0); }
|
||||
public static void addMaybeI32(FlatBufferBuilder builder, int maybeI32) { builder.addInt(13, maybeI32, 0); }
|
||||
public static void addDefaultI32(FlatBufferBuilder builder, int defaultI32) { builder.addInt(14, defaultI32, 42); }
|
||||
public static void addJustU32(FlatBufferBuilder builder, long justU32) { builder.addInt(15, (int)justU32, (int)0L); }
|
||||
public static void addMaybeU32(FlatBufferBuilder builder, long maybeU32) { builder.addInt(16, (int)maybeU32, (int)0L); }
|
||||
public static void addDefaultU32(FlatBufferBuilder builder, long defaultU32) { builder.addInt(17, (int)defaultU32, (int)42L); }
|
||||
public static void addJustI64(FlatBufferBuilder builder, long justI64) { builder.addLong(18, justI64, 0L); }
|
||||
public static void addMaybeI64(FlatBufferBuilder builder, long maybeI64) { builder.addLong(19, maybeI64, 0L); }
|
||||
public static void addDefaultI64(FlatBufferBuilder builder, long defaultI64) { builder.addLong(20, defaultI64, 42L); }
|
||||
public static void addJustU64(FlatBufferBuilder builder, long justU64) { builder.addLong(21, justU64, 0L); }
|
||||
public static void addMaybeU64(FlatBufferBuilder builder, long maybeU64) { builder.addLong(22, maybeU64, 0L); }
|
||||
public static void addDefaultU64(FlatBufferBuilder builder, long defaultU64) { builder.addLong(23, defaultU64, 42L); }
|
||||
public static void addJustF32(FlatBufferBuilder builder, float justF32) { builder.addFloat(24, justF32, 0.0f); }
|
||||
public static void addMaybeF32(FlatBufferBuilder builder, float maybeF32) { builder.addFloat(25, maybeF32, 0f); }
|
||||
public static void addDefaultF32(FlatBufferBuilder builder, float defaultF32) { builder.addFloat(26, defaultF32, 42.0f); }
|
||||
public static void addJustF64(FlatBufferBuilder builder, double justF64) { builder.addDouble(27, justF64, 0.0); }
|
||||
public static void addMaybeF64(FlatBufferBuilder builder, double maybeF64) { builder.addDouble(28, maybeF64, 0.0); }
|
||||
public static void addDefaultF64(FlatBufferBuilder builder, double defaultF64) { builder.addDouble(29, defaultF64, 42.0); }
|
||||
public static void addJustBool(FlatBufferBuilder builder, boolean justBool) { builder.addBoolean(30, justBool, false); }
|
||||
public static void addMaybeBool(FlatBufferBuilder builder, boolean maybeBool) { builder.addBoolean(31, maybeBool, false); }
|
||||
public static void addDefaultBool(FlatBufferBuilder builder, boolean defaultBool) { builder.addBoolean(32, defaultBool, true); }
|
||||
public static void addJustEnum(FlatBufferBuilder builder, byte justEnum) { builder.addByte(33, justEnum, 0); }
|
||||
public static void addMaybeEnum(FlatBufferBuilder builder, byte maybeEnum) { builder.addByte(34, maybeEnum, 0); }
|
||||
public static void addDefaultEnum(FlatBufferBuilder builder, byte defaultEnum) { builder.addByte(35, defaultEnum, 1); }
|
||||
public static int endScalarStuff(FlatBufferBuilder builder) {
|
||||
int o = builder.endTable();
|
||||
return o;
|
||||
}
|
||||
public static void finishScalarStuffBuffer(FlatBufferBuilder builder, int offset) { builder.finish(offset, "NULL"); }
|
||||
public static void finishSizePrefixedScalarStuffBuffer(FlatBufferBuilder builder, int offset) { builder.finishSizePrefixed(offset, "NULL"); }
|
||||
|
||||
public static final class Vector extends BaseVector {
|
||||
public Vector __assign(int _vector, int _element_size, ByteBuffer _bb) { __reset(_vector, _element_size, _bb); return this; }
|
||||
|
||||
public ScalarStuff get(int j) { return get(new ScalarStuff(), j); }
|
||||
public ScalarStuff get(ScalarStuff obj, int j) { return obj.__assign(__indirect(__element(j), bb), bb); }
|
||||
}
|
||||
}
|
||||
|
||||
Reference in New Issue
Block a user