From f6384b41aaad88087f7574c16aee30aff545d830 Mon Sep 17 00:00:00 2001 From: tira-misu Date: Fri, 3 Mar 2023 06:42:27 +0100 Subject: [PATCH] [CS] Naming collision if field has same name as table and used as key (#7842) * Fix C/C++ CreateDirect with sorted vectors If a struct has a key the vector has to be sorted. To sort the vector you can't use "const". * Changes due to code review * Improve code readability * Add generate of JSON schema to string to lib * option indent_step is supported * Remove unused variables * Fix break in test * Fix style to be consistent with rest of the code * [TS] Fix reserved words as arguments (#6955) * [TS] Fix generation of reserved words in object api (#7106) * [TS] Fix generation of object api * [TS] Fix MakeCamel -> ConvertCase * [C#] Fix collision of field name and type name * [TS] Add test for struct of struct of struct * Update generated files * Add missing files * [TS] Fix query of null/undefined fields in object api * Fix collision if field name is equal to table name and used as key in an array --------- Co-authored-by: Derek Bailey --- src/idl_gen_csharp.cpp | 10 +- tests/union_value_collision.fbs | 5 + .../union_value_collision_generated.cs | 134 +++++++++++++++++- 3 files changed, 141 insertions(+), 8 deletions(-) diff --git a/src/idl_gen_csharp.cpp b/src/idl_gen_csharp.cpp index 9f384a7a01c..a113b9beb7c 100644 --- a/src/idl_gen_csharp.cpp +++ b/src/idl_gen_csharp.cpp @@ -477,8 +477,9 @@ class CSharpGenerator : public BaseGenerator { const std::string &offset) const { // Use the generated type directly, to properly handle default values that // might not be written to the buffer. - return GetObjectConstructor(struct_def, data_buffer, offset) + "." + - Name(*key_field); + auto name = Name(*key_field); + if (name == struct_def.name) { name += "_"; } + return GetObjectConstructor(struct_def, data_buffer, offset) + "." + name; } // Direct mutation is only allowed for scalar fields. @@ -1303,6 +1304,8 @@ class CSharpGenerator : public BaseGenerator { // because `key_field` is not set for struct if (struct_def.has_key && !struct_def.fixed) { FLATBUFFERS_ASSERT(key_field); + auto name = Name(*key_field); + if (name == struct_def.name) { name += "_"; } code += "\n public static VectorOffset "; code += "CreateSortedVectorOf" + struct_def.name; code += "(FlatBufferBuilder builder, "; @@ -1332,8 +1335,7 @@ class CSharpGenerator : public BaseGenerator { "(start + middle), bb);\n"; code += " obj_.__assign(tableOffset, bb);\n"; - code += - " int comp = obj_." + Name(*key_field) + ".CompareTo(key);\n"; + code += " int comp = obj_." + name + ".CompareTo(key);\n"; code += " if (comp > 0) {\n"; code += " span = middle;\n"; code += " } else if (comp < 0) {\n"; diff --git a/tests/union_value_collision.fbs b/tests/union_value_collision.fbs index 2e32245025b..58162044695 100644 --- a/tests/union_value_collision.fbs +++ b/tests/union_value_collision.fbs @@ -3,6 +3,10 @@ namespace union_value_collsion; table IntValue { value:int; } +table Collide { + collide: string (key); + value: string; +} union Value { IntValue } @@ -12,6 +16,7 @@ union Other { IntValue } table Collision { some_value : Value; value : Other; + collide : [Collision]; } root_type Collision; \ No newline at end of file diff --git a/tests/union_value_collsion/union_value_collision_generated.cs b/tests/union_value_collsion/union_value_collision_generated.cs index acd30335868..4d016b5f3d0 100644 --- a/tests/union_value_collsion/union_value_collision_generated.cs +++ b/tests/union_value_collsion/union_value_collision_generated.cs @@ -198,6 +198,110 @@ public IntValueT() { } } +public struct Collide : IFlatbufferObject +{ + private Table __p; + public ByteBuffer ByteBuffer { get { return __p.bb; } } + public static void ValidateVersion() { FlatBufferConstants.FLATBUFFERS_23_1_21(); } + public static Collide GetRootAsCollide(ByteBuffer _bb) { return GetRootAsCollide(_bb, new Collide()); } + public static Collide GetRootAsCollide(ByteBuffer _bb, Collide obj) { return (obj.__assign(_bb.GetInt(_bb.Position) + _bb.Position, _bb)); } + public void __init(int _i, ByteBuffer _bb) { __p = new Table(_i, _bb); } + public Collide __assign(int _i, ByteBuffer _bb) { __init(_i, _bb); return this; } + + public string Collide_ { get { int o = __p.__offset(4); return o != 0 ? __p.__string(o + __p.bb_pos) : null; } } +#if ENABLE_SPAN_T + public Span GetCollideBytes() { return __p.__vector_as_span(4, 1); } +#else + public ArraySegment? GetCollideBytes() { return __p.__vector_as_arraysegment(4); } +#endif + public byte[] GetCollideArray() { return __p.__vector_as_array(4); } + public string Value { get { int o = __p.__offset(6); return o != 0 ? __p.__string(o + __p.bb_pos) : null; } } +#if ENABLE_SPAN_T + public Span GetValueBytes() { return __p.__vector_as_span(6, 1); } +#else + public ArraySegment? GetValueBytes() { return __p.__vector_as_arraysegment(6); } +#endif + public byte[] GetValueArray() { return __p.__vector_as_array(6); } + + public static Offset CreateCollide(FlatBufferBuilder builder, + StringOffset collideOffset = default(StringOffset), + StringOffset valueOffset = default(StringOffset)) { + builder.StartTable(2); + Collide.AddValue(builder, valueOffset); + Collide.AddCollide(builder, collideOffset); + return Collide.EndCollide(builder); + } + + public static void StartCollide(FlatBufferBuilder builder) { builder.StartTable(2); } + public static void AddCollide(FlatBufferBuilder builder, StringOffset collideOffset) { builder.AddOffset(0, collideOffset.Value, 0); } + public static void AddValue(FlatBufferBuilder builder, StringOffset valueOffset) { builder.AddOffset(1, valueOffset.Value, 0); } + public static Offset EndCollide(FlatBufferBuilder builder) { + int o = builder.EndTable(); + builder.Required(o, 4); // collide + return new Offset(o); + } + + public static VectorOffset CreateSortedVectorOfCollide(FlatBufferBuilder builder, Offset[] offsets) { + Array.Sort(offsets, + (Offset o1, Offset o2) => + new Collide().__assign(builder.DataBuffer.Length - o1.Value, builder.DataBuffer).Collide_.CompareTo(new Collide().__assign(builder.DataBuffer.Length - o2.Value, builder.DataBuffer).Collide_)); + return builder.CreateVectorOfTables(offsets); + } + + public static Collide? __lookup_by_key(int vectorLocation, string key, ByteBuffer bb) { + Collide obj_ = new Collide(); + int span = bb.GetInt(vectorLocation - 4); + int start = 0; + while (span != 0) { + int middle = span / 2; + int tableOffset = Table.__indirect(vectorLocation + 4 * (start + middle), bb); + obj_.__assign(tableOffset, bb); + int comp = obj_.Collide_.CompareTo(key); + if (comp > 0) { + span = middle; + } else if (comp < 0) { + middle++; + start += middle; + span -= middle; + } else { + return obj_; + } + } + return null; + } + public CollideT UnPack() { + var _o = new CollideT(); + this.UnPackTo(_o); + return _o; + } + public void UnPackTo(CollideT _o) { + _o.Collide_ = this.Collide_; + _o.Value = this.Value; + } + public static Offset Pack(FlatBufferBuilder builder, CollideT _o) { + if (_o == null) return default(Offset); + var _collide = _o.Collide_ == null ? default(StringOffset) : builder.CreateString(_o.Collide_); + var _value = _o.Value == null ? default(StringOffset) : builder.CreateString(_o.Value); + return CreateCollide( + builder, + _collide, + _value); + } +} + +public class CollideT +{ + [Newtonsoft.Json.JsonProperty("collide")] + public string Collide_ { get; set; } + [Newtonsoft.Json.JsonProperty("value")] + public string Value { get; set; } + + public CollideT() { + this.Collide_ = null; + this.Value = null; + } +} + public struct Collision : IFlatbufferObject { private Table __p; @@ -214,13 +318,17 @@ public struct Collision : IFlatbufferObject public union_value_collsion.Other ValueType { get { int o = __p.__offset(8); return o != 0 ? (union_value_collsion.Other)__p.bb.Get(o + __p.bb_pos) : union_value_collsion.Other.NONE; } } public TTable? Value() where TTable : struct, IFlatbufferObject { int o = __p.__offset(10); return o != 0 ? (TTable?)__p.__union(o + __p.bb_pos) : null; } public union_value_collsion.IntValue ValueAsIntValue() { return Value().Value; } + public union_value_collsion.Collision? Collide(int j) { int o = __p.__offset(12); return o != 0 ? (union_value_collsion.Collision?)(new union_value_collsion.Collision()).__assign(__p.__indirect(__p.__vector(o) + j * 4), __p.bb) : null; } + public int CollideLength { get { int o = __p.__offset(12); return o != 0 ? __p.__vector_len(o) : 0; } } public static Offset CreateCollision(FlatBufferBuilder builder, union_value_collsion.Value some_value_type = union_value_collsion.Value.NONE, int some_valueOffset = 0, union_value_collsion.Other value_type = union_value_collsion.Other.NONE, - int valueOffset = 0) { - builder.StartTable(4); + int valueOffset = 0, + VectorOffset collideOffset = default(VectorOffset)) { + builder.StartTable(5); + Collision.AddCollide(builder, collideOffset); Collision.AddValue(builder, valueOffset); Collision.AddSomeValue(builder, some_valueOffset); Collision.AddValueType(builder, value_type); @@ -228,11 +336,17 @@ public struct Collision : IFlatbufferObject return Collision.EndCollision(builder); } - public static void StartCollision(FlatBufferBuilder builder) { builder.StartTable(4); } + public static void StartCollision(FlatBufferBuilder builder) { builder.StartTable(5); } public static void AddSomeValueType(FlatBufferBuilder builder, union_value_collsion.Value someValueType) { builder.AddByte(0, (byte)someValueType, 0); } public static void AddSomeValue(FlatBufferBuilder builder, int someValueOffset) { builder.AddOffset(1, someValueOffset, 0); } public static void AddValueType(FlatBufferBuilder builder, union_value_collsion.Other valueType) { builder.AddByte(2, (byte)valueType, 0); } public static void AddValue(FlatBufferBuilder builder, int valueOffset) { builder.AddOffset(3, valueOffset, 0); } + public static void AddCollide(FlatBufferBuilder builder, VectorOffset collideOffset) { builder.AddOffset(4, collideOffset.Value, 0); } + public static VectorOffset CreateCollideVector(FlatBufferBuilder builder, Offset[] data) { builder.StartVector(4, data.Length, 4); for (int i = data.Length - 1; i >= 0; i--) builder.AddOffset(data[i].Value); return builder.EndVector(); } + public static VectorOffset CreateCollideVectorBlock(FlatBufferBuilder builder, Offset[] data) { builder.StartVector(4, data.Length, 4); builder.Add(data); return builder.EndVector(); } + public static VectorOffset CreateCollideVectorBlock(FlatBufferBuilder builder, ArraySegment> data) { builder.StartVector(4, data.Count, 4); builder.Add(data); return builder.EndVector(); } + public static VectorOffset CreateCollideVectorBlock(FlatBufferBuilder builder, IntPtr dataPtr, int sizeInBytes) { builder.StartVector(1, sizeInBytes, 1); builder.Add>(dataPtr, sizeInBytes); return builder.EndVector(); } + public static void StartCollideVector(FlatBufferBuilder builder, int numElems) { builder.StartVector(4, numElems, 4); } public static Offset EndCollision(FlatBufferBuilder builder) { int o = builder.EndTable(); return new Offset(o); @@ -261,6 +375,8 @@ public void UnPackTo(CollisionT _o) { _o.Value.Value = this.Value().HasValue ? this.Value().Value.UnPack() : null; break; } + _o.Collide = new List(); + for (var _j = 0; _j < this.CollideLength; ++_j) {_o.Collide.Add(this.Collide(_j).HasValue ? this.Collide(_j).Value.UnPack() : null);} } public static Offset Pack(FlatBufferBuilder builder, CollisionT _o) { if (_o == null) return default(Offset); @@ -268,12 +384,19 @@ public void UnPackTo(CollisionT _o) { var _some_value = _o.SomeValue == null ? 0 : union_value_collsion.ValueUnion.Pack(builder, _o.SomeValue); var _value_type = _o.Value == null ? union_value_collsion.Other.NONE : _o.Value.Type; var _value = _o.Value == null ? 0 : union_value_collsion.OtherUnion.Pack(builder, _o.Value); + var _collide = default(VectorOffset); + if (_o.Collide != null) { + var __collide = new Offset[_o.Collide.Count]; + for (var _j = 0; _j < __collide.Length; ++_j) { __collide[_j] = union_value_collsion.Collision.Pack(builder, _o.Collide[_j]); } + _collide = CreateCollideVector(builder, __collide); + } return CreateCollision( builder, _some_value_type, _some_value, _value_type, - _value); + _value, + _collide); } } @@ -305,10 +428,13 @@ private union_value_collsion.Other ValueType { [Newtonsoft.Json.JsonProperty("value")] [Newtonsoft.Json.JsonConverter(typeof(union_value_collsion.OtherUnion_JsonConverter))] public union_value_collsion.OtherUnion Value { get; set; } + [Newtonsoft.Json.JsonProperty("collide")] + public List Collide { get; set; } public CollisionT() { this.SomeValue = null; this.Value = null; + this.Collide = null; } public static CollisionT DeserializeFromJson(string jsonText) {