Merge remote-tracking branch 'refs/remotes/google/master'

docs/source/CppUsage.md

@@ -103,7 +103,7 @@ To use:
     cout << monsterobj->name;  // This is now a std::string!
     monsterobj->name = "Bob";  // Change the name.
     FlatBufferBuilder fbb;
-    CreateMonster(fbb, monsterobj->get());     // Serialize into new buffer.
+    CreateMonster(fbb, monsterobj.get());     // Serialize into new buffer.
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
 ## Reflection (& Resizing)

include/flatbuffers/idl.h

@@ -347,6 +347,7 @@ struct IDLOptions {
   bool generate_name_strings;
   bool escape_proto_identifiers;
   bool generate_object_based_api;
+  bool union_value_namespacing;
 
   // Possible options for the more general generator below.
   enum Language { kJava, kCSharp, kGo, kMAX };
@@ -368,6 +369,7 @@ struct IDLOptions {
       generate_name_strings(false),
       escape_proto_identifiers(false),
       generate_object_based_api(false),
+      union_value_namespacing(true),
       lang(IDLOptions::kJava) {}
 };
 

src/flatc.cpp

@@ -195,6 +195,8 @@ int main(int argc, const char *argv[]) {
       } else if(arg == "--scoped-enums") {
         opts.prefixed_enums = false;
         opts.scoped_enums = true;
+      } else if (arg == "--no-union-value-namespacing") {
+        opts.union_value_namespacing = false;
       } else if(arg == "--gen-mutable") {
         opts.mutable_buffer = true;
       } else if(arg == "--gen-name-strings") {

src/idl_gen_cpp.cpp

@@ -975,8 +975,10 @@ class CppGenerator : public BaseGenerator {
                   if (invector) {
                     return "*" + val;
                   } else {
-                    return "std::unique_ptr<" + type.struct_def->name +
-                           ">(new " + type.struct_def->name + "(*" + val + "))";
+                    return "std::unique_ptr<" +
+                           WrapInNameSpace (*type.struct_def) +
+                           ">(new " +
+                           WrapInNameSpace (*type.struct_def) + "(*" + val + "))";
                   }
                 } else {
                   return val + "->UnPack()";

src/idl_gen_js.cpp

@@ -79,7 +79,7 @@ class JsGenerator : public BaseGenerator {
     for (auto it = parser_.structs_.vec.begin();
          it != parser_.structs_.vec.end(); ++it) {
       auto &struct_def = **it;
-      GenStruct(struct_def, decl_code_ptr, exports_code_ptr);
+      GenStruct(parser_, struct_def, decl_code_ptr, exports_code_ptr);
     }
   }
   void GenNamespaces(std::string *code_ptr, std::string *exports_ptr) {
@@ -361,7 +361,7 @@ static void GenStructBody(const StructDef &struct_def,
 }
 
 // Generate an accessor struct with constructor for a flatbuffers struct.
-void GenStruct(StructDef &struct_def, std::string *code_ptr, std::string *exports_ptr) {
+void GenStruct(const Parser &parser, StructDef &struct_def, std::string *code_ptr, std::string *exports_ptr) {
   if (struct_def.generated) return;
   std::string &code = *code_ptr;
   std::string &exports = *exports_ptr;
@@ -550,6 +550,22 @@ void GenStruct(StructDef &struct_def, std::string *code_ptr, std::string *export
     }
     code += "};\n\n";
 
+    // Adds the mutable scalar value to the output
+    if (IsScalar(field.value.type.base_type) && parser.opts.mutable_buffer) {
+      std::string annotations = "@param {" + GenTypeName(field.value.type, true) + "} value\n";
+      GenDocComment(code_ptr, annotations +
+        "@returns {boolean}");
+
+      code += object_name + ".prototype.mutate_" + field.name + " = function(value) {\n";
+      code += "  var offset = this.bb.__offset(this.bb_pos, " + NumToString(field.value.offset) + ")\n\n";
+      code += "  if (offset === 0) {\n";
+      code += "    return false;\n";
+      code += "  }\n\n";
+      code += "  this.bb.write" + MakeCamel(GenType(field.value.type)) + "(this.bb_pos + offset, value);\n";
+      code += "  return true;\n";
+      code += "}\n\n";
+    }
+
     // Emit vector helpers
     if (field.value.type.base_type == BASE_TYPE_VECTOR) {
       // Emit a length helper

src/idl_parser.cpp

@@ -1216,10 +1216,12 @@ CheckedError Parser::ParseEnum(bool is_union, EnumDef **dest) {
       EXPECT(kTokenIdentifier);
       if (is_union) {
         ECHECK(ParseNamespacing(&full_name, &value_name));
-        // Since we can't namespace the actual enum identifiers, turn
-        // namespace parts into part of the identifier.
-        value_name = full_name;
-        std::replace(value_name.begin(), value_name.end(), '.', '_');
+        if (opts.union_value_namespacing) {
+          // Since we can't namespace the actual enum identifiers, turn
+          // namespace parts into part of the identifier.
+          value_name = full_name;
+          std::replace(value_name.begin(), value_name.end(), '.', '_');
+        }
       }
       auto prevsize = enum_def.vals.vec.size();
       auto value = enum_def.vals.vec.size()

tests/JavaScriptTest.js

@@ -64,7 +64,10 @@ function main() {
 
   fs.writeFileSync('monsterdata_javascript_wire.mon', new Buffer(fbb.asUint8Array()));
 
-  // Test it:
+  // Tests mutation first.  This will verify that we did not trample any other
+  // part of the byte buffer.
+  testMutation(fbb.dataBuffer());
+  
   testBuffer(fbb.dataBuffer());
 
   test64bit();
@@ -74,6 +77,21 @@ function main() {
   console.log('FlatBuffers test: completed successfully');
 }
 
+function testMutation(bb) {
+  var monster = MyGame.Example.Monster.getRootAsMonster(bb);
+
+  monster.mutate_hp(120);
+  assert.strictEqual(monster.hp(), 120);
+
+  monster.mutate_hp(80);
+  assert.strictEqual(monster.hp(), 80);
+
+  var manaRes = monster.mutate_mana(10);
+  assert.strictEqual(manaRes, false);  // Field was NOT present, because default value.
+
+  // TODO: There is not the availability to mutate structs or vectors.
+}
+
 function testBuffer(bb) {
   assert.ok(MyGame.Example.Monster.bufferHasIdentifier(bb));
 

tests/namespace_test/namespace_test1_generated.js

@@ -64,6 +64,21 @@ NamespaceA.NamespaceB.TableInNestedNS.prototype.foo = function() {
   return offset ? this.bb.readInt32(this.bb_pos + offset) : 0;
 };
 
+/**
+ * @param {number} value
+ * @returns {boolean}
+ */
+NamespaceA.NamespaceB.TableInNestedNS.prototype.mutate_foo = function(value) {
+  var offset = this.bb.__offset(this.bb_pos, 4)
+
+  if (offset === 0) {
+    return false;
+  }
+
+  this.bb.writeInt32(this.bb_pos + offset, value);
+  return true;
+}
+
 /**
  * @param {flatbuffers.Builder} builder
  */
@@ -121,6 +136,21 @@ NamespaceA.NamespaceB.StructInNestedNS.prototype.a = function() {
   return this.bb.readInt32(this.bb_pos);
 };
 
+/**
+ * @param {number} value
+ * @returns {boolean}
+ */
+NamespaceA.NamespaceB.StructInNestedNS.prototype.mutate_a = function(value) {
+  var offset = this.bb.__offset(this.bb_pos, 0)
+
+  if (offset === 0) {
+    return false;
+  }
+
+  this.bb.writeInt32(this.bb_pos + offset, value);
+  return true;
+}
+
 /**
  * @returns {number}
  */
@@ -128,6 +158,21 @@ NamespaceA.NamespaceB.StructInNestedNS.prototype.b = function() {
   return this.bb.readInt32(this.bb_pos + 4);
 };
 
+/**
+ * @param {number} value
+ * @returns {boolean}
+ */
+NamespaceA.NamespaceB.StructInNestedNS.prototype.mutate_b = function(value) {
+  var offset = this.bb.__offset(this.bb_pos, 4)
+
+  if (offset === 0) {
+    return false;
+  }
+
+  this.bb.writeInt32(this.bb_pos + offset, value);
+  return true;
+}
+
 /**
  * @param {flatbuffers.Builder} builder
  * @param {number} a

tests/namespace_test/namespace_test2_generated.js

@@ -70,6 +70,21 @@ NamespaceA.TableInFirstNS.prototype.fooEnum = function() {
   return offset ? /** @type {NamespaceA.NamespaceB.EnumInNestedNS} */ (this.bb.readInt8(this.bb_pos + offset)) : NamespaceA.NamespaceB.EnumInNestedNS.A;
 };
 
+/**
+ * @param {NamespaceA.NamespaceB.EnumInNestedNS} value
+ * @returns {boolean}
+ */
+NamespaceA.TableInFirstNS.prototype.mutate_foo_enum = function(value) {
+  var offset = this.bb.__offset(this.bb_pos, 6)
+
+  if (offset === 0) {
+    return false;
+  }
+
+  this.bb.writeInt8(this.bb_pos + offset, value);
+  return true;
+}
+
 /**
  * @param {NamespaceA.NamespaceB.StructInNestedNS=} obj
  * @returns {NamespaceA.NamespaceB.StructInNestedNS}