BigfootDev/flatbuffers
1
0
Fork 1
mirror of https://github.com/google/flatbuffers.git synced 2026-06-30 23:21:38 +00:00
Code Issues Packages Projects Releases Wiki Activity

Apply Namer to Go code gen (#7150)

Browse Source 
* Refactor out a  class from Rust Codegen

* Convert GenerateRustModuleRootFile

* git-clang-format

* unused variable

* parenthesis

* update BUILD file

* buildifier

* Delete bfbs_gen_rust.h

* Delete bfbs_gen_rust.cpp

* Addressed some comments

* Namer::EnumVariant

* Remove do not submit; Add Namespace vector overload

* Unshadow variable

* removed redundant variables

* Apply Namer to Python

* Use more variables a bit

* Apply const a bunch

* More variables

* Fix ObjectTypes

* git clang format

* small thing

* Simplified code around nested flatbuffers

* Make more methods const.

* Python files are kKeep case

* Address DO NOT SUBMIT in SaveType

* ensure dir exists before saving files

* clang format

Co-authored-by: Casper Neo <cneo@google.com>
This commit is contained in:
Casper
2022-03-08 20:53:05 -05:00
committed by GitHub
parent d648396515
commit 2f84c60385
2 changed files with 199 additions and 208 deletions
Download Patch File Download Diff File Expand all files Collapse all files

381
src/idl_gen_go.cpp
View File

@@ -23,6 +23,7 @@
#include "flatbuffers/flatbuffers.h" #include "flatbuffers/flatbuffers.h"
#include "flatbuffers/idl.h" #include "flatbuffers/idl.h"
#include "flatbuffers/util.h" #include "flatbuffers/util.h"
#include "namer.h"
#ifdef _WIN32 #ifdef _WIN32
# include <direct.h> # include <direct.h>
@@ -38,22 +39,39 @@ namespace flatbuffers {
namespace go { namespace go {
// see https://golang.org/ref/spec#Keywords // see https://golang.org/ref/spec#Keywords
static const char *const g_golang_keywords[] = { std::set<std::string> GoKeywords() {
"break", "default", "func", "interface", "select", "case", "defer", return {
"go", "map", "struct", "chan", "else", "goto", "package", "break", "default", "func", "interface", "select",
"switch", "const", "fallthrough", "if", "range", "type", "continue", "case", "defer", "go", "map", "struct",
"for", "import", "return", "var", "chan", "else", "goto", "package", "switch",
}; "const", "fallthrough", "if", "range", "type",
"continue", "for", "import", "return", "var",
};
}
static std::string GoIdentity(const std::string &name) { Namer::Config GoDefaultConfig() {
for (size_t i = 0; // Note that the functions with user defined types in the name use
i < sizeof(g_golang_keywords) / sizeof(g_golang_keywords[0]); i++) { // upper camel case for all but the user defined type itself, which is keep
if (name == g_golang_keywords[i]) { // cased. Despite being a function, we interpret it as a Type.
return ConvertCase(name + "_", Case::kLowerCamel); return { /*types=*/Case::kKeep,
} /*constants=*/Case::kUnknown,
} /*methods=*/Case::kUpperCamel,
/*functions=*/Case::kUpperCamel,
return ConvertCase(name, Case::kLowerCamel); /*fields=*/Case::kUpperCamel,
/*variables=*/Case::kLowerCamel,
/*variants=*/Case::kKeep,
/*enum_variant_seperator=*/"", // I.e. Concatenate.
/*namespaces=*/Case::kKeep,
/*namespace_seperator=*/"__",
/*object_prefix=*/"",
/*object_suffix=*/"T",
/*keyword_prefix=*/"",
/*keyword_suffix=*/"_",
/*filenames=*/Case::kKeep,
/*directories=*/Case::kKeep,
/*output_path=*/"",
/*filename_suffix=*/"",
/*filename_extension=*/".go" };
} }
class GoGenerator : public BaseGenerator { class GoGenerator : public BaseGenerator {
@@ -62,7 +80,9 @@ class GoGenerator : public BaseGenerator {
const std::string &file_name, const std::string &go_namespace) const std::string &file_name, const std::string &go_namespace)
: BaseGenerator(parser, path, file_name, "" /* not used*/, : BaseGenerator(parser, path, file_name, "" /* not used*/,
"" /* not used */, "go"), "" /* not used */, "go"),
cur_name_space_(nullptr) { cur_name_space_(nullptr),
namer_({ GoDefaultConfig().WithFlagOptions(parser.opts, path),
GoKeywords() }) {
std::istringstream iss(go_namespace); std::istringstream iss(go_namespace);
std::string component; std::string component;
while (std::getline(iss, component, '.')) { while (std::getline(iss, component, '.')) {
@@ -120,6 +140,7 @@ class GoGenerator : public BaseGenerator {
private: private:
Namespace go_namespace_; Namespace go_namespace_;
Namespace *cur_name_space_; Namespace *cur_name_space_;
const Namer namer_;
struct NamespacePtrLess { struct NamespacePtrLess {
bool operator()(const Namespace *a, const Namespace *b) const { bool operator()(const Namespace *a, const Namespace *b) const {
@@ -139,7 +160,7 @@ class GoGenerator : public BaseGenerator {
void BeginClass(const StructDef &struct_def, std::string *code_ptr) { void BeginClass(const StructDef &struct_def, std::string *code_ptr) {
std::string &code = *code_ptr; std::string &code = *code_ptr;
code += "type " + struct_def.name + " struct {\n\t"; code += "type " + namer_.Type(struct_def.name) + " struct {\n\t";
// _ is reserved in flatbuffers field names, so no chance of name conflict: // _ is reserved in flatbuffers field names, so no chance of name conflict:
code += "_tab "; code += "_tab ";
@@ -150,7 +171,7 @@ class GoGenerator : public BaseGenerator {
// Construct the name of the type for this enum. // Construct the name of the type for this enum.
std::string GetEnumTypeName(const EnumDef &enum_def) { std::string GetEnumTypeName(const EnumDef &enum_def) {
return WrapInNameSpaceAndTrack(enum_def.defined_namespace, return WrapInNameSpaceAndTrack(enum_def.defined_namespace,
GoIdentity(enum_def.name)); namer_.Type(enum_def.name));
} }
// Create a type for the enum values. // Create a type for the enum values.
@@ -171,8 +192,7 @@ class GoGenerator : public BaseGenerator {
size_t max_name_length, std::string *code_ptr) { size_t max_name_length, std::string *code_ptr) {
std::string &code = *code_ptr; std::string &code = *code_ptr;
code += "\t"; code += "\t";
code += enum_def.name; code += namer_.EnumVariant(enum_def.name, ev.name);
code += ev.name;
code += " "; code += " ";
code += std::string(max_name_length - ev.name.length(), ' '); code += std::string(max_name_length - ev.name.length(), ' ');
code += GetEnumTypeName(enum_def); code += GetEnumTypeName(enum_def);
@@ -199,8 +219,7 @@ class GoGenerator : public BaseGenerator {
size_t max_name_length, std::string *code_ptr) { size_t max_name_length, std::string *code_ptr) {
std::string &code = *code_ptr; std::string &code = *code_ptr;
code += "\t"; code += "\t";
code += enum_def.name; code += namer_.EnumVariant(enum_def.name, ev.name);
code += ev.name;
code += ": "; code += ": ";
code += std::string(max_name_length - ev.name.length(), ' '); code += std::string(max_name_length - ev.name.length(), ' ');
code += "\""; code += "\"";
@@ -217,8 +236,9 @@ class GoGenerator : public BaseGenerator {
// Generate String() method on enum type. // Generate String() method on enum type.
void EnumStringer(const EnumDef &enum_def, std::string *code_ptr) { void EnumStringer(const EnumDef &enum_def, std::string *code_ptr) {
std::string &code = *code_ptr; std::string &code = *code_ptr;
code += "func (v " + enum_def.name + ") String() string {\n"; const std::string enum_type = namer_.Type(enum_def.name);
code += "\tif s, ok := EnumNames" + enum_def.name + "[v]; ok {\n"; code += "func (v " + enum_type + ") String() string {\n";
code += "\tif s, ok := EnumNames" + enum_type + "[v]; ok {\n";
code += "\t\treturn s\n"; code += "\t\treturn s\n";
code += "\t}\n"; code += "\t}\n";
code += "\treturn \"" + enum_def.name; code += "\treturn \"" + enum_def.name;
@@ -230,7 +250,7 @@ class GoGenerator : public BaseGenerator {
void BeginEnumValues(const EnumDef &enum_def, std::string *code_ptr) { void BeginEnumValues(const EnumDef &enum_def, std::string *code_ptr) {
std::string &code = *code_ptr; std::string &code = *code_ptr;
code += "var EnumValues"; code += "var EnumValues";
code += enum_def.name; code += namer_.Type(enum_def.name);
code += " = map[string]" + GetEnumTypeName(enum_def) + "{\n"; code += " = map[string]" + GetEnumTypeName(enum_def) + "{\n";
} }
@@ -242,8 +262,7 @@ class GoGenerator : public BaseGenerator {
code += ev.name; code += ev.name;
code += "\": "; code += "\": ";
code += std::string(max_name_length - ev.name.length(), ' '); code += std::string(max_name_length - ev.name.length(), ' ');
code += enum_def.name; code += namer_.EnumVariant(enum_def.name, ev.name);
code += ev.name;
code += ",\n"; code += ",\n";
} }
@@ -257,13 +276,13 @@ class GoGenerator : public BaseGenerator {
void NewRootTypeFromBuffer(const StructDef &struct_def, void NewRootTypeFromBuffer(const StructDef &struct_def,
std::string *code_ptr) { std::string *code_ptr) {
std::string &code = *code_ptr; std::string &code = *code_ptr;
std::string size_prefix[] = { "", "SizePrefixed" }; const std::string size_prefix[] = { "", "SizePrefixed" };
const std::string struct_type = namer_.Type(struct_def.name);
for (int i = 0; i < 2; i++) { for (int i = 0; i < 2; i++) {
code += "func Get" + size_prefix[i] + "RootAs"; code += "func Get" + size_prefix[i] + "RootAs" + struct_type;
code += struct_def.name;
code += "(buf []byte, offset flatbuffers.UOffsetT) "; code += "(buf []byte, offset flatbuffers.UOffsetT) ";
code += "*" + struct_def.name + ""; code += "*" + struct_type + "";
code += " {\n"; code += " {\n";
if (i == 0) { if (i == 0) {
code += "\tn := flatbuffers.GetUOffsetT(buf[offset:])\n"; code += "\tn := flatbuffers.GetUOffsetT(buf[offset:])\n";
@@ -272,7 +291,7 @@ class GoGenerator : public BaseGenerator {
"\tn := " "\tn := "
"flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:])\n"; "flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:])\n";
} }
code += "\tx := &" + struct_def.name + "{}\n"; code += "\tx := &" + struct_type + "{}\n";
if (i == 0) { if (i == 0) {
code += "\tx.Init(buf, n+offset)\n"; code += "\tx.Init(buf, n+offset)\n";
} else { } else {
@@ -317,7 +336,7 @@ class GoGenerator : public BaseGenerator {
std::string &code = *code_ptr; std::string &code = *code_ptr;
GenReceiver(struct_def, code_ptr); GenReceiver(struct_def, code_ptr);
code += " " + ConvertCase(field.name, Case::kUpperCamel) + "Length("; code += " " + namer_.Function(field.name) + "Length(";
code += ") int " + OffsetPrefix(field); code += ") int " + OffsetPrefix(field);
code += "\t\treturn rcv._tab.VectorLen(o)\n\t}\n"; code += "\t\treturn rcv._tab.VectorLen(o)\n\t}\n";
code += "\treturn 0\n}\n\n"; code += "\treturn 0\n}\n\n";
@@ -329,7 +348,7 @@ class GoGenerator : public BaseGenerator {
std::string &code = *code_ptr; std::string &code = *code_ptr;
GenReceiver(struct_def, code_ptr); GenReceiver(struct_def, code_ptr);
code += " " + ConvertCase(field.name, Case::kUpperCamel) + "Bytes("; code += " " + namer_.Function(field.name) + "Bytes(";
code += ") []byte " + OffsetPrefix(field); code += ") []byte " + OffsetPrefix(field);
code += "\t\treturn rcv._tab.ByteVector(o + rcv._tab.Pos)\n\t}\n"; code += "\t\treturn rcv._tab.ByteVector(o + rcv._tab.Pos)\n\t}\n";
code += "\treturn nil\n}\n\n"; code += "\treturn nil\n}\n\n";
@@ -341,7 +360,7 @@ class GoGenerator : public BaseGenerator {
std::string &code = *code_ptr; std::string &code = *code_ptr;
std::string getter = GenGetter(field.value.type); std::string getter = GenGetter(field.value.type);
GenReceiver(struct_def, code_ptr); GenReceiver(struct_def, code_ptr);
code += " " + ConvertCase(field.name, Case::kUpperCamel); code += " " + namer_.Function(field.name);
code += "() " + TypeName(field) + " {\n"; code += "() " + TypeName(field) + " {\n";
code += "\treturn " + code += "\treturn " +
CastToEnum(field.value.type, CastToEnum(field.value.type,
@@ -356,7 +375,7 @@ class GoGenerator : public BaseGenerator {
std::string &code = *code_ptr; std::string &code = *code_ptr;
std::string getter = GenGetter(field.value.type); std::string getter = GenGetter(field.value.type);
GenReceiver(struct_def, code_ptr); GenReceiver(struct_def, code_ptr);
code += " " + ConvertCase(field.name, Case::kUpperCamel); code += " " + namer_.Function(field.name);
code += "() " + TypeName(field) + " "; code += "() " + TypeName(field) + " ";
code += OffsetPrefix(field); code += OffsetPrefix(field);
if (field.IsScalarOptional()) { if (field.IsScalarOptional()) {
@@ -379,7 +398,7 @@ class GoGenerator : public BaseGenerator {
const FieldDef &field, std::string *code_ptr) { const FieldDef &field, std::string *code_ptr) {
std::string &code = *code_ptr; std::string &code = *code_ptr;
GenReceiver(struct_def, code_ptr); GenReceiver(struct_def, code_ptr);
code += " " + ConvertCase(field.name, Case::kUpperCamel); code += " " + namer_.Function(field.name);
code += "(obj *" + TypeName(field); code += "(obj *" + TypeName(field);
code += ") *" + TypeName(field); code += ") *" + TypeName(field);
code += " {\n"; code += " {\n";
@@ -398,7 +417,7 @@ class GoGenerator : public BaseGenerator {
std::string *code_ptr) { std::string *code_ptr) {
std::string &code = *code_ptr; std::string &code = *code_ptr;
GenReceiver(struct_def, code_ptr); GenReceiver(struct_def, code_ptr);
code += " " + ConvertCase(field.name, Case::kUpperCamel); code += " " + namer_.Function(field.name);
code += "(obj *"; code += "(obj *";
code += TypeName(field); code += TypeName(field);
code += ") *" + TypeName(field) + " " + OffsetPrefix(field); code += ") *" + TypeName(field) + " " + OffsetPrefix(field);
@@ -420,7 +439,7 @@ class GoGenerator : public BaseGenerator {
std::string *code_ptr) { std::string *code_ptr) {
std::string &code = *code_ptr; std::string &code = *code_ptr;
GenReceiver(struct_def, code_ptr); GenReceiver(struct_def, code_ptr);
code += " " + ConvertCase(field.name, Case::kUpperCamel); code += " " + namer_.Function(field.name);
code += "() " + TypeName(field) + " "; code += "() " + TypeName(field) + " ";
code += OffsetPrefix(field) + "\t\treturn " + GenGetter(field.value.type); code += OffsetPrefix(field) + "\t\treturn " + GenGetter(field.value.type);
code += "(o + rcv._tab.Pos)\n\t}\n\treturn nil\n"; code += "(o + rcv._tab.Pos)\n\t}\n\treturn nil\n";
@@ -432,7 +451,7 @@ class GoGenerator : public BaseGenerator {
std::string *code_ptr) { std::string *code_ptr) {
std::string &code = *code_ptr; std::string &code = *code_ptr;
GenReceiver(struct_def, code_ptr); GenReceiver(struct_def, code_ptr);
code += " " + ConvertCase(field.name, Case::kUpperCamel) + "("; code += " " + namer_.Function(field.name) + "(";
code += "obj " + GenTypePointer(field.value.type) + ") bool "; code += "obj " + GenTypePointer(field.value.type) + ") bool ";
code += OffsetPrefix(field); code += OffsetPrefix(field);
code += "\t\t" + GenGetter(field.value.type); code += "\t\t" + GenGetter(field.value.type);
@@ -448,7 +467,7 @@ class GoGenerator : public BaseGenerator {
auto vectortype = field.value.type.VectorType(); auto vectortype = field.value.type.VectorType();
GenReceiver(struct_def, code_ptr); GenReceiver(struct_def, code_ptr);
code += " " + ConvertCase(field.name, Case::kUpperCamel); code += " " + namer_.Function(field.name);
code += "(obj *" + TypeName(field); code += "(obj *" + TypeName(field);
code += ", j int) bool " + OffsetPrefix(field); code += ", j int) bool " + OffsetPrefix(field);
code += "\t\tx := rcv._tab.Vector(o)\n"; code += "\t\tx := rcv._tab.Vector(o)\n";
@@ -471,7 +490,7 @@ class GoGenerator : public BaseGenerator {
auto vectortype = field.value.type.VectorType(); auto vectortype = field.value.type.VectorType();
GenReceiver(struct_def, code_ptr); GenReceiver(struct_def, code_ptr);
code += " " + ConvertCase(field.name, Case::kUpperCamel); code += " " + namer_.Function(field.name);
code += "(j int) " + TypeName(field) + " "; code += "(j int) " + TypeName(field) + " ";
code += OffsetPrefix(field); code += OffsetPrefix(field);
code += "\t\ta := rcv._tab.Vector(o)\n"; code += "\t\ta := rcv._tab.Vector(o)\n";
@@ -519,7 +538,7 @@ class GoGenerator : public BaseGenerator {
} else { } else {
std::string &code = *code_ptr; std::string &code = *code_ptr;
code += std::string(", ") + nameprefix; code += std::string(", ") + nameprefix;
code += GoIdentity(field.name); code += namer_.Variable(field.name);
code += " " + TypeName(field); code += " " + TypeName(field);
} }
} }
@@ -549,7 +568,7 @@ class GoGenerator : public BaseGenerator {
} else { } else {
code += "\tbuilder.Prepend" + GenMethod(field) + "("; code += "\tbuilder.Prepend" + GenMethod(field) + "(";
code += CastToBaseType(field.value.type, code += CastToBaseType(field.value.type,
nameprefix + GoIdentity(field.name)) + nameprefix + namer_.Variable(field.name)) +
")\n"; ")\n";
} }
} }
@@ -564,7 +583,7 @@ class GoGenerator : public BaseGenerator {
// Get the value of a table's starting offset. // Get the value of a table's starting offset.
void GetStartOfTable(const StructDef &struct_def, std::string *code_ptr) { void GetStartOfTable(const StructDef &struct_def, std::string *code_ptr) {
std::string &code = *code_ptr; std::string &code = *code_ptr;
code += "func " + struct_def.name + "Start"; code += "func " + namer_.Type(struct_def.name) + "Start";
code += "(builder *flatbuffers.Builder) {\n"; code += "(builder *flatbuffers.Builder) {\n";
code += "\tbuilder.StartObject("; code += "\tbuilder.StartObject(";
code += NumToString(struct_def.fields.vec.size()); code += NumToString(struct_def.fields.vec.size());
@@ -575,10 +594,11 @@ class GoGenerator : public BaseGenerator {
void BuildFieldOfTable(const StructDef &struct_def, const FieldDef &field, void BuildFieldOfTable(const StructDef &struct_def, const FieldDef &field,
const size_t offset, std::string *code_ptr) { const size_t offset, std::string *code_ptr) {
std::string &code = *code_ptr; std::string &code = *code_ptr;
code += "func " + struct_def.name + "Add" + const std::string field_var = namer_.Variable(field.name);
ConvertCase(field.name, Case::kUpperCamel); code += "func " + namer_.Type(struct_def.name) + "Add" +
namer_.Function(field.name);
code += "(builder *flatbuffers.Builder, "; code += "(builder *flatbuffers.Builder, ";
code += GoIdentity(field.name) + " "; code += field_var + " ";
if (!IsScalar(field.value.type.base_type) && (!struct_def.fixed)) { if (!IsScalar(field.value.type.base_type) && (!struct_def.fixed)) {
code += "flatbuffers.UOffsetT"; code += "flatbuffers.UOffsetT";
} else { } else {
@@ -594,10 +614,9 @@ class GoGenerator : public BaseGenerator {
} }
if (!IsScalar(field.value.type.base_type) && (!struct_def.fixed)) { if (!IsScalar(field.value.type.base_type) && (!struct_def.fixed)) {
code += "flatbuffers.UOffsetT"; code += "flatbuffers.UOffsetT";
code += "("; code += "(" + field_var + ")";
code += GoIdentity(field.name) + ")";
} else { } else {
code += CastToBaseType(field.value.type, GoIdentity(field.name)); code += CastToBaseType(field.value.type, field_var);
} }
if (field.IsScalarOptional()) { if (field.IsScalarOptional()) {
code += ")\n"; code += ")\n";
@@ -613,8 +632,8 @@ class GoGenerator : public BaseGenerator {
void BuildVectorOfTable(const StructDef &struct_def, const FieldDef &field, void BuildVectorOfTable(const StructDef &struct_def, const FieldDef &field,
std::string *code_ptr) { std::string *code_ptr) {
std::string &code = *code_ptr; std::string &code = *code_ptr;
code += "func " + struct_def.name + "Start"; code += "func " + namer_.Type(struct_def.name) + "Start";
code += ConvertCase(field.name, Case::kUpperCamel); code += namer_.Function(field.name);
code += "Vector(builder *flatbuffers.Builder, numElems int) "; code += "Vector(builder *flatbuffers.Builder, numElems int) ";
code += "flatbuffers.UOffsetT {\n\treturn builder.StartVector("; code += "flatbuffers.UOffsetT {\n\treturn builder.StartVector(";
auto vector_type = field.value.type.VectorType(); auto vector_type = field.value.type.VectorType();
@@ -628,7 +647,7 @@ class GoGenerator : public BaseGenerator {
// Get the offset of the end of a table. // Get the offset of the end of a table.
void GetEndOffsetOnTable(const StructDef &struct_def, std::string *code_ptr) { void GetEndOffsetOnTable(const StructDef &struct_def, std::string *code_ptr) {
std::string &code = *code_ptr; std::string &code = *code_ptr;
code += "func " + struct_def.name + "End"; code += "func " + namer_.Type(struct_def.name) + "End";
code += "(builder *flatbuffers.Builder) flatbuffers.UOffsetT "; code += "(builder *flatbuffers.Builder) flatbuffers.UOffsetT ";
code += "{\n\treturn builder.EndObject()\n}\n"; code += "{\n\treturn builder.EndObject()\n}\n";
} }
@@ -636,7 +655,7 @@ class GoGenerator : public BaseGenerator {
// Generate the receiver for function signatures. // Generate the receiver for function signatures.
void GenReceiver(const StructDef &struct_def, std::string *code_ptr) { void GenReceiver(const StructDef &struct_def, std::string *code_ptr) {
std::string &code = *code_ptr; std::string &code = *code_ptr;
code += "func (rcv *" + struct_def.name + ")"; code += "func (rcv *" + namer_.Type(struct_def.name) + ")";
} }
// Generate a struct field getter, conditioned on its child type(s). // Generate a struct field getter, conditioned on its child type(s).
@@ -686,11 +705,10 @@ class GoGenerator : public BaseGenerator {
void MutateScalarFieldOfStruct(const StructDef &struct_def, void MutateScalarFieldOfStruct(const StructDef &struct_def,
const FieldDef &field, std::string *code_ptr) { const FieldDef &field, std::string *code_ptr) {
std::string &code = *code_ptr; std::string &code = *code_ptr;
std::string type = std::string setter =
ConvertCase(GenTypeBasic(field.value.type), Case::kUpperCamel); "rcv._tab.Mutate" + namer_.Method(GenTypeBasic(field.value.type));
std::string setter = "rcv._tab.Mutate" + type;
GenReceiver(struct_def, code_ptr); GenReceiver(struct_def, code_ptr);
code += " Mutate" + ConvertCase(field.name, Case::kUpperCamel); code += " Mutate" + namer_.Function(field.name);
code += "(n " + GenTypeGet(field.value.type) + ") bool {\n\treturn " + setter; code += "(n " + GenTypeGet(field.value.type) + ") bool {\n\treturn " + setter;
code += "(rcv._tab.Pos+flatbuffers.UOffsetT("; code += "(rcv._tab.Pos+flatbuffers.UOffsetT(";
code += NumToString(field.value.offset) + "), "; code += NumToString(field.value.offset) + "), ";
@@ -701,11 +719,10 @@ class GoGenerator : public BaseGenerator {
void MutateScalarFieldOfTable(const StructDef &struct_def, void MutateScalarFieldOfTable(const StructDef &struct_def,
const FieldDef &field, std::string *code_ptr) { const FieldDef &field, std::string *code_ptr) {
std::string &code = *code_ptr; std::string &code = *code_ptr;
std::string type = std::string setter = "rcv._tab.Mutate" +
ConvertCase(GenTypeBasic(field.value.type), Case::kUpperCamel); namer_.Method(GenTypeBasic(field.value.type)) + "Slot";
std::string setter = "rcv._tab.Mutate" + type + "Slot";
GenReceiver(struct_def, code_ptr); GenReceiver(struct_def, code_ptr);
code += " Mutate" + ConvertCase(field.name, Case::kUpperCamel); code += " Mutate" + namer_.Function(field.name);
code += "(n " + GenTypeGet(field.value.type) + ") bool {\n\treturn "; code += "(n " + GenTypeGet(field.value.type) + ") bool {\n\treturn ";
code += setter + "(" + NumToString(field.value.offset) + ", "; code += setter + "(" + NumToString(field.value.offset) + ", ";
code += CastToBaseType(field.value.type, "n") + ")\n"; code += CastToBaseType(field.value.type, "n") + ")\n";
@@ -718,10 +735,10 @@ class GoGenerator : public BaseGenerator {
std::string *code_ptr) { std::string *code_ptr) {
std::string &code = *code_ptr; std::string &code = *code_ptr;
auto vectortype = field.value.type.VectorType(); auto vectortype = field.value.type.VectorType();
std::string type = ConvertCase(GenTypeBasic(vectortype), Case::kUpperCamel); std::string setter =
std::string setter = "rcv._tab.Mutate" + type; "rcv._tab.Mutate" + namer_.Method(GenTypeBasic(vectortype));
GenReceiver(struct_def, code_ptr); GenReceiver(struct_def, code_ptr);
code += " Mutate" + ConvertCase(field.name, Case::kUpperCamel); code += " Mutate" + namer_.Function(field.name);
code += "(j int, n " + TypeName(field) + ") bool "; code += "(j int, n " + TypeName(field) + ") bool ";
code += OffsetPrefix(field); code += OffsetPrefix(field);
code += "\t\ta := rcv._tab.Vector(o)\n"; code += "\t\ta := rcv._tab.Vector(o)\n";
@@ -824,7 +841,7 @@ class GoGenerator : public BaseGenerator {
field.value.type.enum_def != nullptr && field.value.type.enum_def != nullptr &&
field.value.type.enum_def->is_union) field.value.type.enum_def->is_union)
continue; continue;
code += "\t" + ConvertCase(field.name, Case::kUpperCamel) + " "; code += "\t" + namer_.Field(field.name) + " ";
if (field.IsScalarOptional()) { if (field.IsScalarOptional()) {
code += "*"; code += "*";
} }
@@ -844,7 +861,7 @@ class GoGenerator : public BaseGenerator {
void GenNativeUnion(const EnumDef &enum_def, std::string *code_ptr) { void GenNativeUnion(const EnumDef &enum_def, std::string *code_ptr) {
std::string &code = *code_ptr; std::string &code = *code_ptr;
code += "type " + NativeName(enum_def) + " struct {\n"; code += "type " + NativeName(enum_def) + " struct {\n";
code += "\tType " + enum_def.name + "\n"; code += "\tType " + namer_.Type(enum_def.name) + "\n";
code += "\tValue interface{}\n"; code += "\tValue interface{}\n";
code += "}\n\n"; code += "}\n\n";
} }
@@ -860,7 +877,7 @@ class GoGenerator : public BaseGenerator {
++it2) { ++it2) {
const EnumVal &ev = **it2; const EnumVal &ev = **it2;
if (ev.IsZero()) continue; if (ev.IsZero()) continue;
code += "\tcase " + enum_def.name + ev.name + ":\n"; code += "\tcase " + namer_.EnumVariant(enum_def.name, ev.name) + ":\n";
code += "\t\treturn t.Value.(" + NativeType(ev.union_type) + code += "\t\treturn t.Value.(" + NativeType(ev.union_type) +
").Pack(builder)\n"; ").Pack(builder)\n";
} }
@@ -872,7 +889,7 @@ class GoGenerator : public BaseGenerator {
void GenNativeUnionUnPack(const EnumDef &enum_def, std::string *code_ptr) { void GenNativeUnionUnPack(const EnumDef &enum_def, std::string *code_ptr) {
std::string &code = *code_ptr; std::string &code = *code_ptr;
code += "func (rcv " + enum_def.name + code += "func (rcv " + namer_.Type(enum_def.name) +
") UnPack(table flatbuffers.Table) *" + NativeName(enum_def) + ") UnPack(table flatbuffers.Table) *" + NativeName(enum_def) +
" {\n"; " {\n";
code += "\tswitch rcv {\n"; code += "\tswitch rcv {\n";
@@ -881,13 +898,14 @@ class GoGenerator : public BaseGenerator {
++it2) { ++it2) {
const EnumVal &ev = **it2; const EnumVal &ev = **it2;
if (ev.IsZero()) continue; if (ev.IsZero()) continue;
code += "\tcase " + enum_def.name + ev.name + ":\n"; code += "\tcase " + namer_.EnumVariant(enum_def.name, ev.name) + ":\n";
code += "\t\tx := " + ev.union_type.struct_def->name + "{_tab: table}\n"; code += "\t\tx := " + ev.union_type.struct_def->name + "{_tab: table}\n";
code += "\t\treturn &" + code += "\t\treturn &" +
WrapInNameSpaceAndTrack(enum_def.defined_namespace, WrapInNameSpaceAndTrack(enum_def.defined_namespace,
NativeName(enum_def)) + NativeName(enum_def)) +
"{ Type: " + enum_def.name + ev.name + ", Value: x.UnPack() }\n"; "{ Type: " + namer_.EnumVariant(enum_def.name, ev.name) +
", Value: x.UnPack() }\n";
} }
code += "\t}\n"; code += "\t}\n";
code += "\treturn nil\n"; code += "\treturn nil\n";
@@ -896,6 +914,7 @@ class GoGenerator : public BaseGenerator {
void GenNativeTablePack(const StructDef &struct_def, std::string *code_ptr) { void GenNativeTablePack(const StructDef &struct_def, std::string *code_ptr) {
std::string &code = *code_ptr; std::string &code = *code_ptr;
const std::string struct_type = namer_.Type(struct_def.name);
code += "func (t *" + NativeName(struct_def) + code += "func (t *" + NativeName(struct_def) +
") Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT {\n"; ") Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT {\n";
@@ -906,66 +925,56 @@ class GoGenerator : public BaseGenerator {
if (field.deprecated) continue; if (field.deprecated) continue;
if (IsScalar(field.value.type.base_type)) continue; if (IsScalar(field.value.type.base_type)) continue;
std::string offset = const std::string field_field = namer_.Field(field.name);
ConvertCase(field.name, Case::kLowerCamel) + "Offset"; const std::string field_var = namer_.Variable(field.name);
const std::string offset = field_var + "Offset";
if (IsString(field.value.type)) { if (IsString(field.value.type)) {
code += "\t" + offset + " := builder.CreateString(t." + code +=
ConvertCase(field.name, Case::kUpperCamel) + ")\n"; "\t" + offset + " := builder.CreateString(t." + field_field + ")\n";
} else if (IsVector(field.value.type) && } else if (IsVector(field.value.type) &&
field.value.type.element == BASE_TYPE_UCHAR && field.value.type.element == BASE_TYPE_UCHAR &&
field.value.type.enum_def == nullptr) { field.value.type.enum_def == nullptr) {
code += "\t" + offset + " := flatbuffers.UOffsetT(0)\n"; code += "\t" + offset + " := flatbuffers.UOffsetT(0)\n";
code += "\tif t." + ConvertCase(field.name, Case::kUpperCamel) + code += "\tif t." + field_field + " != nil {\n";
" != nil {\n";
code += "\t\t" + offset + " = builder.CreateByteString(t." + code += "\t\t" + offset + " = builder.CreateByteString(t." +
ConvertCase(field.name, Case::kUpperCamel) + ")\n"; field_field + ")\n";
code += "\t}\n"; code += "\t}\n";
} else if (IsVector(field.value.type)) { } else if (IsVector(field.value.type)) {
code += "\t" + offset + " := flatbuffers.UOffsetT(0)\n"; code += "\t" + offset + " := flatbuffers.UOffsetT(0)\n";
code += "\tif t." + ConvertCase(field.name, Case::kUpperCamel) + code += "\tif t." + field_field + " != nil {\n";
" != nil {\n"; std::string length = field_var + "Length";
std::string length = std::string offsets = field_var + "Offsets";
ConvertCase(field.name, Case::kLowerCamel) + "Length"; code += "\t\t" + length + " := len(t." + field_field + ")\n";
std::string offsets =
ConvertCase(field.name, Case::kLowerCamel) + "Offsets";
code += "\t\t" + length + " := len(t." +
ConvertCase(field.name, Case::kUpperCamel) + ")\n";
if (field.value.type.element == BASE_TYPE_STRING) { if (field.value.type.element == BASE_TYPE_STRING) {
code += "\t\t" + offsets + " := make([]flatbuffers.UOffsetT, " + code += "\t\t" + offsets + " := make([]flatbuffers.UOffsetT, " +
length + ")\n"; length + ")\n";
code += "\t\tfor j := 0; j < " + length + "; j++ {\n"; code += "\t\tfor j := 0; j < " + length + "; j++ {\n";
code += "\t\t\t" + offsets + "[j] = builder.CreateString(t." + code += "\t\t\t" + offsets + "[j] = builder.CreateString(t." +
ConvertCase(field.name, Case::kUpperCamel) + "[j])\n"; field_field + "[j])\n";
code += "\t\t}\n"; code += "\t\t}\n";
} else if (field.value.type.element == BASE_TYPE_STRUCT && } else if (field.value.type.element == BASE_TYPE_STRUCT &&
!field.value.type.struct_def->fixed) { !field.value.type.struct_def->fixed) {
code += "\t\t" + offsets + " := make([]flatbuffers.UOffsetT, " + code += "\t\t" + offsets + " := make([]flatbuffers.UOffsetT, " +
length + ")\n"; length + ")\n";
code += "\t\tfor j := 0; j < " + length + "; j++ {\n"; code += "\t\tfor j := 0; j < " + length + "; j++ {\n";
code += "\t\t\t" + offsets + "[j] = t." + code += "\t\t\t" + offsets + "[j] = t." + field_field +
ConvertCase(field.name, Case::kUpperCamel) +
"[j].Pack(builder)\n"; "[j].Pack(builder)\n";
code += "\t\t}\n"; code += "\t\t}\n";
} }
code += "\t\t" + struct_def.name + "Start" + code += "\t\t" + struct_type + "Start" + namer_.Function(field.name) +
ConvertCase(field.name, Case::kUpperCamel) +
"Vector(builder, " + length + ")\n"; "Vector(builder, " + length + ")\n";
code += "\t\tfor j := " + length + " - 1; j >= 0; j-- {\n"; code += "\t\tfor j := " + length + " - 1; j >= 0; j-- {\n";
if (IsScalar(field.value.type.element)) { if (IsScalar(field.value.type.element)) {
code += code += "\t\t\tbuilder.Prepend" +
"\t\t\tbuilder.Prepend" + namer_.Method(GenTypeBasic(field.value.type.VectorType())) +
ConvertCase(GenTypeBasic(field.value.type.VectorType()), "(" +
Case::kUpperCamel) + CastToBaseType(field.value.type.VectorType(),
"(" + "t." + field_field + "[j]") +
CastToBaseType( ")\n";
field.value.type.VectorType(),
"t." + ConvertCase(field.name, Case::kUpperCamel) + "[j]") +
")\n";
} else if (field.value.type.element == BASE_TYPE_STRUCT && } else if (field.value.type.element == BASE_TYPE_STRUCT &&
field.value.type.struct_def->fixed) { field.value.type.struct_def->fixed) {
code += "\t\t\tt." + ConvertCase(field.name, Case::kUpperCamel) + code += "\t\t\tt." + field_field + "[j].Pack(builder)\n";
"[j].Pack(builder)\n";
} else { } else {
code += "\t\t\tbuilder.PrependUOffsetT(" + offsets + "[j])\n"; code += "\t\t\tbuilder.PrependUOffsetT(" + offsets + "[j])\n";
} }
@@ -974,37 +983,33 @@ class GoGenerator : public BaseGenerator {
code += "\t}\n"; code += "\t}\n";
} else if (field.value.type.base_type == BASE_TYPE_STRUCT) { } else if (field.value.type.base_type == BASE_TYPE_STRUCT) {
if (field.value.type.struct_def->fixed) continue; if (field.value.type.struct_def->fixed) continue;
code += "\t" + offset + " := t." + code += "\t" + offset + " := t." + field_field + ".Pack(builder)\n";
ConvertCase(field.name, Case::kUpperCamel) + ".Pack(builder)\n";
} else if (field.value.type.base_type == BASE_TYPE_UNION) { } else if (field.value.type.base_type == BASE_TYPE_UNION) {
code += "\t" + offset + " := t." + code += "\t" + offset + " := t." + field_field + ".Pack(builder)\n";
ConvertCase(field.name, Case::kUpperCamel) + ".Pack(builder)\n";
code += "\t\n"; code += "\t\n";
} else { } else {
FLATBUFFERS_ASSERT(0); FLATBUFFERS_ASSERT(0);
} }
} }
code += "\t" + struct_def.name + "Start(builder)\n"; code += "\t" + struct_type + "Start(builder)\n";
for (auto it = struct_def.fields.vec.begin(); for (auto it = struct_def.fields.vec.begin();
it != struct_def.fields.vec.end(); ++it) { it != struct_def.fields.vec.end(); ++it) {
const FieldDef &field = **it; const FieldDef &field = **it;
if (field.deprecated) continue; if (field.deprecated) continue;
const std::string field_field = namer_.Field(field.name);
const std::string field_fn = namer_.Function(field.name);
const std::string offset = namer_.Variable(field.name) + "Offset";
std::string offset =
ConvertCase(field.name, Case::kLowerCamel) + "Offset";
if (IsScalar(field.value.type.base_type)) { if (IsScalar(field.value.type.base_type)) {
std::string prefix; std::string prefix;
if (field.IsScalarOptional()) { if (field.IsScalarOptional()) {
code += "\tif t." + ConvertCase(field.name, Case::kUpperCamel) + code += "\tif t." + field_field + " != nil {\n\t";
" != nil {\n\t";
prefix = "*"; prefix = "*";
} }
if (field.value.type.enum_def == nullptr || if (field.value.type.enum_def == nullptr ||
!field.value.type.enum_def->is_union) { !field.value.type.enum_def->is_union) {
code += "\t" + struct_def.name + "Add" + code += "\t" + struct_type + "Add" + field_fn + "(builder, " +
ConvertCase(field.name, Case::kUpperCamel) + "(builder, " + prefix + "t." + field_field + ")\n";
prefix + "t." + ConvertCase(field.name, Case::kUpperCamel) +
")\n";
} }
if (field.IsScalarOptional()) { if (field.IsScalarOptional()) {
code += "\t}\n"; code += "\t}\n";
@@ -1012,72 +1017,64 @@ class GoGenerator : public BaseGenerator {
} else { } else {
if (field.value.type.base_type == BASE_TYPE_STRUCT && if (field.value.type.base_type == BASE_TYPE_STRUCT &&
field.value.type.struct_def->fixed) { field.value.type.struct_def->fixed) {
code += "\t" + offset + " := t." + code += "\t" + offset + " := t." + field_field + ".Pack(builder)\n";
ConvertCase(field.name, Case::kUpperCamel) +
".Pack(builder)\n";
} else if (field.value.type.enum_def != nullptr && } else if (field.value.type.enum_def != nullptr &&
field.value.type.enum_def->is_union) { field.value.type.enum_def->is_union) {
code += "\tif t." + ConvertCase(field.name, Case::kUpperCamel) + code += "\tif t." + field_field + " != nil {\n";
" != nil {\n"; code += "\t\t" + struct_type + "Add" +
code += "\t\t" + struct_def.name + "Add" + namer_.Method(field.name + UnionTypeFieldSuffix()) +
ConvertCase(field.name + UnionTypeFieldSuffix(), "(builder, t." + field_field + ".Type)\n";
Case::kUpperCamel) +
"(builder, t." + ConvertCase(field.name, Case::kUpperCamel) +
".Type)\n";
code += "\t}\n"; code += "\t}\n";
} }
code += "\t" + struct_def.name + "Add" + code += "\t" + struct_type + "Add" + field_fn + "(builder, " + offset +
ConvertCase(field.name, Case::kUpperCamel) + "(builder, " + ")\n";
offset + ")\n";
} }
} }
code += "\treturn " + struct_def.name + "End(builder)\n"; code += "\treturn " + struct_type + "End(builder)\n";
code += "}\n\n"; code += "}\n\n";
} }
void GenNativeTableUnPack(const StructDef &struct_def, void GenNativeTableUnPack(const StructDef &struct_def,
std::string *code_ptr) { std::string *code_ptr) {
std::string &code = *code_ptr; std::string &code = *code_ptr;
const std::string struct_type = namer_.Type(struct_def.name);
code += "func (rcv *" + struct_def.name + ") UnPackTo(t *" + code += "func (rcv *" + struct_type + ") UnPackTo(t *" +
NativeName(struct_def) + ") {\n"; NativeName(struct_def) + ") {\n";
for (auto it = struct_def.fields.vec.begin(); for (auto it = struct_def.fields.vec.begin();
it != struct_def.fields.vec.end(); ++it) { it != struct_def.fields.vec.end(); ++it) {
const FieldDef &field = **it; const FieldDef &field = **it;
if (field.deprecated) continue; if (field.deprecated) continue;
std::string field_name_camel = ConvertCase(field.name, Case::kUpperCamel); const std::string field_field = namer_.Field(field.name);
std::string length = const std::string field_var = namer_.Variable(field.name);
ConvertCase(field.name, Case::kLowerCamel) + "Length"; const std::string length = field_var + "Length";
if (IsScalar(field.value.type.base_type)) { if (IsScalar(field.value.type.base_type)) {
if (field.value.type.enum_def != nullptr && if (field.value.type.enum_def != nullptr &&
field.value.type.enum_def->is_union) field.value.type.enum_def->is_union)
continue; continue;
code += code += "\tt." + field_field + " = rcv." + field_field + "()\n";
"\tt." + field_name_camel + " = rcv." + field_name_camel + "()\n";
} else if (IsString(field.value.type)) { } else if (IsString(field.value.type)) {
code += "\tt." + field_name_camel + " = string(rcv." + code += "\tt." + field_field + " = string(rcv." + field_field + "())\n";
field_name_camel + "())\n";
} else if (IsVector(field.value.type) && } else if (IsVector(field.value.type) &&
field.value.type.element == BASE_TYPE_UCHAR && field.value.type.element == BASE_TYPE_UCHAR &&
field.value.type.enum_def == nullptr) { field.value.type.enum_def == nullptr) {
code += "\tt." + field_name_camel + " = rcv." + field_name_camel + code += "\tt." + field_field + " = rcv." + field_field + "Bytes()\n";
"Bytes()\n";
} else if (IsVector(field.value.type)) { } else if (IsVector(field.value.type)) {
code += "\t" + length + " := rcv." + field_name_camel + "Length()\n"; code += "\t" + length + " := rcv." + field_field + "Length()\n";
code += "\tt." + field_name_camel + " = make(" + code += "\tt." + field_field + " = make(" +
NativeType(field.value.type) + ", " + length + ")\n"; NativeType(field.value.type) + ", " + length + ")\n";
code += "\tfor j := 0; j < " + length + "; j++ {\n"; code += "\tfor j := 0; j < " + length + "; j++ {\n";
if (field.value.type.element == BASE_TYPE_STRUCT) { if (field.value.type.element == BASE_TYPE_STRUCT) {
code += "\t\tx := " + code += "\t\tx := " +
WrapInNameSpaceAndTrack(*field.value.type.struct_def) + WrapInNameSpaceAndTrack(*field.value.type.struct_def) +
"{}\n"; "{}\n";
code += "\t\trcv." + field_name_camel + "(&x, j)\n"; code += "\t\trcv." + field_field + "(&x, j)\n";
} }
code += "\t\tt." + field_name_camel + "[j] = "; code += "\t\tt." + field_field + "[j] = ";
if (IsScalar(field.value.type.element)) { if (IsScalar(field.value.type.element)) {
code += "rcv." + field_name_camel + "(j)"; code += "rcv." + field_field + "(j)";
} else if (field.value.type.element == BASE_TYPE_STRING) { } else if (field.value.type.element == BASE_TYPE_STRING) {
code += "string(rcv." + field_name_camel + "(j))"; code += "string(rcv." + field_field + "(j))";
} else if (field.value.type.element == BASE_TYPE_STRUCT) { } else if (field.value.type.element == BASE_TYPE_STRUCT) {
code += "x.UnPack()"; code += "x.UnPack()";
} else { } else {
@@ -1087,17 +1084,15 @@ class GoGenerator : public BaseGenerator {
code += "\n"; code += "\n";
code += "\t}\n"; code += "\t}\n";
} else if (field.value.type.base_type == BASE_TYPE_STRUCT) { } else if (field.value.type.base_type == BASE_TYPE_STRUCT) {
code += "\tt." + field_name_camel + " = rcv." + field_name_camel + code +=
"(nil).UnPack()\n"; "\tt." + field_field + " = rcv." + field_field + "(nil).UnPack()\n";
} else if (field.value.type.base_type == BASE_TYPE_UNION) { } else if (field.value.type.base_type == BASE_TYPE_UNION) {
std::string field_table = const std::string field_table = field_var + "Table";
ConvertCase(field.name, Case::kLowerCamel) + "Table";
code += "\t" + field_table + " := flatbuffers.Table{}\n"; code += "\t" + field_table + " := flatbuffers.Table{}\n";
code += "\tif rcv." + ConvertCase(field.name, Case::kUpperCamel) + code += "\tif rcv." + namer_.Method(field.name) + "(&" + field_table +
"(&" + field_table + ") {\n"; ") {\n";
code += "\t\tt." + field_name_camel + " = rcv." + code += "\t\tt." + field_field + " = rcv." +
ConvertCase(field.name + UnionTypeFieldSuffix(), namer_.Method(field.name + UnionTypeFieldSuffix()) +
Case::kUpperCamel) +
"().UnPack(" + field_table + ")\n"; "().UnPack(" + field_table + ")\n";
code += "\t}\n"; code += "\t}\n";
} else { } else {
@@ -1106,7 +1101,7 @@ class GoGenerator : public BaseGenerator {
} }
code += "}\n\n"; code += "}\n\n";
code += "func (rcv *" + struct_def.name + ") UnPack() *" + code += "func (rcv *" + struct_type + ") UnPack() *" +
NativeName(struct_def) + " {\n"; NativeName(struct_def) + " {\n";
code += "\tif rcv == nil { return nil }\n"; code += "\tif rcv == nil { return nil }\n";
code += "\tt := &" + NativeName(struct_def) + "{}\n"; code += "\tt := &" + NativeName(struct_def) + "{}\n";
@@ -1121,7 +1116,7 @@ class GoGenerator : public BaseGenerator {
code += "func (t *" + NativeName(struct_def) + code += "func (t *" + NativeName(struct_def) +
") Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT {\n"; ") Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT {\n";
code += "\tif t == nil { return 0 }\n"; code += "\tif t == nil { return 0 }\n";
code += "\treturn Create" + struct_def.name + "(builder"; code += "\treturn Create" + namer_.Type(struct_def.name) + "(builder";
StructPackArgs(struct_def, "", code_ptr); StructPackArgs(struct_def, "", code_ptr);
code += ")\n"; code += ")\n";
code += "}\n"; code += "}\n";
@@ -1134,14 +1129,11 @@ class GoGenerator : public BaseGenerator {
it != struct_def.fields.vec.end(); ++it) { it != struct_def.fields.vec.end(); ++it) {
const FieldDef &field = **it; const FieldDef &field = **it;
if (field.value.type.base_type == BASE_TYPE_STRUCT) { if (field.value.type.base_type == BASE_TYPE_STRUCT) {
StructPackArgs( StructPackArgs(*field.value.type.struct_def,
*field.value.type.struct_def, (nameprefix + namer_.Field(field.name) + ".").c_str(),
(nameprefix + ConvertCase(field.name, Case::kUpperCamel) + ".") code_ptr);
.c_str(),
code_ptr);
} else { } else {
code += std::string(", t.") + nameprefix + code += std::string(", t.") + nameprefix + namer_.Field(field.name);
ConvertCase(field.name, Case::kUpperCamel);
} }
} }
} }
@@ -1150,23 +1142,22 @@ class GoGenerator : public BaseGenerator {
std::string *code_ptr) { std::string *code_ptr) {
std::string &code = *code_ptr; std::string &code = *code_ptr;
code += "func (rcv *" + struct_def.name + ") UnPackTo(t *" + code += "func (rcv *" + namer_.Type(struct_def.name) + ") UnPackTo(t *" +
NativeName(struct_def) + ") {\n"; NativeName(struct_def) + ") {\n";
for (auto it = struct_def.fields.vec.begin(); for (auto it = struct_def.fields.vec.begin();
it != struct_def.fields.vec.end(); ++it) { it != struct_def.fields.vec.end(); ++it) {
const FieldDef &field = **it; const FieldDef &field = **it;
if (field.value.type.base_type == BASE_TYPE_STRUCT) { if (field.value.type.base_type == BASE_TYPE_STRUCT) {
code += "\tt." + ConvertCase(field.name, Case::kUpperCamel) + code += "\tt." + namer_.Field(field.name) + " = rcv." +
" = rcv." + ConvertCase(field.name, Case::kUpperCamel) + namer_.Method(field.name) + "(nil).UnPack()\n";
"(nil).UnPack()\n";
} else { } else {
code += "\tt." + ConvertCase(field.name, Case::kUpperCamel) + code += "\tt." + namer_.Field(field.name) + " = rcv." +
" = rcv." + ConvertCase(field.name, Case::kUpperCamel) + "()\n"; namer_.Method(field.name) + "()\n";
} }
} }
code += "}\n\n"; code += "}\n\n";
code += "func (rcv *" + struct_def.name + ") UnPack() *" + code += "func (rcv *" + namer_.Type(struct_def.name) + ") UnPack() *" +
NativeName(struct_def) + " {\n"; NativeName(struct_def) + " {\n";
code += "\tif rcv == nil { return nil }\n"; code += "\tif rcv == nil { return nil }\n";
code += "\tt := &" + NativeName(struct_def) + "{}\n"; code += "\tt := &" + NativeName(struct_def) + "{}\n";
@@ -1215,16 +1206,14 @@ class GoGenerator : public BaseGenerator {
case BASE_TYPE_STRING: return "rcv._tab.ByteVector"; case BASE_TYPE_STRING: return "rcv._tab.ByteVector";
case BASE_TYPE_UNION: return "rcv._tab.Union"; case BASE_TYPE_UNION: return "rcv._tab.Union";
case BASE_TYPE_VECTOR: return GenGetter(type.VectorType()); case BASE_TYPE_VECTOR: return GenGetter(type.VectorType());
default: default: return "rcv._tab.Get" + namer_.Function(GenTypeBasic(type));
return "rcv._tab.Get" +
ConvertCase(GenTypeBasic(type), Case::kUpperCamel);
} }
} }
// Returns the method name for use with add/put calls. // Returns the method name for use with add/put calls.
std::string GenMethod(const FieldDef &field) { std::string GenMethod(const FieldDef &field) {
return IsScalar(field.value.type.base_type) return IsScalar(field.value.type.base_type)
? ConvertCase(GenTypeBasic(field.value.type), Case::kUpperCamel) ? namer_.Method(GenTypeBasic(field.value.type))
: (IsStruct(field.value.type) ? "Struct" : "UOffsetT"); : (IsStruct(field.value.type) ? "Struct" : "UOffsetT");
} }
@@ -1295,14 +1284,12 @@ class GoGenerator : public BaseGenerator {
} }
} }
std::string NativeName(const StructDef &struct_def) { std::string NativeName(const StructDef &struct_def) const {
return parser_.opts.object_prefix + struct_def.name + return namer_.ObjectType(struct_def.name);
parser_.opts.object_suffix;
} }
std::string NativeName(const EnumDef &enum_def) { std::string NativeName(const EnumDef &enum_def) const {
return parser_.opts.object_prefix + enum_def.name + return namer_.ObjectType(enum_def.name);
parser_.opts.object_suffix;
} }
std::string NativeType(const Type &type) { std::string NativeType(const Type &type) {
@@ -1379,34 +1366,20 @@ class GoGenerator : public BaseGenerator {
while (code.length() > 2 && code.substr(code.length() - 2) == "\n\n") { while (code.length() > 2 && code.substr(code.length() - 2) == "\n\n") {
code.pop_back(); code.pop_back();
} }
std::string filename = NamespaceDir(ns) + def.name + ".go"; std::string filename = namer_.Directories(ns.components) +
namer_.File(def.name, SkipFile::Suffix);
return SaveFile(filename.c_str(), code, false); return SaveFile(filename.c_str(), code, false);
} }
// Create the full name of the imported namespace (format: A__B__C). // Create the full name of the imported namespace (format: A__B__C).
std::string NamespaceImportName(const Namespace *ns) { std::string NamespaceImportName(const Namespace *ns) const {
std::string s = ""; return namer_.Namespace(ns->components);
for (auto it = ns->components.begin(); it != ns->components.end(); ++it) {
if (s.size() == 0) {
s += *it;
} else {
s += "__" + *it;
}
}
return s;
} }
// Create the full path for the imported namespace (format: A/B/C). // Create the full path for the imported namespace (format: A/B/C).
std::string NamespaceImportPath(const Namespace *ns) { std::string NamespaceImportPath(const Namespace *ns) const {
std::string s = ""; return namer_.Directories(ns->components,
for (auto it = ns->components.begin(); it != ns->components.end(); ++it) { SkipDir::OutputPathAndTrailingPathSeparator);
if (s.size() == 0) {
s += *it;
} else {
s += "/" + *it;
}
}
return s;
} }
// Ensure that a type is prefixed with its go package import name if it is // Ensure that a type is prefixed with its go package import name if it is
@@ -1416,9 +1389,7 @@ class GoGenerator : public BaseGenerator {
if (CurrentNameSpace() == ns) return name; if (CurrentNameSpace() == ns) return name;
tracked_imported_namespaces_.insert(ns); tracked_imported_namespaces_.insert(ns);
return NamespaceImportName(ns) + "." + name;
std::string import_name = NamespaceImportName(ns);
return import_name + "." + name;
} }
std::string WrapInNameSpaceAndTrack(const Definition &def) { std::string WrapInNameSpaceAndTrack(const Definition &def) {

26
src/namer.h
View File

@@ -16,6 +16,18 @@ enum class SkipFile {
inline SkipFile operator&(SkipFile a, SkipFile b) { inline SkipFile operator&(SkipFile a, SkipFile b) {
return static_cast<SkipFile>(static_cast<int>(a) & static_cast<int>(b)); return static_cast<SkipFile>(static_cast<int>(a) & static_cast<int>(b));
} }
// Options for Namer::Directories
enum class SkipDir {
None = 0,
// Skip prefixing the -o $output_path.
OutputPath = 1,
// Skip trailing path seperator.
TrailingPathSeperator = 2,
OutputPathAndTrailingPathSeparator = 3,
};
inline SkipDir operator&(SkipDir a, SkipDir b) {
return static_cast<SkipDir>(static_cast<int>(a) & static_cast<int>(b));
}
// `Namer` applies style configuration to symbols in generated code. It manages // `Namer` applies style configuration to symbols in generated code. It manages
// casing, escapes keywords, and object API naming. // casing, escapes keywords, and object API naming.
@@ -163,14 +175,22 @@ class Namer {
(skip_suffix ? "" : config_.filename_suffix) + (skip_suffix ? "" : config_.filename_suffix) +
(skip_ext ? "" : config_.filename_extension); (skip_ext ? "" : config_.filename_extension);
} }
// Formats `directories` and returns a filepath with the right seperator. // Formats `directories` prefixed with the output_path and joined with the
// right seperator. Output path prefixing and the trailing separator may be
// skiped using `skips`.
// Callers may want to use `EnsureDirExists` with the result. // Callers may want to use `EnsureDirExists` with the result.
std::string Directories(const std::vector<std::string> &directories) const { std::string Directories(const std::vector<std::string> &directories,
std::string result = config_.output_path; SkipDir skips = SkipDir::None) const {
const bool skip_output_path =
(skips & SkipDir::OutputPath) != SkipDir::None;
const bool skip_trailing_seperator =
(skips & SkipDir::TrailingPathSeperator) != SkipDir::None;
std::string result = skip_output_path ? "" : config_.output_path;
for (auto d = directories.begin(); d != directories.end(); d++) { for (auto d = directories.begin(); d != directories.end(); d++) {
result += ConvertCase(*d, config_.directories, Case::kUpperCamel); result += ConvertCase(*d, config_.directories, Case::kUpperCamel);
result.push_back(kPathSeparator); result.push_back(kPathSeparator);
} }
if (skip_trailing_seperator) result.pop_back();
return result; return result;
} }