integral type of the enum with `:` (in this case `byte`), which then determines
the type of any fields declared with this enum type.
+Only integer types are allowed, i.e. `byte`, `ubyte`, `short` `ushort`, `int`,
+`uint`, `long` and `ulong`.
+
Typically, enum values should only ever be added, never removed (there is no
deprecation for enums). This requires code to handle forwards compatibility
itself, by handling unknown enum values.
Unions share a lot of properties with enums, but instead of new names
for constants, you use names of tables. You can then declare
a union field, which can hold a reference to any of those types, and
-additionally a hidden field with the suffix `_type` is generated that
-holds the corresponding enum value, allowing you to know which type to
-cast to at runtime.
+additionally a field with the suffix `_type` is generated that holds
+the corresponding enum value, allowing you to know which type to cast
+to at runtime.
+
+It's possible to give an alias name to a type union. This way a type can even be
+used to mean different things depending on the name used:
+
+ table PointPosition { x:uint; y:uint; }
+ table MarkerPosition {}
+ union Position {
+ Start:MarkerPosition,
+ Point:PointPosition,
+ Finish:MarkerPosition
+ }
+
+Unions contain a special `NONE` marker to denote that no value is stored so that
+name cannot be used as an alias.
Unions are a good way to be able to send multiple message types as a FlatBuffer.
Note that because a union field is really two fields, it must always be
}
// Specify the integer type underlying this enum.
ECHECK(ParseType(enum_def->underlying_type));
- if (!IsInteger(enum_def->underlying_type.base_type))
+ if (!IsInteger(enum_def->underlying_type.base_type) ||
+ IsBool(enum_def->underlying_type.base_type))
return Error("underlying enum type must be integral");
// Make this type refer back to the enum it was derived from.
enum_def->underlying_type.enum_def = enum_def;
}
}
auto prevsize = enum_def->vals.vec.size();
- auto value = !enum_def->vals.vec.empty()
- ? enum_def->vals.vec.back()->value + 1
- : 0;
- auto &ev = *new EnumVal(value_name, value);
+ auto prevvalue = prevsize > 0 ? enum_def->vals.vec.back()->value : 0;
+ auto &ev = *new EnumVal(value_name, 0);
if (enum_def->vals.Add(value_name, &ev))
return Error("enum value already exists: " + value_name);
ev.doc_comment = value_comment;
if (!opts.proto_mode && prevsize &&
enum_def->vals.vec[prevsize - 1]->value >= ev.value)
return Error("enum values must be specified in ascending order");
+ } else if (prevsize == 0) {
+ // already set to zero
+ } else if (prevvalue != flatbuffers::numeric_limits<int64_t>::max()) {
+ ev.value = prevvalue + 1;
+ } else {
+ return Error("enum value overflows");
}
- if (is_union) {
- if (ev.value < 0 || ev.value >= 256)
- return Error("union enum value must fit in a ubyte");
+
+ // Check that value fits into the underlying type.
+ switch (enum_def->underlying_type.base_type) {
+ // clang-format off
+ #define FLATBUFFERS_TD(ENUM, IDLTYPE, CTYPE, JTYPE, GTYPE, NTYPE, \
+ PTYPE, RTYPE) \
+ case BASE_TYPE_##ENUM: { \
+ int64_t min_value = static_cast<int64_t>( \
+ flatbuffers::numeric_limits<CTYPE>::lowest()); \
+ int64_t max_value = static_cast<int64_t>( \
+ flatbuffers::numeric_limits<CTYPE>::max()); \
+ if (ev.value < min_value || ev.value > max_value) { \
+ return Error( \
+ "enum value does not fit [" + NumToString(min_value) + \
+ "; " + NumToString(max_value) + "]"); \
+ } \
+ break; \
+ }
+ FLATBUFFERS_GEN_TYPES_SCALAR(FLATBUFFERS_TD);
+ #undef FLATBUFFERS_TD
+ default: break;
+ // clang-format on
}
+
if (opts.proto_mode && Is('[')) {
NEXT();
// ignore attributes on enums.
TestError("enum X:float {}", "underlying");
TestError("enum X:byte { Y, Y }", "value already");
TestError("enum X:byte { Y=2, Z=1 }", "ascending");
- TestError("union X { Y = 256 }", "must fit");
TestError("enum X:byte (bit_flags) { Y=8 }", "bit flag out");
TestError("table X { Y:int; } table X {", "datatype already");
TestError("struct X (force_align: 7) { Y:int; }", "force_align");
// float to integer conversion is forbidden
TestError("table X { Y:int; } root_type X; { Y:1.0 }", "float");
TestError("table X { Y:bool; } root_type X; { Y:1.0 }", "float");
+ TestError("enum X:bool { Y = true }", "must be integral");
}
template<typename T> T TestValue(const char *json, const char *type_name) {
TEST_EQ_STR("", EnumNameColor(static_cast<Color>(1000)));
}
+void EnumOutOfRangeTest() {
+ TestError("enum X:byte { Y = 128 }", "enum value does not fit");
+ TestError("enum X:byte { Y = -129 }", "enum value does not fit");
+ TestError("enum X:byte { Y = 127, Z }", "enum value does not fit");
+ TestError("enum X:ubyte { Y = -1 }", "enum value does not fit");
+ TestError("enum X:ubyte { Y = 256 }", "enum value does not fit");
+ // Unions begin with an implicit "NONE = 0".
+ TestError("table Y{} union X { Y = -1 }",
+ "enum values must be specified in ascending order");
+ TestError("table Y{} union X { Y = 256 }", "enum value does not fit");
+ TestError("table Y{} union X { Y = 255, Z:Y }", "enum value does not fit");
+ TestError("enum X:int { Y = -2147483649 }", "enum value does not fit");
+ TestError("enum X:int { Y = 2147483648 }", "enum value does not fit");
+ TestError("enum X:uint { Y = -1 }", "enum value does not fit");
+ TestError("enum X:uint { Y = 4294967297 }", "enum value does not fit");
+ TestError("enum X:long { Y = 9223372036854775808 }", "constant does not fit");
+ TestError("enum X:long { Y = 9223372036854775807, Z }", "enum value overflows");
+ TestError("enum X:ulong { Y = -1 }", "enum value does not fit");
+ // TODO: these are perfectly valid constants that shouldn't fail
+ TestError("enum X:ulong { Y = 13835058055282163712 }", "constant does not fit");
+ TestError("enum X:ulong { Y = 18446744073709551615 }", "constant does not fit");
+}
+
void IntegerOutOfRangeTest() {
TestError("table T { F:byte; } root_type T; { F:128 }",
"constant does not fit");
ValueTest();
EnumStringsTest();
EnumNamesTest();
+ EnumOutOfRangeTest();
IntegerOutOfRangeTest();
IntegerBoundaryTest();
UnicodeTest();