Resolve #4530: Added string and struct union support

Author: surculus12

python/flatbuffers/table.py

@@ -53,6 +53,13 @@ def String(self, off):
         length = encode.Get(N.UOffsetTFlags.packer_type, self.Bytes, off)
         return bytes(self.Bytes[start:start+length])
 
+    def UnionString(self, off):
+        """String gets a string from data stored inside the flatbuffer."""
+        N.enforce_number(off, N.UOffsetTFlags)
+        start = off + N.UOffsetTFlags.bytewidth
+        length = encode.Get(N.UOffsetTFlags.packer_type, self.Bytes, off)
+        return bytes(self.Bytes[start:start+length])
+
     def VectorLen(self, off):
         """VectorLen retrieves the length of the vector whose offset is stored
            at "off" in this object."""

src/idl_gen_python.cpp

@@ -1078,8 +1078,8 @@ class PythonGenerator : public BaseGenerator {
 
   // Get the value of a vector's union member.
   void GetMemberOfVectorOfUnion(const StructDef &struct_def,
-    const FieldDef &field,
-    std::string *code_ptr) const {
+                                const FieldDef &field,
+                                std::string *code_ptr) const {
     auto &code = *code_ptr;
     auto vectortype = field.value.type.VectorType();
 
@@ -1092,17 +1092,8 @@ class PythonGenerator : public BaseGenerator {
     code += NumToString(InlineSize(vectortype)) + "\n";
     code += Indent + Indent + Indent;
     code += "x -= self._tab.Pos\n";
-
-    // TODO(rw): this works and is not the good way to it:
-    bool is_native_table = TypeName(field) == "*flatbuffers.Table";
-    if (is_native_table) {
     code +=
-    Indent + Indent + Indent + "from flatbuffers.table import Table\n";
-    } else if (parser_.opts.include_dependence_headers) {
-    code += Indent + Indent + Indent;
-    code += "from " + GenPackageReference(field.value.type) + " import " +
-    TypeName(field) + "\n";
-    }
+        Indent + Indent + Indent + "from flatbuffers.table import Table\n";
     code += Indent + Indent + Indent + "obj = Table(bytearray(), 0)\n";
     code += Indent + Indent + Indent + GenGetter(field.value.type);
     code += "obj, x)\n" + Indent + Indent + Indent + "return obj\n";
@@ -2543,7 +2534,7 @@ class PythonGenerator : public BaseGenerator {
     code +=
         GenIndents(1) + "if unionType == " + union_type + "()." + variant + ":";
     code += GenIndents(2) + "tab = Table(table.Bytes, table.Pos)";
-    code += GenIndents(2) + "union = tab.String(table.Pos)";
+    code += GenIndents(2) + "union = tab.UnionString(table.Pos)";
     code += GenIndents(2) + "return union";
   }
 

src/idl_parser.cpp

@@ -2699,6 +2699,10 @@ bool Parser::SupportsDefaultVectorsAndStrings() const {
 }
 
 bool Parser::SupportsAdvancedUnionFeatures() const {
+  // Advanced Union Features refers to the following features:
+  //    - Vectors of unions
+  //    - Strings in unions
+  //    - structs in unions
   return (opts.lang_to_generate &
           ~(IDLOptions::kCpp | IDLOptions::kTs | IDLOptions::kPhp |
             IDLOptions::kJava | IDLOptions::kCSharp | IDLOptions::kKotlin |

tests/py_test.py

@@ -58,6 +58,8 @@
 import union_vector.Attacker
 import union_vector.Character
 import union_vector.Movie
+import union_vector.Rapunzel
+import union_vector.BookReader
 
 
 def create_namespace_shortcut(is_onefile):
@@ -308,27 +310,41 @@ def test_default_values_with_pack_and_unpack(self):
   def test_union_vectors_with_pack_and_unpack(self):
     b = flatbuffers.Builder(0)
 
+    # Types of the characters
+    types = [
+      union_vector.Character.Character.MuLan,
+      union_vector.Character.Character.Rapunzel,
+      union_vector.Character.Character.Belle,
+      union_vector.Character.Character.BookFan,
+      union_vector.Character.Character.Other,
+      union_vector.Character.Character.Unused,
+    ]
+    # Pack the attacker manually
     union_vector.Attacker.Start(b)
     union_vector.Attacker.AddSwordAttackDamage(b, 1)
     attacker_offset = union_vector.Attacker.End(b)
-
-    union_vector.Attacker.Start(b)
-    union_vector.Attacker.AddSwordAttackDamage(b, 2)
-    attacker_offset2 = union_vector.Attacker.End(b)
-
-    characters = [attacker_offset, attacker_offset2]
-    character_types = [union_vector.Character.Character.MuLan, union_vector.Character.Character.MuLan]
-
-    union_vector.Movie.StartCharactersTypeVector(b, len(character_types))
-    for character_type in reversed(character_types):
+    # Prepare the rest of the characters
+    characters = [
+      attacker_offset,
+      union_vector.Rapunzel.CreateRapunzel(b, 2),
+      union_vector.BookReader.CreateBookReader(b, 3),
+      union_vector.BookReader.CreateBookReader(b, 4),
+      b.CreateString("Other", "utf-8"),
+      b.CreateString("Unused", "utf-8")
+    ]
+
+    # Pack the types
+    union_vector.Movie.StartCharactersTypeVector(b, len(types))
+    for character_type in reversed(types):
       b.PrependByte(character_type)
     character_types_offset = b.EndVector()
-
+    # Pack the characters
     union_vector.Movie.StartCharactersVector(b, len(characters))
     for character in reversed(characters):
       b.PrependUOffsetTRelative(character)
     characters_offset = b.EndVector()
 
+    # Pack the movie object
     union_vector.Movie.Start(b)
     union_vector.Movie.AddMainCharacterType(b, 0)
     union_vector.Movie.AddMainCharacter(b, 0)
@@ -337,18 +353,39 @@ def test_union_vectors_with_pack_and_unpack(self):
     movie_offset = union_vector.Movie.End(b)
     b.Finish(movie_offset)
 
+    # Unpack the movie object
     buf = b.Output()
     movie = union_vector.Movie.Movie.GetRootAsMovie(buf, 0)
 
-    self.assertEqual(movie.CharactersTypeLength(), len(character_types))
-    self.assertEqual(movie.CharactersLength(), len(characters))
-    self.assertEqual(movie.CharactersType(0), character_types[0])
-
-    character = union_vector.Attacker.Attacker()
-    character.Init(movie.Characters(0).Bytes, movie.Characters(0).Pos)
-    self.assertEqual(character.SwordAttackDamage(), 1)
-    character.Init(movie.Characters(1).Bytes, movie.Characters(1).Pos)
-    self.assertEqual(character.SwordAttackDamage(), 2)
+    self.assertEqual(movie.CharactersType(0), union_vector.Character.Character.MuLan)
+    self.assertEqual(movie.CharactersType(1), union_vector.Character.Character.Rapunzel)
+    self.assertEqual(movie.CharactersType(2), union_vector.Character.Character.Belle)
+    self.assertEqual(movie.CharactersType(3), union_vector.Character.Character.BookFan)
+    self.assertEqual(movie.CharactersType(4), union_vector.Character.Character.Other)
+    self.assertEqual(movie.CharactersType(5), union_vector.Character.Character.Unused)
+
+    attacker = union_vector.Attacker.Attacker()
+    attacker.Init(movie.Characters(0).Bytes, movie.Characters(0).Pos)
+    self.assertEqual(attacker.SwordAttackDamage(), 1)
+    rapunzel = union_vector.Rapunzel.Rapunzel()
+    rapunzel.Init(movie.Characters(1).Bytes, movie.Characters(1).Pos)
+    self.assertEqual(rapunzel.HairLength(), 2)
+    book_reader = union_vector.BookReader.BookReader()
+    book_reader.Init(movie.Characters(2).Bytes, movie.Characters(2).Pos)
+    self.assertEqual(book_reader.BooksRead(), 3)
+    book_reader.Init(movie.Characters(3).Bytes, movie.Characters(3).Pos)
+    self.assertEqual(book_reader.BooksRead(), 4)
+
+    other = union_vector.Character.CharacterCreator(
+      union_vector.Character.Character.Other,
+      movie.Characters(4)
+    )
+    self.assertEqual(other.decode("utf-8"), "Other")
+    unused = union_vector.Character.CharacterCreator(
+      union_vector.Character.Character.Unused,
+      movie.Characters(5)
+    )
+    self.assertEqual(unused.decode("utf-8"), "Unused")
 
   def test_optional_scalars_with_pack_and_unpack(self):
     """ Serializes and deserializes between a buffer with optional values (no

tests/union_vector/Character.py

@@ -29,10 +29,10 @@ def CharacterCreator(unionType, table):
         return BookReader.BookReaderT.InitFromBuf(table.Bytes, table.Pos)
     if unionType == Character().Other:
         tab = Table(table.Bytes, table.Pos)
-        union = tab.String(table.Pos)
+        union = tab.UnionString(table.Pos)
         return union
     if unionType == Character().Unused:
         tab = Table(table.Bytes, table.Pos)
-        union = tab.String(table.Pos)
+        union = tab.UnionString(table.Pos)
         return union
     return None