Fixed vectors of enums in object API serialized incorrectly.

And also added tests for them. Change-Id: I91af1904105435601287291412e82d5066f476a5 Tested: on Linux.
2026-06-02 04:04:19 +00:00 · 2018-11-05 14:33:36 -08:00
parent 21591916af
commit 980a6d66d3
18 changed files with 368 additions and 27 deletions
--- a/include/flatbuffers/flatbuffers.h
+++ b/include/flatbuffers/flatbuffers.h
@@ -1731,6 +1731,19 @@ class FlatBufferBuilder {
                                     reinterpret_cast<uint8_t **>(buf));
  }

+
+  // @brief Create a vector of scalar type T given as input a vector of scalar
+  // type U, useful with e.g. pre "enum class" enums, or any existing scalar
+  // data of the wrong type.
+  template<typename T, typename U>
+  Offset<Vector<T>> CreateVectorScalarCast(const U *v, size_t len) {
+    AssertScalarT<T>();
+    AssertScalarT<U>();
+    StartVector(len, sizeof(T));
+    for (auto i = len; i > 0;) { PushElement(static_cast<T>(v[--i])); }
+    return Offset<Vector<T>>(EndVector(len));
+  }
+
  /// @brief Write a struct by itself, typically to be part of a union.
  template<typename T> Offset<const T *> CreateStruct(const T &structobj) {
    NotNested();
--- a/src/idl_gen_cpp.cpp
+++ b/src/idl_gen_cpp.cpp
@@ -1538,7 +1538,7 @@ class CppGenerator : public BaseGenerator {
      cmp_rhs = "rhs";
      compare_op = "  return\n      " + compare_op + ";";
    }
-    
+
    code_.SetValue("CMP_OP", compare_op);
    code_.SetValue("CMP_LHS", cmp_lhs);
    code_.SetValue("CMP_RHS", cmp_rhs);
@@ -2363,7 +2363,7 @@ class CppGenerator : public BaseGenerator {
              // the underlying storage type (eg. uint8_t).
              const auto basetype = GenTypeBasic(
                  field.value.type.enum_def->underlying_type, false);
-              code += "_fbb.CreateVector((const " + basetype + "*)" + value +
+              code += "_fbb.CreateVectorScalarCast<" + basetype + ">(" + value +
                      ".data(), " + value + ".size())";
            } else if (field.attributes.Lookup("cpp_type")) {
              auto type = GenTypeBasic(vector_type, false);
--- a/tests/MyGame/Example/Monster.cs
+++ b/tests/MyGame/Example/Monster.cs
@@ -178,8 +178,17 @@ public struct Monster : IFlatbufferObject
  public AnyAmbiguousAliases AnyAmbiguousType { get { int o = __p.__offset(94); return o != 0 ? (AnyAmbiguousAliases)__p.bb.Get(o + __p.bb_pos) : AnyAmbiguousAliases.NONE; } }
  public bool MutateAnyAmbiguousType(AnyAmbiguousAliases any_ambiguous_type) { int o = __p.__offset(94); if (o != 0) { __p.bb.Put(o + __p.bb_pos, (byte)any_ambiguous_type); return true; } else { return false; } }
  public TTable? AnyAmbiguous<TTable>() where TTable : struct, IFlatbufferObject { int o = __p.__offset(96); return o != 0 ? (TTable?)__p.__union<TTable>(o) : null; }
+  public Color VectorOfEnums(int j) { int o = __p.__offset(98); return o != 0 ? (Color)__p.bb.GetSbyte(__p.__vector(o) + j * 1) : (Color)0; }
+  public int VectorOfEnumsLength { get { int o = __p.__offset(98); return o != 0 ? __p.__vector_len(o) : 0; } }
+#if ENABLE_SPAN_T
+  public Span<byte> GetVectorOfEnumsBytes() { return __p.__vector_as_span(98); }
+#else
+  public ArraySegment<byte>? GetVectorOfEnumsBytes() { return __p.__vector_as_arraysegment(98); }
+#endif
+  public Color[] GetVectorOfEnumsArray() { return __p.__vector_as_array<Color>(98); }
+  public bool MutateVectorOfEnums(int j, Color vector_of_enums) { int o = __p.__offset(98); if (o != 0) { __p.bb.PutSbyte(__p.__vector(o) + j * 1, (sbyte)vector_of_enums); return true; } else { return false; } }

-  public static void StartMonster(FlatBufferBuilder builder) { builder.StartObject(47); }
+  public static void StartMonster(FlatBufferBuilder builder) { builder.StartObject(48); }
  public static void AddPos(FlatBufferBuilder builder, Offset<Vec3> posOffset) { builder.AddStruct(0, posOffset.Value, 0); }
  public static void AddMana(FlatBufferBuilder builder, short mana) { builder.AddShort(1, mana, 150); }
  public static void AddHp(FlatBufferBuilder builder, short hp) { builder.AddShort(2, hp, 100); }
@@ -271,6 +280,10 @@ public struct Monster : IFlatbufferObject
  public static void AddAnyUnique(FlatBufferBuilder builder, int anyUniqueOffset) { builder.AddOffset(44, anyUniqueOffset, 0); }
  public static void AddAnyAmbiguousType(FlatBufferBuilder builder, AnyAmbiguousAliases anyAmbiguousType) { builder.AddByte(45, (byte)anyAmbiguousType, 0); }
  public static void AddAnyAmbiguous(FlatBufferBuilder builder, int anyAmbiguousOffset) { builder.AddOffset(46, anyAmbiguousOffset, 0); }
+  public static void AddVectorOfEnums(FlatBufferBuilder builder, VectorOffset vectorOfEnumsOffset) { builder.AddOffset(47, vectorOfEnumsOffset.Value, 0); }
+  public static VectorOffset CreateVectorOfEnumsVector(FlatBufferBuilder builder, Color[] data) { builder.StartVector(1, data.Length, 1); for (int i = data.Length - 1; i >= 0; i--) builder.AddSbyte((sbyte)data[i]); return builder.EndVector(); }
+  public static VectorOffset CreateVectorOfEnumsVectorBlock(FlatBufferBuilder builder, Color[] data) { builder.StartVector(1, data.Length, 1); builder.Add(data); return builder.EndVector(); }
+  public static void StartVectorOfEnumsVector(FlatBufferBuilder builder, int numElems) { builder.StartVector(1, numElems, 1); }
  public static Offset<Monster> EndMonster(FlatBufferBuilder builder) {
    int o = builder.EndObject();
    builder.Required(o, 10);  // name
--- a/tests/MyGame/Example/Monster.go
+++ b/tests/MyGame/Example/Monster.go
@@ -698,8 +698,25 @@ func (rcv *Monster) AnyAmbiguous(obj *flatbuffers.Table) bool {
 	return false
 }

+func (rcv *Monster) VectorOfEnums(j int) Color {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(98))
+	if o != 0 {
+		a := rcv._tab.Vector(o)
+		return rcv._tab.GetInt8(a + flatbuffers.UOffsetT(j*1))
+	}
+	return 0
+}
+
+func (rcv *Monster) VectorOfEnumsLength() int {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(98))
+	if o != 0 {
+		return rcv._tab.VectorLen(o)
+	}
+	return 0
+}
+
 func MonsterStart(builder *flatbuffers.Builder) {
-	builder.StartObject(47)
+	builder.StartObject(48)
 }
 func MonsterAddPos(builder *flatbuffers.Builder, pos flatbuffers.UOffsetT) {
 	builder.PrependStructSlot(0, flatbuffers.UOffsetT(pos), 0)
@@ -890,6 +907,12 @@ func MonsterAddAnyAmbiguousType(builder *flatbuffers.Builder, anyAmbiguousType b
 func MonsterAddAnyAmbiguous(builder *flatbuffers.Builder, anyAmbiguous flatbuffers.UOffsetT) {
 	builder.PrependUOffsetTSlot(46, flatbuffers.UOffsetT(anyAmbiguous), 0)
 }
+func MonsterAddVectorOfEnums(builder *flatbuffers.Builder, vectorOfEnums flatbuffers.UOffsetT) {
+	builder.PrependUOffsetTSlot(47, flatbuffers.UOffsetT(vectorOfEnums), 0)
+}
+func MonsterStartVectorOfEnumsVector(builder *flatbuffers.Builder, numElems int) flatbuffers.UOffsetT {
+	return builder.StartVector(1, numElems, 1)
+}
 func MonsterEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT {
 	return builder.EndObject()
 }
--- a/tests/MyGame/Example/Monster.java
+++ b/tests/MyGame/Example/Monster.java
@@ -152,8 +152,13 @@ public final class Monster extends Table {
  public byte anyAmbiguousType() { int o = __offset(94); return o != 0 ? bb.get(o + bb_pos) : 0; }
  public boolean mutateAnyAmbiguousType(byte any_ambiguous_type) { int o = __offset(94); if (o != 0) { bb.put(o + bb_pos, any_ambiguous_type); return true; } else { return false; } }
  public Table anyAmbiguous(Table obj) { int o = __offset(96); return o != 0 ? __union(obj, o) : null; }
+  public byte vectorOfEnums(int j) { int o = __offset(98); return o != 0 ? bb.get(__vector(o) + j * 1) : 0; }
+  public int vectorOfEnumsLength() { int o = __offset(98); return o != 0 ? __vector_len(o) : 0; }
+  public ByteBuffer vectorOfEnumsAsByteBuffer() { return __vector_as_bytebuffer(98, 1); }
+  public ByteBuffer vectorOfEnumsInByteBuffer(ByteBuffer _bb) { return __vector_in_bytebuffer(_bb, 98, 1); }
+  public boolean mutateVectorOfEnums(int j, byte vector_of_enums) { int o = __offset(98); if (o != 0) { bb.put(__vector(o) + j * 1, vector_of_enums); return true; } else { return false; } }

-  public static void startMonster(FlatBufferBuilder builder) { builder.startObject(47); }
+  public static void startMonster(FlatBufferBuilder builder) { builder.startObject(48); }
  public static void addPos(FlatBufferBuilder builder, int posOffset) { builder.addStruct(0, posOffset, 0); }
  public static void addMana(FlatBufferBuilder builder, short mana) { builder.addShort(1, mana, 150); }
  public static void addHp(FlatBufferBuilder builder, short hp) { builder.addShort(2, hp, 100); }
@@ -231,6 +236,9 @@ public final class Monster extends Table {
  public static void addAnyUnique(FlatBufferBuilder builder, int anyUniqueOffset) { builder.addOffset(44, anyUniqueOffset, 0); }
  public static void addAnyAmbiguousType(FlatBufferBuilder builder, byte anyAmbiguousType) { builder.addByte(45, anyAmbiguousType, 0); }
  public static void addAnyAmbiguous(FlatBufferBuilder builder, int anyAmbiguousOffset) { builder.addOffset(46, anyAmbiguousOffset, 0); }
+  public static void addVectorOfEnums(FlatBufferBuilder builder, int vectorOfEnumsOffset) { builder.addOffset(47, vectorOfEnumsOffset, 0); }
+  public static int createVectorOfEnumsVector(FlatBufferBuilder builder, byte[] data) { builder.startVector(1, data.length, 1); for (int i = data.length - 1; i >= 0; i--) builder.addByte(data[i]); return builder.endVector(); }
+  public static void startVectorOfEnumsVector(FlatBufferBuilder builder, int numElems) { builder.startVector(1, numElems, 1); }
  public static int endMonster(FlatBufferBuilder builder) {
    int o = builder.endObject();
    builder.required(o, 10);  // name
--- a/tests/MyGame/Example/Monster.lua
+++ b/tests/MyGame/Example/Monster.lua
@@ -507,7 +507,22 @@ function Monster_mt:AnyAmbiguous()
        return obj
    end
 end
-function Monster.Start(builder) builder:StartObject(47) end
+function Monster_mt:VectorOfEnums(j)
+    local o = self.view:Offset(98)
+    if o ~= 0 then
+        local a = self.view:Vector(o)
+        return self.view:Get(flatbuffers.N.Int8, a + ((j-1) * 1))
+    end
+    return 0
+end
+function Monster_mt:VectorOfEnumsLength()
+    local o = self.view:Offset(98)
+    if o ~= 0 then
+        return self.view:VectorLen(o)
+    end
+    return 0
+end
+function Monster.Start(builder) builder:StartObject(48) end
 function Monster.AddPos(builder, pos) builder:PrependStructSlot(0, pos, 0) end
 function Monster.AddMana(builder, mana) builder:PrependInt16Slot(1, mana, 150) end
 function Monster.AddHp(builder, hp) builder:PrependInt16Slot(2, hp, 100) end
@@ -571,6 +586,8 @@ function Monster.AddAnyUniqueType(builder, anyUniqueType) builder:PrependUint8Sl
 function Monster.AddAnyUnique(builder, anyUnique) builder:PrependUOffsetTRelativeSlot(44, anyUnique, 0) end
 function Monster.AddAnyAmbiguousType(builder, anyAmbiguousType) builder:PrependUint8Slot(45, anyAmbiguousType, 0) end
 function Monster.AddAnyAmbiguous(builder, anyAmbiguous) builder:PrependUOffsetTRelativeSlot(46, anyAmbiguous, 0) end
+function Monster.AddVectorOfEnums(builder, vectorOfEnums) builder:PrependUOffsetTRelativeSlot(47, vectorOfEnums, 0) end
+function Monster.StartVectorOfEnumsVector(builder, numElems) return builder:StartVector(1, numElems, 1) end
 function Monster.End(builder) return builder:EndObject() end

 return Monster -- return the module
--- a/tests/MyGame/Example/Monster.php
+++ b/tests/MyGame/Example/Monster.php
@@ -647,22 +647,41 @@ class Monster extends Table
        return $o != 0 ? $this->__union($obj, $o) : null;
    }

+    /**
+     * @param int offset
+     * @return sbyte
+     */
+    public function getVectorOfEnums($j)
+    {
+        $o = $this->__offset(98);
+        return $o != 0 ? $this->bb->getSbyte($this->__vector($o) + $j * 1) : 0;
+    }
+
+    /**
+     * @return int
+     */
+    public function getVectorOfEnumsLength()
+    {
+        $o = $this->__offset(98);
+        return $o != 0 ? $this->__vector_len($o) : 0;
+    }
+
    /**
     * @param FlatBufferBuilder $builder
     * @return void
     */
    public static function startMonster(FlatBufferBuilder $builder)
    {
-        $builder->StartObject(47);
+        $builder->StartObject(48);
    }

    /**
     * @param FlatBufferBuilder $builder
     * @return Monster
     */
-    public static function createMonster(FlatBufferBuilder $builder, $pos, $mana, $hp, $name, $inventory, $color, $test_type, $test, $test4, $testarrayofstring, $testarrayoftables, $enemy, $testnestedflatbuffer, $testempty, $testbool, $testhashs32_fnv1, $testhashu32_fnv1, $testhashs64_fnv1, $testhashu64_fnv1, $testhashs32_fnv1a, $testhashu32_fnv1a, $testhashs64_fnv1a, $testhashu64_fnv1a, $testarrayofbools, $testf, $testf2, $testf3, $testarrayofstring2, $testarrayofsortedstruct, $flex, $test5, $vector_of_longs, $vector_of_doubles, $parent_namespace_test, $vector_of_referrables, $single_weak_reference, $vector_of_weak_references, $vector_of_strong_referrables, $co_owning_reference, $vector_of_co_owning_references, $non_owning_reference, $vector_of_non_owning_references, $any_unique_type, $any_unique, $any_ambiguous_type, $any_ambiguous)
+    public static function createMonster(FlatBufferBuilder $builder, $pos, $mana, $hp, $name, $inventory, $color, $test_type, $test, $test4, $testarrayofstring, $testarrayoftables, $enemy, $testnestedflatbuffer, $testempty, $testbool, $testhashs32_fnv1, $testhashu32_fnv1, $testhashs64_fnv1, $testhashu64_fnv1, $testhashs32_fnv1a, $testhashu32_fnv1a, $testhashs64_fnv1a, $testhashu64_fnv1a, $testarrayofbools, $testf, $testf2, $testf3, $testarrayofstring2, $testarrayofsortedstruct, $flex, $test5, $vector_of_longs, $vector_of_doubles, $parent_namespace_test, $vector_of_referrables, $single_weak_reference, $vector_of_weak_references, $vector_of_strong_referrables, $co_owning_reference, $vector_of_co_owning_references, $non_owning_reference, $vector_of_non_owning_references, $any_unique_type, $any_unique, $any_ambiguous_type, $any_ambiguous, $vector_of_enums)
    {
-        $builder->startObject(47);
+        $builder->startObject(48);
        self::addPos($builder, $pos);
        self::addMana($builder, $mana);
        self::addHp($builder, $hp);
@@ -709,6 +728,7 @@ class Monster extends Table
        self::addAnyUnique($builder, $any_unique);
        self::addAnyAmbiguousType($builder, $any_ambiguous_type);
        self::addAnyAmbiguous($builder, $any_ambiguous);
+        self::addVectorOfEnums($builder, $vector_of_enums);
        $o = $builder->endObject();
        $builder->required($o, 10);  // name
        return $o;
@@ -1567,6 +1587,40 @@ class Monster extends Table
        $builder->addOffsetX(46, $offset, 0);
    }

+    /**
+     * @param FlatBufferBuilder $builder
+     * @param VectorOffset
+     * @return void
+     */
+    public static function addVectorOfEnums(FlatBufferBuilder $builder, $vectorOfEnums)
+    {
+        $builder->addOffsetX(47, $vectorOfEnums, 0);
+    }
+
+    /**
+     * @param FlatBufferBuilder $builder
+     * @param array offset array
+     * @return int vector offset
+     */
+    public static function createVectorOfEnumsVector(FlatBufferBuilder $builder, array $data)
+    {
+        $builder->startVector(1, count($data), 1);
+        for ($i = count($data) - 1; $i >= 0; $i--) {
+            $builder->addSbyte($data[$i]);
+        }
+        return $builder->endVector();
+    }
+
+    /**
+     * @param FlatBufferBuilder $builder
+     * @param int $numElems
+     * @return void
+     */
+    public static function startVectorOfEnumsVector(FlatBufferBuilder $builder, $numElems)
+    {
+        $builder->startVector(1, $numElems, 1);
+    }
+
    /**
     * @param FlatBufferBuilder $builder
     * @return int table offset
--- a/tests/MyGame/Example/Monster.py
+++ b/tests/MyGame/Example/Monster.py
@@ -594,7 +594,29 @@ class Monster(object):
            return obj
        return None

-def MonsterStart(builder): builder.StartObject(47)
+    # Monster
+    def VectorOfEnums(self, j):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(98))
+        if o != 0:
+            a = self._tab.Vector(o)
+            return self._tab.Get(flatbuffers.number_types.Int8Flags, a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 1))
+        return 0
+
+    # Monster
+    def VectorOfEnumsAsNumpy(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(98))
+        if o != 0:
+            return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Int8Flags, o)
+        return 0
+
+    # Monster
+    def VectorOfEnumsLength(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(98))
+        if o != 0:
+            return self._tab.VectorLen(o)
+        return 0
+
+def MonsterStart(builder): builder.StartObject(48)
 def MonsterAddPos(builder, pos): builder.PrependStructSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(pos), 0)
 def MonsterAddMana(builder, mana): builder.PrependInt16Slot(1, mana, 150)
 def MonsterAddHp(builder, hp): builder.PrependInt16Slot(2, hp, 100)
@@ -658,4 +680,6 @@ def MonsterAddAnyUniqueType(builder, anyUniqueType): builder.PrependUint8Slot(43
 def MonsterAddAnyUnique(builder, anyUnique): builder.PrependUOffsetTRelativeSlot(44, flatbuffers.number_types.UOffsetTFlags.py_type(anyUnique), 0)
 def MonsterAddAnyAmbiguousType(builder, anyAmbiguousType): builder.PrependUint8Slot(45, anyAmbiguousType, 0)
 def MonsterAddAnyAmbiguous(builder, anyAmbiguous): builder.PrependUOffsetTRelativeSlot(46, flatbuffers.number_types.UOffsetTFlags.py_type(anyAmbiguous), 0)
+def MonsterAddVectorOfEnums(builder, vectorOfEnums): builder.PrependUOffsetTRelativeSlot(47, flatbuffers.number_types.UOffsetTFlags.py_type(vectorOfEnums), 0)
+def MonsterStartVectorOfEnumsVector(builder, numElems): return builder.StartVector(1, numElems, 1)
 def MonsterEnd(builder): return builder.EndObject()
--- a/tests/monster_test.bfbs
+++ b/tests/monster_test.bfbs
--- a/tests/monster_test.fbs
+++ b/tests/monster_test.fbs
@@ -99,6 +99,7 @@ table Monster {
  vector_of_non_owning_references:[ulong](id:42, hash:"fnv1a_64", cpp_type:"ReferrableT", cpp_ptr_type:"naked", cpp_ptr_type_get:"");                 //was weak_ptr
  any_unique:AnyUniqueAliases(id:44);
  any_ambiguous:AnyAmbiguousAliases (id:46);
+  vector_of_enums:[Color] (id:47);
 }

 table TypeAliases {
--- a/tests/monster_test.schema.json
+++ b/tests/monster_test.schema.json
@@ -155,7 +155,8 @@
        "any_unique_type" : { "$ref" : "#/definitions/MyGame_Example_AnyUniqueAliases" },
        "any_unique" : { "anyOf": [{ "$ref" : "#/definitions/MyGame_Example_Monster" },{ "$ref" : "#/definitions/MyGame_Example_TestSimpleTableWithEnum" },{ "$ref" : "#/definitions/MyGame_Example2_Monster" }] },
        "any_ambiguous_type" : { "$ref" : "#/definitions/MyGame_Example_AnyAmbiguousAliases" },
-        "any_ambiguous" : { "anyOf": [{ "$ref" : "#/definitions/MyGame_Example_Monster" },{ "$ref" : "#/definitions/MyGame_Example_Monster" },{ "$ref" : "#/definitions/MyGame_Example_Monster" }] }
+        "any_ambiguous" : { "anyOf": [{ "$ref" : "#/definitions/MyGame_Example_Monster" },{ "$ref" : "#/definitions/MyGame_Example_Monster" },{ "$ref" : "#/definitions/MyGame_Example_Monster" }] },
+        "vector_of_enums" : { "$ref" : "#/definitions/MyGame_Example_Color" }
      },
      "required" : ["name"],
      "additionalProperties" : false
--- a/tests/monster_test_generated.h
+++ b/tests/monster_test_generated.h
@@ -1056,6 +1056,7 @@ struct MonsterT : public flatbuffers::NativeTable {
  std::vector<ReferrableT *> vector_of_non_owning_references;
  AnyUniqueAliasesUnion any_unique;
  AnyAmbiguousAliasesUnion any_ambiguous;
+  std::vector<Color> vector_of_enums;
  MonsterT()
      : mana(150),
        hp(100),
@@ -1122,7 +1123,8 @@ inline bool operator==(const MonsterT &lhs, const MonsterT &rhs) {
      (lhs.non_owning_reference == rhs.non_owning_reference) &&
      (lhs.vector_of_non_owning_references == rhs.vector_of_non_owning_references) &&
      (lhs.any_unique == rhs.any_unique) &&
-      (lhs.any_ambiguous == rhs.any_ambiguous);
+      (lhs.any_ambiguous == rhs.any_ambiguous) &&
+      (lhs.vector_of_enums == rhs.vector_of_enums);
 }

 /// an example documentation comment: monster object
@@ -1177,7 +1179,8 @@ struct Monster FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
    VT_ANY_UNIQUE_TYPE = 90,
    VT_ANY_UNIQUE = 92,
    VT_ANY_AMBIGUOUS_TYPE = 94,
-    VT_ANY_AMBIGUOUS = 96
+    VT_ANY_AMBIGUOUS = 96,
+    VT_VECTOR_OF_ENUMS = 98
  };
  const Vec3 *pos() const {
    return GetStruct<const Vec3 *>(VT_POS);
@@ -1498,6 +1501,12 @@ struct Monster FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
  void *mutable_any_ambiguous() {
    return GetPointer<void *>(VT_ANY_AMBIGUOUS);
  }
+  const flatbuffers::Vector<int8_t> *vector_of_enums() const {
+    return GetPointer<const flatbuffers::Vector<int8_t> *>(VT_VECTOR_OF_ENUMS);
+  }
+  flatbuffers::Vector<int8_t> *mutable_vector_of_enums() {
+    return GetPointer<flatbuffers::Vector<int8_t> *>(VT_VECTOR_OF_ENUMS);
+  }
  bool Verify(flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyField<Vec3>(verifier, VT_POS) &&
@@ -1575,6 +1584,8 @@ struct Monster FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
           VerifyField<uint8_t>(verifier, VT_ANY_AMBIGUOUS_TYPE) &&
           VerifyOffset(verifier, VT_ANY_AMBIGUOUS) &&
           VerifyAnyAmbiguousAliases(verifier, any_ambiguous(), any_ambiguous_type()) &&
+           VerifyOffset(verifier, VT_VECTOR_OF_ENUMS) &&
+           verifier.VerifyVector(vector_of_enums()) &&
           verifier.EndTable();
  }
  MonsterT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
@@ -1747,6 +1758,9 @@ struct MonsterBuilder {
  void add_any_ambiguous(flatbuffers::Offset<void> any_ambiguous) {
    fbb_.AddOffset(Monster::VT_ANY_AMBIGUOUS, any_ambiguous);
  }
+  void add_vector_of_enums(flatbuffers::Offset<flatbuffers::Vector<int8_t>> vector_of_enums) {
+    fbb_.AddOffset(Monster::VT_VECTOR_OF_ENUMS, vector_of_enums);
+  }
  explicit MonsterBuilder(flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
@@ -1807,7 +1821,8 @@ inline flatbuffers::Offset<Monster> CreateMonster(
    AnyUniqueAliases any_unique_type = AnyUniqueAliases_NONE,
    flatbuffers::Offset<void> any_unique = 0,
    AnyAmbiguousAliases any_ambiguous_type = AnyAmbiguousAliases_NONE,
-    flatbuffers::Offset<void> any_ambiguous = 0) {
+    flatbuffers::Offset<void> any_ambiguous = 0,
+    flatbuffers::Offset<flatbuffers::Vector<int8_t>> vector_of_enums = 0) {
  MonsterBuilder builder_(_fbb);
  builder_.add_non_owning_reference(non_owning_reference);
  builder_.add_co_owning_reference(co_owning_reference);
@@ -1816,6 +1831,7 @@ inline flatbuffers::Offset<Monster> CreateMonster(
  builder_.add_testhashs64_fnv1a(testhashs64_fnv1a);
  builder_.add_testhashu64_fnv1(testhashu64_fnv1);
  builder_.add_testhashs64_fnv1(testhashs64_fnv1);
+  builder_.add_vector_of_enums(vector_of_enums);
  builder_.add_any_ambiguous(any_ambiguous);
  builder_.add_any_unique(any_unique);
  builder_.add_vector_of_non_owning_references(vector_of_non_owning_references);
@@ -1905,7 +1921,8 @@ inline flatbuffers::Offset<Monster> CreateMonsterDirect(
    AnyUniqueAliases any_unique_type = AnyUniqueAliases_NONE,
    flatbuffers::Offset<void> any_unique = 0,
    AnyAmbiguousAliases any_ambiguous_type = AnyAmbiguousAliases_NONE,
-    flatbuffers::Offset<void> any_ambiguous = 0) {
+    flatbuffers::Offset<void> any_ambiguous = 0,
+    const std::vector<int8_t> *vector_of_enums = nullptr) {
  return MyGame::Example::CreateMonster(
      _fbb,
      pos,
@@ -1953,7 +1970,8 @@ inline flatbuffers::Offset<Monster> CreateMonsterDirect(
      any_unique_type,
      any_unique,
      any_ambiguous_type,
-      any_ambiguous);
+      any_ambiguous,
+      vector_of_enums ? _fbb.CreateVector<int8_t>(*vector_of_enums) : 0);
 }

 flatbuffers::Offset<Monster> CreateMonster(flatbuffers::FlatBufferBuilder &_fbb, const MonsterT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
@@ -2429,6 +2447,7 @@ if (_resolver) (*_resolver)(reinterpret_cast<void **>(&_o->vector_of_non_owning_
  { auto _e = any_unique(); if (_e) _o->any_unique.value = AnyUniqueAliasesUnion::UnPack(_e, any_unique_type(), _resolver); };
  { auto _e = any_ambiguous_type(); _o->any_ambiguous.type = _e; };
  { auto _e = any_ambiguous(); if (_e) _o->any_ambiguous.value = AnyAmbiguousAliasesUnion::UnPack(_e, any_ambiguous_type(), _resolver); };
+  { auto _e = vector_of_enums(); if (_e) { _o->vector_of_enums.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->vector_of_enums[_i] = static_cast<Color>(_e->Get(_i)); } } };
 }

 inline flatbuffers::Offset<Monster> Monster::Pack(flatbuffers::FlatBufferBuilder &_fbb, const MonsterT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
@@ -2485,6 +2504,7 @@ inline flatbuffers::Offset<Monster> CreateMonster(flatbuffers::FlatBufferBuilder
  auto _any_unique = _o->any_unique.Pack(_fbb);
  auto _any_ambiguous_type = _o->any_ambiguous.type;
  auto _any_ambiguous = _o->any_ambiguous.Pack(_fbb);
+  auto _vector_of_enums = _o->vector_of_enums.size() ? _fbb.CreateVectorScalarCast<int8_t>(_o->vector_of_enums.data(), _o->vector_of_enums.size()) : 0;
  return MyGame::Example::CreateMonster(
      _fbb,
      _pos,
@@ -2532,7 +2552,8 @@ inline flatbuffers::Offset<Monster> CreateMonster(flatbuffers::FlatBufferBuilder
      _any_unique_type,
      _any_unique,
      _any_ambiguous_type,
-      _any_ambiguous);
+      _any_ambiguous,
+      _vector_of_enums);
 }

 inline TypeAliasesT *TypeAliases::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
@@ -3194,7 +3215,8 @@ inline const flatbuffers::TypeTable *MonsterTypeTable() {
    { flatbuffers::ET_UTYPE, 0, 9 },
    { flatbuffers::ET_SEQUENCE, 0, 9 },
    { flatbuffers::ET_UTYPE, 0, 10 },
-    { flatbuffers::ET_SEQUENCE, 0, 10 }
+    { flatbuffers::ET_SEQUENCE, 0, 10 },
+    { flatbuffers::ET_CHAR, 1, 1 }
  };
  static const flatbuffers::TypeFunction type_refs[] = {
    Vec3TypeTable,
@@ -3256,10 +3278,11 @@ inline const flatbuffers::TypeTable *MonsterTypeTable() {
    "any_unique_type",
    "any_unique",
    "any_ambiguous_type",
-    "any_ambiguous"
+    "any_ambiguous",
+    "vector_of_enums"
  };
  static const flatbuffers::TypeTable tt = {
-    flatbuffers::ST_TABLE, 47, type_codes, type_refs, nullptr, names
+    flatbuffers::ST_TABLE, 48, type_codes, type_refs, nullptr, names
  };
  return &tt;
 }
--- a/tests/monster_test_generated.js
+++ b/tests/monster_test_generated.js
@@ -1738,11 +1738,36 @@ MyGame.Example.Monster.prototype.anyAmbiguous = function(obj) {
  return offset ? this.bb.__union(obj, this.bb_pos + offset) : null;
 };

+/**
+ * @param {number} index
+ * @returns {MyGame.Example.Color}
+ */
+MyGame.Example.Monster.prototype.vectorOfEnums = function(index) {
+  var offset = this.bb.__offset(this.bb_pos, 98);
+  return offset ? /** @type {MyGame.Example.Color} */ (this.bb.readInt8(this.bb.__vector(this.bb_pos + offset) + index)) : /** @type {MyGame.Example.Color} */ (0);
+};
+
+/**
+ * @returns {number}
+ */
+MyGame.Example.Monster.prototype.vectorOfEnumsLength = function() {
+  var offset = this.bb.__offset(this.bb_pos, 98);
+  return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0;
+};
+
+/**
+ * @returns {Int8Array}
+ */
+MyGame.Example.Monster.prototype.vectorOfEnumsArray = function() {
+  var offset = this.bb.__offset(this.bb_pos, 98);
+  return offset ? new Int8Array(this.bb.bytes().buffer, this.bb.bytes().byteOffset + this.bb.__vector(this.bb_pos + offset), this.bb.__vector_len(this.bb_pos + offset)) : null;
+};
+
 /**
 * @param {flatbuffers.Builder} builder
 */
 MyGame.Example.Monster.startMonster = function(builder) {
-  builder.startObject(47);
+  builder.startObject(48);
 };

 /**
@@ -2431,6 +2456,35 @@ MyGame.Example.Monster.addAnyAmbiguous = function(builder, anyAmbiguousOffset) {
  builder.addFieldOffset(46, anyAmbiguousOffset, 0);
 };

+/**
+ * @param {flatbuffers.Builder} builder
+ * @param {flatbuffers.Offset} vectorOfEnumsOffset
+ */
+MyGame.Example.Monster.addVectorOfEnums = function(builder, vectorOfEnumsOffset) {
+  builder.addFieldOffset(47, vectorOfEnumsOffset, 0);
+};
+
+/**
+ * @param {flatbuffers.Builder} builder
+ * @param {Array.<MyGame.Example.Color>} data
+ * @returns {flatbuffers.Offset}
+ */
+MyGame.Example.Monster.createVectorOfEnumsVector = function(builder, data) {
+  builder.startVector(1, data.length, 1);
+  for (var i = data.length - 1; i >= 0; i--) {
+    builder.addInt8(data[i]);
+  }
+  return builder.endVector();
+};
+
+/**
+ * @param {flatbuffers.Builder} builder
+ * @param {number} numElems
+ */
+MyGame.Example.Monster.startVectorOfEnumsVector = function(builder, numElems) {
+  builder.startVector(1, numElems, 1);
+};
+
 /**
 * @param {flatbuffers.Builder} builder
 * @returns {flatbuffers.Offset}
--- a/tests/monster_test_generated.lobster
+++ b/tests/monster_test_generated.lobster
@@ -325,11 +325,15 @@ struct Monster : flatbuffers_handle
        MyGame_Example_Monster { buf_, buf_.flatbuffers_field_table(pos_, 96) }
    def any_ambiguous_as_M3():
        MyGame_Example_Monster { buf_, buf_.flatbuffers_field_table(pos_, 96) }
+    def vector_of_enums(i:int):
+        buf_.read_int8_le(buf_.flatbuffers_field_vector(pos_, 98) + i * 1)
+    def vector_of_enums_length():
+        buf_.flatbuffers_field_vector_len(pos_, 98)

 def GetRootAsMonster(buf:string): Monster { buf, buf.flatbuffers_indirect(0) }

 def MonsterStart(b_:flatbuffers_builder):
-    b_.StartObject(47)
+    b_.StartObject(48)
 def MonsterAddPos(b_:flatbuffers_builder, pos:int):
    b_.PrependStructSlot(0, pos, 0)
 def MonsterAddMana(b_:flatbuffers_builder, mana:int):
@@ -512,6 +516,14 @@ def MonsterAddAnyAmbiguousType(b_:flatbuffers_builder, any_ambiguous_type:int):
    b_.PrependUint8Slot(45, any_ambiguous_type, 0)
 def MonsterAddAnyAmbiguous(b_:flatbuffers_builder, any_ambiguous:int):
    b_.PrependUOffsetTRelativeSlot(46, any_ambiguous, 0)
+def MonsterAddVectorOfEnums(b_:flatbuffers_builder, vector_of_enums:int):
+    b_.PrependUOffsetTRelativeSlot(47, vector_of_enums, 0)
+def MonsterStartVectorOfEnumsVector(b_:flatbuffers_builder, n_:int):
+    b_.StartVector(1, n_, 1)
+def MonsterCreateVectorOfEnumsVector(b_:flatbuffers_builder, v_:[int]):
+    b_.StartVector(1, v_.length, 1)
+    reverse(v_) e_: b_.PrependInt8(e_)
+    b_.EndVector(v_.length)
 def MonsterEnd(b_:flatbuffers_builder):
    b_.EndObject()

--- a/tests/monster_test_generated.rs
+++ b/tests/monster_test_generated.rs
@@ -948,6 +948,7 @@ impl<'a> Monster<'a> {
      builder.add_testhashs64_fnv1a(args.testhashs64_fnv1a);
      builder.add_testhashu64_fnv1(args.testhashu64_fnv1);
      builder.add_testhashs64_fnv1(args.testhashs64_fnv1);
+      if let Some(x) = args.vector_of_enums { builder.add_vector_of_enums(x); }
      if let Some(x) = args.any_ambiguous { builder.add_any_ambiguous(x); }
      if let Some(x) = args.any_unique { builder.add_any_unique(x); }
      if let Some(x) = args.vector_of_non_owning_references { builder.add_vector_of_non_owning_references(x); }
@@ -1036,6 +1037,7 @@ impl<'a> Monster<'a> {
    pub const VT_ANY_UNIQUE: flatbuffers::VOffsetT = 92;
    pub const VT_ANY_AMBIGUOUS_TYPE: flatbuffers::VOffsetT = 94;
    pub const VT_ANY_AMBIGUOUS: flatbuffers::VOffsetT = 96;
+    pub const VT_VECTOR_OF_ENUMS: flatbuffers::VOffsetT = 98;

  #[inline]
  pub fn pos(&self) -> Option<&'a Vec3> {
@@ -1243,6 +1245,10 @@ impl<'a> Monster<'a> {
    self._tab.get::<flatbuffers::ForwardsUOffset<flatbuffers::Table<'a>>>(Monster::VT_ANY_AMBIGUOUS, None)
  }
  #[inline]
+  pub fn vector_of_enums(&self) -> Option<flatbuffers::Vector<'a, Color>> {
+    self._tab.get::<flatbuffers::ForwardsUOffset<flatbuffers::Vector<'a, Color>>>(Monster::VT_VECTOR_OF_ENUMS, None)
+  }
+  #[inline]
  #[allow(non_snake_case)]
  pub fn test_as_monster(&'a self) -> Option<Monster> {
    if self.test_type() == Any::Monster {
@@ -1381,6 +1387,7 @@ pub struct MonsterArgs<'a> {
    pub any_unique: Option<flatbuffers::WIPOffset<flatbuffers::UnionWIPOffset>>,
    pub any_ambiguous_type: AnyAmbiguousAliases,
    pub any_ambiguous: Option<flatbuffers::WIPOffset<flatbuffers::UnionWIPOffset>>,
+    pub vector_of_enums: Option<flatbuffers::WIPOffset<flatbuffers::Vector<'a , Color>>>,
 }
 impl<'a> Default for MonsterArgs<'a> {
    #[inline]
@@ -1432,6 +1439,7 @@ impl<'a> Default for MonsterArgs<'a> {
            any_unique: None,
            any_ambiguous_type: AnyAmbiguousAliases::NONE,
            any_ambiguous: None,
+            vector_of_enums: None,
        }
    }
 }
@@ -1625,6 +1633,10 @@ impl<'a: 'b, 'b> MonsterBuilder<'a, 'b> {
    self.fbb_.push_slot_always::<flatbuffers::WIPOffset<_>>(Monster::VT_ANY_AMBIGUOUS, any_ambiguous);
  }
  #[inline]
+  pub fn add_vector_of_enums(&mut self, vector_of_enums: flatbuffers::WIPOffset<flatbuffers::Vector<'b , Color>>) {
+    self.fbb_.push_slot_always::<flatbuffers::WIPOffset<_>>(Monster::VT_VECTOR_OF_ENUMS, vector_of_enums);
+  }
+  #[inline]
  pub fn new(_fbb: &'b mut flatbuffers::FlatBufferBuilder<'a>) -> MonsterBuilder<'a, 'b> {
    let start = _fbb.start_table();
    MonsterBuilder {
--- a/tests/monster_test_generated.ts
+++ b/tests/monster_test_generated.ts
@@ -1679,11 +1679,36 @@ anyAmbiguous<T extends flatbuffers.Table>(obj:T):T|null {
  return offset ? this.bb!.__union(obj, this.bb_pos + offset) : null;
 };

+/**
+ * @param number index
+ * @returns MyGame.Example.Color
+ */
+vectorOfEnums(index: number):MyGame.Example.Color|null {
+  var offset = this.bb!.__offset(this.bb_pos, 98);
+  return offset ? /**  */ (this.bb!.readInt8(this.bb!.__vector(this.bb_pos + offset) + index)) : /**  */ (0);
+};
+
+/**
+ * @returns number
+ */
+vectorOfEnumsLength():number {
+  var offset = this.bb!.__offset(this.bb_pos, 98);
+  return offset ? this.bb!.__vector_len(this.bb_pos + offset) : 0;
+};
+
+/**
+ * @returns Int8Array
+ */
+vectorOfEnumsArray():Int8Array|null {
+  var offset = this.bb!.__offset(this.bb_pos, 98);
+  return offset ? new Int8Array(this.bb!.bytes().buffer, this.bb!.bytes().byteOffset + this.bb!.__vector(this.bb_pos + offset), this.bb!.__vector_len(this.bb_pos + offset)) : null;
+};
+
 /**
 * @param flatbuffers.Builder builder
 */
 static startMonster(builder:flatbuffers.Builder) {
-  builder.startObject(47);
+  builder.startObject(48);
 };

 /**
@@ -2372,6 +2397,35 @@ static addAnyAmbiguous(builder:flatbuffers.Builder, anyAmbiguousOffset:flatbuffe
  builder.addFieldOffset(46, anyAmbiguousOffset, 0);
 };

+/**
+ * @param flatbuffers.Builder builder
+ * @param flatbuffers.Offset vectorOfEnumsOffset
+ */
+static addVectorOfEnums(builder:flatbuffers.Builder, vectorOfEnumsOffset:flatbuffers.Offset) {
+  builder.addFieldOffset(47, vectorOfEnumsOffset, 0);
+};
+
+/**
+ * @param flatbuffers.Builder builder
+ * @param Array.<MyGame.Example.Color> data
+ * @returns flatbuffers.Offset
+ */
+static createVectorOfEnumsVector(builder:flatbuffers.Builder, data:MyGame.Example.Color[]):flatbuffers.Offset {
+  builder.startVector(1, data.length, 1);
+  for (var i = data.length - 1; i >= 0; i--) {
+    builder.addInt8(data[i]);
+  }
+  return builder.endVector();
+};
+
+/**
+ * @param flatbuffers.Builder builder
+ * @param number numElems
+ */
+static startVectorOfEnumsVector(builder:flatbuffers.Builder, numElems:number) {
+  builder.startVector(1, numElems, 1);
+};
+
 /**
 * @param flatbuffers.Builder builder
 * @returns flatbuffers.Offset
--- a/tests/monster_test_my_game.example_generated.dart
+++ b/tests/monster_test_my_game.example_generated.dart
@@ -752,10 +752,11 @@ class Monster {
      default: return null;
    }
  }
+  List<Color> get vectorOfEnums => const fb.ListReader<Color>(Color.reader).vTableGet(_bc, _bcOffset, 98, null);

  @override
  String toString() {
-    return 'Monster{pos: $pos, mana: $mana, hp: $hp, name: $name, inventory: $inventory, color: $color, testType: $testType, test: $test, test4: $test4, testarrayofstring: $testarrayofstring, testarrayoftables: $testarrayoftables, enemy: $enemy, testnestedflatbuffer: $testnestedflatbuffer, testempty: $testempty, testbool: $testbool, testhashs32Fnv1: $testhashs32Fnv1, testhashu32Fnv1: $testhashu32Fnv1, testhashs64Fnv1: $testhashs64Fnv1, testhashu64Fnv1: $testhashu64Fnv1, testhashs32Fnv1a: $testhashs32Fnv1a, testhashu32Fnv1a: $testhashu32Fnv1a, testhashs64Fnv1a: $testhashs64Fnv1a, testhashu64Fnv1a: $testhashu64Fnv1a, testarrayofbools: $testarrayofbools, testf: $testf, testf2: $testf2, testf3: $testf3, testarrayofstring2: $testarrayofstring2, testarrayofsortedstruct: $testarrayofsortedstruct, flex: $flex, test5: $test5, vectorOfLongs: $vectorOfLongs, vectorOfDoubles: $vectorOfDoubles, parentNamespaceTest: $parentNamespaceTest, vectorOfReferrables: $vectorOfReferrables, singleWeakReference: $singleWeakReference, vectorOfWeakReferences: $vectorOfWeakReferences, vectorOfStrongReferrables: $vectorOfStrongReferrables, coOwningReference: $coOwningReference, vectorOfCoOwningReferences: $vectorOfCoOwningReferences, nonOwningReference: $nonOwningReference, vectorOfNonOwningReferences: $vectorOfNonOwningReferences, anyUniqueType: $anyUniqueType, anyUnique: $anyUnique, anyAmbiguousType: $anyAmbiguousType, anyAmbiguous: $anyAmbiguous}';
+    return 'Monster{pos: $pos, mana: $mana, hp: $hp, name: $name, inventory: $inventory, color: $color, testType: $testType, test: $test, test4: $test4, testarrayofstring: $testarrayofstring, testarrayoftables: $testarrayoftables, enemy: $enemy, testnestedflatbuffer: $testnestedflatbuffer, testempty: $testempty, testbool: $testbool, testhashs32Fnv1: $testhashs32Fnv1, testhashu32Fnv1: $testhashu32Fnv1, testhashs64Fnv1: $testhashs64Fnv1, testhashu64Fnv1: $testhashu64Fnv1, testhashs32Fnv1a: $testhashs32Fnv1a, testhashu32Fnv1a: $testhashu32Fnv1a, testhashs64Fnv1a: $testhashs64Fnv1a, testhashu64Fnv1a: $testhashu64Fnv1a, testarrayofbools: $testarrayofbools, testf: $testf, testf2: $testf2, testf3: $testf3, testarrayofstring2: $testarrayofstring2, testarrayofsortedstruct: $testarrayofsortedstruct, flex: $flex, test5: $test5, vectorOfLongs: $vectorOfLongs, vectorOfDoubles: $vectorOfDoubles, parentNamespaceTest: $parentNamespaceTest, vectorOfReferrables: $vectorOfReferrables, singleWeakReference: $singleWeakReference, vectorOfWeakReferences: $vectorOfWeakReferences, vectorOfStrongReferrables: $vectorOfStrongReferrables, coOwningReference: $coOwningReference, vectorOfCoOwningReferences: $vectorOfCoOwningReferences, nonOwningReference: $nonOwningReference, vectorOfNonOwningReferences: $vectorOfNonOwningReferences, anyUniqueType: $anyUniqueType, anyUnique: $anyUnique, anyAmbiguousType: $anyAmbiguousType, anyAmbiguous: $anyAmbiguous, vectorOfEnums: $vectorOfEnums}';
  }
 }

@@ -962,6 +963,10 @@ class MonsterBuilder {
    fbBuilder.addOffset(46, offset);
    return fbBuilder.offset;
  }
+  int addVectorOfEnumsOffset(int offset) {
+    fbBuilder.addOffset(47, offset);
+    return fbBuilder.offset;
+  }

  int finish() {
    return fbBuilder.endTable();
@@ -1015,6 +1020,7 @@ class MonsterObjectBuilder extends fb.ObjectBuilder {
  final dynamic _anyUnique;
  final AnyAmbiguousAliasesTypeId _anyAmbiguousType;
  final dynamic _anyAmbiguous;
+  final List<Color> _vectorOfEnums;

  MonsterObjectBuilder({
    Vec3ObjectBuilder pos,
@@ -1063,6 +1069,7 @@ class MonsterObjectBuilder extends fb.ObjectBuilder {
    dynamic anyUnique,
    AnyAmbiguousAliasesTypeId anyAmbiguousType,
    dynamic anyAmbiguous,
+    List<Color> vectorOfEnums,
  })
      : _pos = pos,
        _mana = mana,
@@ -1109,7 +1116,8 @@ class MonsterObjectBuilder extends fb.ObjectBuilder {
        _anyUniqueType = anyUniqueType,
        _anyUnique = anyUnique,
        _anyAmbiguousType = anyAmbiguousType,
-        _anyAmbiguous = anyAmbiguous;
+        _anyAmbiguous = anyAmbiguous,
+        _vectorOfEnums = vectorOfEnums;

  /// Finish building, and store into the [fbBuilder].
  @override
@@ -1174,6 +1182,9 @@ class MonsterObjectBuilder extends fb.ObjectBuilder {
        : null;
    final int anyUniqueOffset = _anyUnique?.getOrCreateOffset(fbBuilder);
    final int anyAmbiguousOffset = _anyAmbiguous?.getOrCreateOffset(fbBuilder);
+    final int vectorOfEnumsOffset = _vectorOfEnums?.isNotEmpty == true
+        ? fbBuilder.writeListInt8(_vectorOfEnums.map((f) => f.value))
+        : null;

    fbBuilder.startTable();
    if (_pos != null) {
@@ -1272,6 +1283,9 @@ class MonsterObjectBuilder extends fb.ObjectBuilder {
    if (anyAmbiguousOffset != null) {
      fbBuilder.addOffset(46, anyAmbiguousOffset);
    }
+    if (vectorOfEnumsOffset != null) {
+      fbBuilder.addOffset(47, vectorOfEnumsOffset);
+    }
    return fbBuilder.endTable();
  }

--- a/tests/test.cpp
+++ b/tests/test.cpp
@@ -161,13 +161,22 @@ flatbuffers::DetachedBuffer CreateFlatBufferTest(std::string &buffer) {
  flexbuild.Finish();
  auto flex = builder.CreateVector(flexbuild.GetBuffer());

+  // Test vector of enums.
+  Color colors[] = { Color_Blue, Color_Green };
+  // We use this special creation function because we have an array of
+  // pre-C++11 (enum class) enums whose size likely is int, yet its declared
+  // type in the schema is byte.
+  auto vecofcolors = builder.CreateVectorScalarCast<int8_t, Color>(colors, 2);
+
  // shortcut for creating monster with all fields set:
  auto mloc = CreateMonster(builder, &vec, 150, 80, name, inventory, Color_Blue,
                            Any_Monster, mlocs[1].Union(),  // Store a union.
                            testv, vecofstrings, vecoftables, 0,
                            nested_flatbuffer_vector, 0, false, 0, 0, 0, 0, 0,
                            0, 0, 0, 0, 3.14159f, 3.0f, 0.0f, vecofstrings2,
-                            vecofstructs, flex, testv2);
+                            vecofstructs, flex, testv2, 0, 0, 0, 0, 0, 0, 0, 0,
+                            0, 0, 0, AnyUniqueAliases_NONE, 0,
+                            AnyAmbiguousAliases_NONE, 0, vecofcolors);

  FinishMonsterBuffer(builder, mloc);

@@ -310,6 +319,14 @@ void AccessFlatBufferTest(const uint8_t *flatbuf, size_t length,
  // convenient accessor that directly gives you the root value:
  TEST_EQ(monster->flex_flexbuffer_root().AsInt16(), 1234);

+  // Test vector of enums:
+  auto colors = monster->vector_of_enums();
+  if (colors) {
+    TEST_EQ(colors->size(), 2);
+    TEST_EQ(colors->Get(0), Color_Blue);
+    TEST_EQ(colors->Get(1), Color_Green);
+  }
+
  // Since Flatbuffers uses explicit mechanisms to override the default
  // compiler alignment, double check that the compiler indeed obeys them:
  // (Test consists of a short and byte):
@@ -834,7 +851,8 @@ void MiniReflectFlatBuffersTest(uint8_t *flatbuf) {
      "{ id: 2, distance: 20 }, { id: 3, distance: 30 }, "
      "{ id: 4, distance: 40 } ], "
      "flex: [ 210, 4, 5, 2 ], "
-      "test5: [ { a: 10, b: 20 }, { a: 30, b: 40 } ] "
+      "test5: [ { a: 10, b: 20 }, { a: 30, b: 40 } ], "
+      "vector_of_enums: [ Blue, Green ] "
      "}");
 }