Note: currently not guaranteed to have an effect when used with
`--object-api`, since that may allocate objects at alignments less than
what you specify with `force_align`.
-- `bit_flags` (on an enum): the values of this field indicate bits,
- meaning that any value N specified in the schema will end up
+- `bit_flags` (on an unsigned enum): the values of this field indicate bits,
+ meaning that any unsigned value N specified in the schema will end up
representing 1<<N, or if you don't specify values at all, you'll get
the sequence 1, 2, 4, 8, ...
- `nested_flatbuffer: "table_name"` (on a field): this indicates that the field
Offset<reflection::EnumVal> Serialize(FlatBufferBuilder *builder, const Parser &parser) const;
bool Deserialize(const Parser &parser, const reflection::EnumVal *val);
+ bool IsZero() const { return 0 == value; }
+ bool IsNonZero() const { return !IsZero(); }
std::string name;
std::vector<std::string> doc_comment;
EnumDef() : is_union(false), uses_multiple_type_instances(false) {}
EnumVal *ReverseLookup(int64_t enum_idx, bool skip_union_default = true) {
- for (auto it = vals.vec.begin() +
+ for (auto it = Vals().begin() +
static_cast<int>(is_union && skip_union_default);
- it != vals.vec.end(); ++it) {
+ it != Vals().end(); ++it) {
if ((*it)->value == enum_idx) { return *it; }
}
return nullptr;
bool Deserialize(Parser &parser, const reflection::Enum *values);
+ size_t size() const { return vals.vec.size(); }
+
+ const std::vector<EnumVal *> &Vals() const {
+ return vals.vec;
+ }
+
SymbolTable<EnumVal> vals;
bool is_union;
// Type is a union which uses type aliases where at least one type is
bool ParseFlexBuffer(const char *source, const char *source_filename,
flexbuffers::Builder *builder);
- FLATBUFFERS_CHECKED_ERROR InvalidNumber(const char *number,
- const std::string &msg);
-
StructDef *LookupStruct(const std::string &id) const;
std::string UnqualifiedName(std::string fullQualifiedName);
+ FLATBUFFERS_CHECKED_ERROR Error(const std::string &msg);
+
private:
void Message(const std::string &msg);
void Warning(const std::string &msg);
- FLATBUFFERS_CHECKED_ERROR Error(const std::string &msg);
FLATBUFFERS_CHECKED_ERROR ParseHexNum(int nibbles, uint64_t *val);
FLATBUFFERS_CHECKED_ERROR Next();
FLATBUFFERS_CHECKED_ERROR SkipByteOrderMark();
FLATBUFFERS_CHECKED_ERROR ParseHash(Value &e, FieldDef* field);
FLATBUFFERS_CHECKED_ERROR TokenError();
FLATBUFFERS_CHECKED_ERROR ParseSingleValue(const std::string *name, Value &e, bool check_now);
- FLATBUFFERS_CHECKED_ERROR ParseEnumFromString(Type &type, int64_t *result);
+ FLATBUFFERS_CHECKED_ERROR ParseEnumFromString(const Type &type, std::string *result);
StructDef *LookupCreateStruct(const std::string &name,
bool create_if_new = true,
bool definition = false);
struct_def ? (struct_def->fixed ? "ST_STRUCT" : "ST_TABLE")
: (enum_def->is_union ? "ST_UNION" : "ST_ENUM"));
auto num_fields =
- struct_def ? struct_def->fields.vec.size() : enum_def->vals.vec.size();
+ struct_def ? struct_def->fields.vec.size() : enum_def->size();
code_.SetValue("NUM_FIELDS", NumToString(num_fields));
std::vector<std::string> names;
std::vector<Type> types;
types.push_back(field.value.type);
}
} else {
- for (auto it = enum_def->vals.vec.begin(); it != enum_def->vals.vec.end();
+ for (auto it = enum_def->Vals().begin(); it != enum_def->Vals().end();
++it) {
const auto &ev = **it;
names.push_back(Name(ev));
types.push_back(enum_def->is_union ? ev.union_type
: Type(enum_def->underlying_type));
- if (static_cast<int64_t>(it - enum_def->vals.vec.begin()) != ev.value) {
+ if (static_cast<int64_t>(it - enum_def->Vals().begin()) != ev.value) {
consecutive_enum_from_zero = false;
}
}
}
std::string vs;
if (enum_def && !consecutive_enum_from_zero) {
- for (auto it = enum_def->vals.vec.begin(); it != enum_def->vals.vec.end();
+ for (auto it = enum_def->Vals().begin(); it != enum_def->Vals().end();
++it) {
const auto &ev = **it;
if (!vs.empty()) vs += ", ";
int64_t anyv = 0;
const EnumVal *minv = nullptr, *maxv = nullptr;
- for (auto it = enum_def.vals.vec.begin(); it != enum_def.vals.vec.end();
- ++it) {
+ for (auto it = enum_def.Vals().begin(); it != enum_def.Vals().end(); ++it) {
const auto &ev = **it;
GenComment(ev.doc_comment, " ");
code_ += "";
// Generate an array of all enumeration values
- auto num_fields = NumToString(enum_def.vals.vec.size());
+ auto num_fields = NumToString(enum_def.size());
code_ += "inline const {{ENUM_NAME}} (&EnumValues{{ENUM_NAME}}())[" +
num_fields + "] {";
code_ += " static const {{ENUM_NAME}} values[] = {";
- for (auto it = enum_def.vals.vec.begin(); it != enum_def.vals.vec.end();
- ++it) {
+ for (auto it = enum_def.Vals().begin(); it != enum_def.Vals().end(); ++it) {
const auto &ev = **it;
auto value = GetEnumValUse(enum_def, ev);
- auto suffix = *it != enum_def.vals.vec.back() ? "," : "";
+ auto suffix = *it != enum_def.Vals().back() ? "," : "";
code_ += " " + value + suffix;
}
code_ += " };";
code_ += "inline const char * const *EnumNames{{ENUM_NAME}}() {";
code_ += " static const char * const names[] = {";
- auto val = enum_def.vals.vec.front()->value;
- for (auto it = enum_def.vals.vec.begin(); it != enum_def.vals.vec.end();
+ auto val = enum_def.Vals().front()->value;
+ for (auto it = enum_def.Vals().begin(); it != enum_def.Vals().end();
++it) {
const auto &ev = **it;
while (val++ != ev.value) { code_ += " \"\","; }
code_ += " switch (e) {";
- for (auto it = enum_def.vals.vec.begin(); it != enum_def.vals.vec.end();
+ for (auto it = enum_def.Vals().begin(); it != enum_def.Vals().end();
++it) {
const auto &ev = **it;
code_ += " case " + GetEnumValUse(enum_def, ev) + ": return \"" +
// Generate type traits for unions to map from a type to union enum value.
if (enum_def.is_union && !enum_def.uses_multiple_type_instances) {
- for (auto it = enum_def.vals.vec.begin(); it != enum_def.vals.vec.end();
+ for (auto it = enum_def.Vals().begin(); it != enum_def.Vals().end();
++it) {
const auto &ev = **it;
- if (it == enum_def.vals.vec.begin()) {
+ if (it == enum_def.Vals().begin()) {
code_ += "template<typename T> struct {{ENUM_NAME}}Traits {";
} else {
auto name = GetUnionElement(ev, true, true);
code_ += " " + UnionPackSignature(enum_def, true) + ";";
code_ += "";
- for (auto it = enum_def.vals.vec.begin(); it != enum_def.vals.vec.end();
+ for (auto it = enum_def.Vals().begin(); it != enum_def.Vals().end();
++it) {
const auto &ev = **it;
- if (!ev.value) { continue; }
+ if (ev.IsZero()) { continue; }
const auto native_type =
NativeName(GetUnionElement(ev, true, true, true),
code_ += " if (lhs.type != rhs.type) return false;";
code_ += " switch (lhs.type) {";
- for (auto it = enum_def.vals.vec.begin(); it != enum_def.vals.vec.end();
+ for (auto it = enum_def.Vals().begin(); it != enum_def.Vals().end();
++it) {
const auto &ev = **it;
code_.SetValue("NATIVE_ID", GetEnumValUse(enum_def, ev));
- if (ev.value) {
+ if (ev.IsNonZero()) {
const auto native_type =
NativeName(GetUnionElement(ev, true, true, true),
ev.union_type.struct_def, parser_.opts);
code_ += "inline " + UnionVerifySignature(enum_def) + " {";
code_ += " switch (type) {";
- for (auto it = enum_def.vals.vec.begin(); it != enum_def.vals.vec.end();
- ++it) {
+ for (auto it = enum_def.Vals().begin(); it != enum_def.Vals().end(); ++it) {
const auto &ev = **it;
code_.SetValue("LABEL", GetEnumValUse(enum_def, ev));
- if (ev.value) {
+ if (ev.IsNonZero()) {
code_.SetValue("TYPE", GetUnionElement(ev, true, true));
code_ += " case {{LABEL}}: {";
auto getptr =
// Generate union Unpack() and Pack() functions.
code_ += "inline " + UnionUnPackSignature(enum_def, false) + " {";
code_ += " switch (type) {";
- for (auto it = enum_def.vals.vec.begin(); it != enum_def.vals.vec.end();
+ for (auto it = enum_def.Vals().begin(); it != enum_def.Vals().end();
++it) {
const auto &ev = **it;
- if (!ev.value) { continue; }
+ if (ev.IsZero()) { continue; }
code_.SetValue("LABEL", GetEnumValUse(enum_def, ev));
code_.SetValue("TYPE", GetUnionElement(ev, true, true));
code_ += "inline " + UnionPackSignature(enum_def, false) + " {";
code_ += " switch (type) {";
- for (auto it = enum_def.vals.vec.begin(); it != enum_def.vals.vec.end();
+ for (auto it = enum_def.Vals().begin(); it != enum_def.Vals().end();
++it) {
auto &ev = **it;
- if (!ev.value) { continue; }
+ if (ev.IsZero()) { continue; }
code_.SetValue("LABEL", GetEnumValUse(enum_def, ev));
code_.SetValue("TYPE",
"{{ENUM_NAME}}Union &u) FLATBUFFERS_NOEXCEPT : type(u.type), "
"value(nullptr) {";
code_ += " switch (type) {";
- for (auto it = enum_def.vals.vec.begin(); it != enum_def.vals.vec.end();
+ for (auto it = enum_def.Vals().begin(); it != enum_def.Vals().end();
++it) {
const auto &ev = **it;
- if (!ev.value) { continue; }
+ if (ev.IsZero()) { continue; }
code_.SetValue("LABEL", GetEnumValUse(enum_def, ev));
code_.SetValue("TYPE",
NativeName(GetUnionElement(ev, true, true, true),
code_ += "inline void {{ENUM_NAME}}Union::Reset() {";
code_ += " switch (type) {";
- for (auto it = enum_def.vals.vec.begin(); it != enum_def.vals.vec.end();
+ for (auto it = enum_def.Vals().begin(); it != enum_def.Vals().end();
++it) {
const auto &ev = **it;
- if (!ev.value) { continue; }
+ if (ev.IsZero()) { continue; }
code_.SetValue("LABEL", GetEnumValUse(enum_def, ev));
code_.SetValue("TYPE",
NativeName(GetUnionElement(ev, true, true, true),
" template<typename T> "
"const T *{{NULLABLE_EXT}}{{FIELD_NAME}}_as() const;";
- for (auto u_it = u->vals.vec.begin(); u_it != u->vals.vec.end();
- ++u_it) {
+ for (auto u_it = u->Vals().begin(); u_it != u->Vals().end(); ++u_it) {
auto &ev = **u_it;
if (ev.union_type.base_type == BASE_TYPE_NONE) { continue; }
auto full_struct_name = GetUnionElement(ev, true, true);
code_.SetValue("FIELD_NAME", Name(field));
- for (auto u_it = u->vals.vec.begin(); u_it != u->vals.vec.end(); ++u_it) {
+ for (auto u_it = u->Vals().begin(); u_it != u->Vals().end(); ++u_it) {
auto &ev = **u_it;
if (ev.union_type.base_type == BASE_TYPE_NONE) { continue; }
" static bool containsValue(int value) =>"
" values.containsKey(value);\n\n";
- for (auto it = enum_def.vals.vec.begin(); it != enum_def.vals.vec.end();
- ++it) {
+ for (auto it = enum_def.Vals().begin(); it != enum_def.Vals().end(); ++it) {
auto &ev = **it;
if (!ev.doc_comment.empty()) {
- if (it != enum_def.vals.vec.begin()) { code += '\n'; }
+ if (it != enum_def.Vals().begin()) { code += '\n'; }
GenDocComment(ev.doc_comment, &code, "", " ");
}
code += " static const " + name + " " + ev.name + " = ";
}
code += " static get values => {";
- for (auto it = enum_def.vals.vec.begin(); it != enum_def.vals.vec.end();
- ++it) {
+ for (auto it = enum_def.Vals().begin(); it != enum_def.Vals().end(); ++it) {
auto &ev = **it;
code += NumToString(ev.value) + ": " + ev.name + ",";
}
if (field.value.type.base_type == BASE_TYPE_UNION) {
code += " {\n";
code += " switch (" + field_name + "Type?.value) {\n";
- for (auto en_it = field.value.type.enum_def->vals.vec.begin() + 1;
- en_it != field.value.type.enum_def->vals.vec.end(); ++en_it) {
+ auto &enum_def = *field.value.type.enum_def;
+ for (auto en_it = enum_def.Vals().begin() + 1;
+ en_it != enum_def.Vals().end(); ++en_it) {
auto &ev = **en_it;
auto enum_name = NamespaceAliasFromUnionType(ev.name);
else
schema += "enum " + enum_def.name + " : ";
schema += GenType(enum_def.underlying_type, true) + " {\n";
- for (auto it = enum_def.vals.vec.begin(); it != enum_def.vals.vec.end();
- ++it) {
+ for (auto it = enum_def.Vals().begin(); it != enum_def.Vals().end(); ++it) {
auto &ev = **it;
GenComment(ev.doc_comment, &schema, nullptr, " ");
if (enum_def.is_union)
if (lang_.language == IDLOptions::kJava) {
code += " private " + enum_def.name + "() { }\n";
}
- for (auto it = enum_def.vals.vec.begin(); it != enum_def.vals.vec.end();
- ++it) {
+ for (auto it = enum_def.Vals().begin(); it != enum_def.Vals().end(); ++it) {
auto &ev = **it;
GenComment(ev.doc_comment, code_ptr, &lang_.comment_config, " ");
if (lang_.language != IDLOptions::kCSharp) {
code += lang_.const_decl;
code += lang_.string_type;
code += "[] names = { ";
- auto val = enum_def.vals.vec.front()->value;
- for (auto it = enum_def.vals.vec.begin(); it != enum_def.vals.vec.end();
+ auto val = enum_def.Vals().front()->value;
+ for (auto it = enum_def.Vals().begin(); it != enum_def.Vals().end();
++it) {
while (val++ != (*it)->value) code += "\"\", ";
code += "\"" + (*it)->name + "\", ";
}
// A single enum member.
- void EnumMember(const EnumDef &enum_def, const EnumVal ev,
+ void EnumMember(const EnumDef &enum_def, const EnumVal &ev,
std::string *code_ptr) {
std::string &code = *code_ptr;
code += "\t";
GenComment(enum_def.doc_comment, code_ptr, nullptr);
GenEnumType(enum_def, code_ptr);
BeginEnum(code_ptr);
- for (auto it = enum_def.vals.vec.begin(); it != enum_def.vals.vec.end();
- ++it) {
+ for (auto it = enum_def.Vals().begin(); it != enum_def.Vals().end(); ++it) {
auto &ev = **it;
GenComment(ev.doc_comment, code_ptr, nullptr, "\t");
EnumMember(enum_def, ev, code_ptr);
EndEnum(code_ptr);
BeginEnumNames(enum_def, code_ptr);
- for (auto it = enum_def.vals.vec.begin(); it != enum_def.vals.vec.end();
- ++it) {
+ for (auto it = enum_def.Vals().begin(); it != enum_def.Vals().end(); ++it) {
auto &ev = **it;
EnumNameMember(enum_def, ev, code_ptr);
}
}
code += WrapInNameSpace(enum_def) + (reverse ? "Name" : "") + " = {\n";
}
- for (auto it = enum_def.vals.vec.begin(); it != enum_def.vals.vec.end();
- ++it) {
+ for (auto it = enum_def.Vals().begin(); it != enum_def.Vals().end(); ++it) {
auto &ev = **it;
if (!ev.doc_comment.empty()) {
- if (it != enum_def.vals.vec.begin()) { code += '\n'; }
+ if (it != enum_def.Vals().begin()) { code += '\n'; }
GenDocComment(ev.doc_comment, code_ptr, "", " ");
}
code += NumToString(ev.value);
}
- code += (it + 1) != enum_def.vals.vec.end() ? ",\n" : "\n";
+ code += (it + 1) != enum_def.Vals().end() ? ",\n" : "\n";
if (ev.union_type.struct_def) {
ReexportDescription desc = { ev.name,
}
case BASE_TYPE_UNION: {
std::string union_type_string("\"anyOf\": [");
- const auto &union_types = type.enum_def->vals.vec;
+ const auto &union_types = type.enum_def->Vals();
for (auto ut = union_types.cbegin(); ut < union_types.cend(); ++ut) {
auto &union_type = *ut;
if (union_type->union_type.base_type == BASE_TYPE_NONE) { continue; }
union_type_string.append(
"{ " + GenTypeRef(union_type->union_type.struct_def) + " }");
}
- if (union_type != *type.enum_def->vals.vec.rbegin()) {
+ if (union_type != *type.enum_def->Vals().rbegin()) {
union_type_string.append(",");
}
}
code_ += " \"" + GenFullName(*e) + "\" : {";
code_ += " " + GenType("string") + ",";
std::string enumdef(" \"enum\": [");
- for (auto enum_value = (*e)->vals.vec.begin();
- enum_value != (*e)->vals.vec.end(); ++enum_value) {
+ for (auto enum_value = (*e)->Vals().begin();
+ enum_value != (*e)->Vals().end(); ++enum_value) {
enumdef.append("\"" + (*enum_value)->name + "\"");
- if (*enum_value != (*e)->vals.vec.back()) { enumdef.append(", "); }
+ if (*enum_value != (*e)->Vals().back()) { enumdef.append(", "); }
}
enumdef.append("]");
code_ += enumdef;
break;
}
case BASE_TYPE_UNION: {
- for (auto it = field.value.type.enum_def->vals.vec.begin();
- it != field.value.type.enum_def->vals.vec.end(); ++it) {
+ for (auto it = field.value.type.enum_def->Vals().begin();
+ it != field.value.type.enum_def->Vals().end(); ++it) {
auto &ev = **it;
- if (ev.value) {
+ if (ev.IsNonZero()) {
code += def + "_as_" + ev.name + "():\n " +
NamespacedName(*ev.union_type.struct_def) +
" { buf_, buf_.flatbuffers_field_table(pos_, " + offsets +
CheckNameSpace(enum_def, &code);
GenComment(enum_def.doc_comment, code_ptr, nullptr, "");
code += "enum + \n";
- for (auto it = enum_def.vals.vec.begin(); it != enum_def.vals.vec.end();
- ++it) {
+ for (auto it = enum_def.Vals().begin(); it != enum_def.Vals().end(); ++it) {
auto &ev = **it;
GenComment(ev.doc_comment, code_ptr, nullptr, " ");
code += " " + enum_def.name + "_" + NormalizedName(ev) + " = " +
NumToString(ev.value);
- if (it + 1 != enum_def.vals.vec.end()) code += ",";
+ if (it + 1 != enum_def.Vals().end()) code += ",";
code += "\n";
}
code += "\n";
}
// A single enum member.
- void EnumMember(const EnumVal ev, std::string *code_ptr) {
+ void EnumMember(const EnumDef &enum_def, const EnumVal &ev, std::string *code_ptr) {
std::string &code = *code_ptr;
code += std::string(Indent) + NormalizedName(ev) + " = " + NumToString(ev.value) + ",\n";
+ (void)enum_def;
}
// End enum code.
}
code += EndFunc;
}
-
+
// Begin the creator function signature.
void BeginBuilderArgs(const StructDef &struct_def,
std::string *code_ptr) {
GetMemberOfVectorOfStruct(struct_def, field, code_ptr);
}
else {
- GetMemberOfVectorOfNonStruct(struct_def, field, code_ptr);
+ GetMemberOfVectorOfNonStruct(struct_def, field, code_ptr);
}
break;
}
GenComment(enum_def.doc_comment, code_ptr, nullptr, Comment);
BeginEnum(NormalizedName(enum_def), code_ptr);
- for (auto it = enum_def.vals.vec.begin(); it != enum_def.vals.vec.end();
- ++it) {
+ for (auto it = enum_def.Vals().begin(); it != enum_def.Vals().end();
+ ++it) {
auto &ev = **it;
GenComment(ev.doc_comment, code_ptr, nullptr, Comment);
- EnumMember(ev, code_ptr);
+ EnumMember(enum_def, ev, code_ptr);
}
EndEnum(code_ptr);
}
}
// A single enum member.
- static void EnumMember(const EnumVal ev, std::string *code_ptr) {
+ static void EnumMember(const EnumDef &enum_def, const EnumVal &ev,
+ std::string *code_ptr) {
std::string &code = *code_ptr;
code += Indent + "const ";
code += ev.name;
code += " = ";
code += NumToString(ev.value) + ";\n";
+ (void)enum_def;
}
// End enum code.
GenComment(enum_def.doc_comment, code_ptr, nullptr);
BeginEnum(enum_def.name, code_ptr);
- for (auto it = enum_def.vals.vec.begin(); it != enum_def.vals.vec.end();
- ++it) {
+ for (auto it = enum_def.Vals().begin(); it != enum_def.Vals().end(); ++it) {
auto &ev = **it;
GenComment(ev.doc_comment, code_ptr, nullptr);
- EnumMember(ev, code_ptr);
+ EnumMember(enum_def, ev, code_ptr);
}
std::string &code = *code_ptr;
code += "\n";
code += Indent + "private static $names = array(\n";
- for (auto it = enum_def.vals.vec.begin(); it != enum_def.vals.vec.end();
- ++it) {
+ for (auto it = enum_def.Vals().begin(); it != enum_def.Vals().end(); ++it) {
auto &ev = **it;
code += Indent + Indent + enum_def.name + "::" + ev.name + "=>" + "\"" + ev.name + "\",\n";
}
}
// A single enum member.
- void EnumMember(const EnumVal ev, std::string *code_ptr) {
+ void EnumMember(const EnumDef &enum_def, const EnumVal &ev,
+ std::string *code_ptr) {
std::string &code = *code_ptr;
code += Indent;
code += NormalizedName(ev);
code += " = ";
code += NumToString(ev.value) + "\n";
+ (void)enum_def;
}
// End enum code.
GenComment(enum_def.doc_comment, code_ptr, nullptr, "# ");
BeginEnum(NormalizedName(enum_def), code_ptr);
- for (auto it = enum_def.vals.vec.begin(); it != enum_def.vals.vec.end();
- ++it) {
+ for (auto it = enum_def.Vals().begin(); it != enum_def.Vals().end(); ++it) {
auto &ev = **it;
GenComment(ev.doc_comment, code_ptr, nullptr, "# ");
- EnumMember(ev, code_ptr);
+ EnumMember(enum_def, ev, code_ptr);
}
EndEnum(code_ptr);
}
// structs, and tables) and output them to a single file.
bool generate() {
code_.Clear();
- code_ += "// " + std::string(FlatBuffersGeneratedWarning()) + "\n\n";
+ code_ += "// " + std::string(FlatBuffersGeneratedWarning()) + "\n\n";
assert(!cur_name_space_);
int64_t anyv = 0;
const EnumVal *minv = nullptr, *maxv = nullptr;
- for (auto it = enum_def.vals.vec.begin(); it != enum_def.vals.vec.end();
- ++it) {
+ for (auto it = enum_def.Vals().begin(); it != enum_def.Vals().end(); ++it) {
const auto &ev = **it;
GenComment(ev.doc_comment, " ");
code_ += "";
// Generate an array of all enumeration values.
- auto num_fields = NumToString(enum_def.vals.vec.size());
+ auto num_fields = NumToString(enum_def.size());
code_ += "#[allow(non_camel_case_types)]";
code_ += "const ENUM_VALUES_{{ENUM_NAME_CAPS}}:[{{ENUM_NAME}}; " +
num_fields + "] = [";
- for (auto it = enum_def.vals.vec.begin(); it != enum_def.vals.vec.end();
- ++it) {
+ for (auto it = enum_def.Vals().begin(); it != enum_def.Vals().end(); ++it) {
const auto &ev = **it;
auto value = GetEnumValUse(enum_def, ev);
- auto suffix = *it != enum_def.vals.vec.back() ? "," : "";
+ auto suffix = *it != enum_def.Vals().back() ? "," : "";
code_ += " " + value + suffix;
}
code_ += "];";
code_ += "const ENUM_NAMES_{{ENUM_NAME_CAPS}}:[&'static str; " +
NumToString(range) + "] = [";
- auto val = enum_def.vals.vec.front()->value;
- for (auto it = enum_def.vals.vec.begin(); it != enum_def.vals.vec.end();
+ auto val = enum_def.Vals().front()->value;
+ for (auto it = enum_def.Vals().begin(); it != enum_def.Vals().end();
++it) {
const auto &ev = **it;
while (val++ != ev.value) { code_ += " \"\","; }
code_.SetValue("FIELD_NAME", Name(field));
- for (auto u_it = u->vals.vec.begin(); u_it != u->vals.vec.end(); ++u_it) {
+ for (auto u_it = u->Vals().begin(); u_it != u->Vals().end(); ++u_it) {
auto &ev = **u_it;
if (ev.union_type.base_type == BASE_TYPE_NONE) { continue; }
return ce;
}
-CheckedError Parser::InvalidNumber(const char *number, const std::string &msg) {
- return Error("invalid number: \"" + std::string(number) + "\"" + msg);
+template<typename T> std::string TypeToIntervalString() {
+ return "[" + NumToString((flatbuffers::numeric_limits<T>::lowest)()) + "; " +
+ NumToString((flatbuffers::numeric_limits<T>::max)()) + "]";
}
-// atot: templated version of atoi/atof: convert a string to an instance of T.
+
+// atot: template version of atoi/atof: convert a string to an instance of T.
template<typename T>
inline CheckedError atot(const char *s, Parser &parser, T *val) {
auto done = StringToNumber(s, val);
if (done) return NoError();
-
- return parser.InvalidNumber(
- s, (0 == *val)
- ? ""
- : (", constant does not fit [" +
- NumToString(flatbuffers::numeric_limits<T>::lowest()) + "; " +
- NumToString(flatbuffers::numeric_limits<T>::max()) + "]"));
+ if (0 == *val)
+ return parser.Error("invalid number: \"" + std::string(s) + "\"");
+ else
+ return parser.Error("invalid number: \"" + std::string(s) + "\"" +
+ ", constant does not fit " + TypeToIntervalString<T>());
}
template<>
inline CheckedError atot<Offset<void>>(const char *s, Parser &parser,
nested_parser.enums_.vec.clear();
if (!ok) {
- ECHECK(Error(nested_parser.error_));
+ ECHECK(Error(nested_parser.error_));
}
// Force alignment for nested flatbuffer
builder_.ForceVectorAlignment(nested_parser.builder_.GetSize(), sizeof(uint8_t),
return NoError();
}
-CheckedError Parser::ParseEnumFromString(Type &type, int64_t *result) {
- *result = 0;
+CheckedError Parser::ParseEnumFromString(const Type &type,
+ std::string *result) {
+ int64_t i64 = 0;
// Parse one or more enum identifiers, separated by spaces.
const char *next = attribute_.c_str();
do {
if (!enum_val)
return Error("unknown enum value: " + word +
", for enum: " + type.enum_def->name);
- *result |= enum_val->value;
+ i64 |= enum_val->value;
} else { // No enum type, probably integral field.
if (!IsInteger(type.base_type))
return Error("not a valid value for this field: " + word);
if (!enum_def) return Error("unknown enum: " + enum_def_str);
auto enum_val = enum_def->vals.Lookup(enum_val_str);
if (!enum_val) return Error("unknown enum value: " + enum_val_str);
- *result |= enum_val->value;
+ i64 |= enum_val->value;
}
} while (*next);
+ *result = NumToString(i64);
return NoError();
}
// Enum can have only true integer base type.
if (!match && IsInteger(e.type.base_type) && !IsBool(e.type.base_type) &&
IsIdentifierStart(*attribute_.c_str())) {
- int64_t val;
- ECHECK(ParseEnumFromString(e.type, &val));
- e.constant = NumToString(val);
+ ECHECK(ParseEnumFromString(e.type, &e.constant));
NEXT();
match = true;
}
for (auto it = enums_.vec.begin(); it != enums_.vec.end(); ++it) {
auto &enum_def = **it;
if (enum_def.is_union) {
- for (auto val_it = enum_def.vals.vec.begin();
- val_it != enum_def.vals.vec.end(); ++val_it) {
+ for (auto val_it = enum_def.Vals().begin();
+ val_it != enum_def.Vals().end(); ++val_it) {
auto &val = **val_it;
if (!SupportsAdvancedUnionFeatures() && val.union_type.struct_def &&
val.union_type.struct_def->fixed)
enum_def.defined_namespace->GetFullyQualifiedName(enum_def.name);
auto enum_def_base = base.enums_.Lookup(qualified_name);
if (!enum_def_base) continue;
- for (auto evit = enum_def.vals.vec.begin(); evit != enum_def.vals.vec.end();
+ for (auto evit = enum_def.Vals().begin(); evit != enum_def.Vals().end();
++evit) {
auto &enum_val = **evit;
auto enum_val_base = enum_def_base->vals.Lookup(enum_val.name);