From 952428d438d11f3169f09c17ed5c1a14fa2ee07a Mon Sep 17 00:00:00 2001 From: yoniiny Date: Sat, 15 Aug 2015 19:14:35 +0300 Subject: [PATCH] added IEnumerable getters GetXXXEnumerable to vectors in C# --- net/FlatBuffers/ByteBuffer.cs | 14 ++--- .../Enumerables/FlatBufferDoubleEnumerable.cs | 60 ++++++++++++++++++ .../Enumerables/FlatBufferEnumerable.cs | 60 ++++++++++++++++++ .../Enumerables/FlatBufferFloatEnumerable.cs | 60 ++++++++++++++++++ .../Enumerables/FlatBufferIntEnumerable.cs | 60 ++++++++++++++++++ .../Enumerables/FlatBufferLongEnumerable.cs | 60 ++++++++++++++++++ .../Enumerables/FlatBufferObjectEnumerable.cs | 60 ++++++++++++++++++ .../Enumerables/FlatBufferSbyteEnumerable.cs | 60 ++++++++++++++++++ .../Enumerables/FlatBufferShortEnumerable.cs | 60 ++++++++++++++++++ .../Enumerables/FlatBufferStringEnumerable.cs | 62 +++++++++++++++++++ .../Enumerables/FlatBufferStructEnumerable.cs | 61 ++++++++++++++++++ .../Enumerables/FlatBufferUintEnumerable.cs | 60 ++++++++++++++++++ .../Enumerables/FlatBufferUlongEnumerable.cs | 60 ++++++++++++++++++ .../Enumerables/FlatBufferUshortEnumerable.cs | 60 ++++++++++++++++++ net/FlatBuffers/FlatBufferConstants.cs | 5 -- net/FlatBuffers/FlatBuffers.csproj | 13 ++++ net/FlatBuffers/Struct.cs | 6 ++ net/FlatBuffers/Table.cs | 12 +++- src/idl_gen_general.cpp | 28 +++++++++ 19 files changed, 846 insertions(+), 15 deletions(-) create mode 100644 net/FlatBuffers/Enumerables/FlatBufferDoubleEnumerable.cs create mode 100644 net/FlatBuffers/Enumerables/FlatBufferEnumerable.cs create mode 100644 net/FlatBuffers/Enumerables/FlatBufferFloatEnumerable.cs create mode 100644 net/FlatBuffers/Enumerables/FlatBufferIntEnumerable.cs create mode 100644 net/FlatBuffers/Enumerables/FlatBufferLongEnumerable.cs create mode 100644 net/FlatBuffers/Enumerables/FlatBufferObjectEnumerable.cs create mode 100644 net/FlatBuffers/Enumerables/FlatBufferSbyteEnumerable.cs create mode 100644 net/FlatBuffers/Enumerables/FlatBufferShortEnumerable.cs create mode 100644 net/FlatBuffers/Enumerables/FlatBufferStringEnumerable.cs create mode 100644 net/FlatBuffers/Enumerables/FlatBufferStructEnumerable.cs create mode 100644 net/FlatBuffers/Enumerables/FlatBufferUintEnumerable.cs create mode 100644 net/FlatBuffers/Enumerables/FlatBufferUlongEnumerable.cs create mode 100644 net/FlatBuffers/Enumerables/FlatBufferUshortEnumerable.cs diff --git a/net/FlatBuffers/ByteBuffer.cs b/net/FlatBuffers/ByteBuffer.cs index c986269b9cc..a4d164ebbd0 100755 --- a/net/FlatBuffers/ByteBuffer.cs +++ b/net/FlatBuffers/ByteBuffer.cs @@ -48,12 +48,7 @@ public void Reset() public int Position { get { return _pos; } } - // Pre-allocated helper arrays for convertion. - private float[] floathelper = new[] { 0.0f }; - private int[] inthelper = new[] { 0 }; - private double[] doublehelper = new[] { 0.0 }; - private ulong[] ulonghelper = new[] { 0UL }; - +#if UNSAFE_BYTEBUFFER // Helper functions for the unsafe version. static public ushort ReverseBytes(ushort input) { @@ -78,8 +73,13 @@ static public ulong ReverseBytes(ulong input) ((input & 0x00FF000000000000UL) >> 40) | ((input & 0xFF00000000000000UL) >> 56)); } +#else + // Pre-allocated helper arrays for convertion. + private float[] floathelper = new[] { 0.0f }; + private int[] inthelper = new[] { 0 }; + private double[] doublehelper = new[] { 0.0 }; + private ulong[] ulonghelper = new[] { 0UL }; -#if !UNSAFE_BYTEBUFFER // Helper functions for the safe (but slower) version. protected void WriteLittleEndian(int offset, int count, ulong data) { diff --git a/net/FlatBuffers/Enumerables/FlatBufferDoubleEnumerable.cs b/net/FlatBuffers/Enumerables/FlatBufferDoubleEnumerable.cs new file mode 100644 index 00000000000..dc3b50c3c95 --- /dev/null +++ b/net/FlatBuffers/Enumerables/FlatBufferDoubleEnumerable.cs @@ -0,0 +1,60 @@ +using System; +using System.Collections; +using System.Collections.Generic; + +namespace FlatBuffers +{ + using ObjectType = Double; + + public class FlatBufferDoubleEnumerable : IEnumerable, IEnumerator + { + private int _pos; + private readonly int _end; + private readonly ByteBuffer _buffer; + private const int Size = sizeof(ObjectType); + + public FlatBufferDoubleEnumerable(int pos, int length, ByteBuffer buffer) + { + _pos = pos; + _end = pos + Size * length; + _buffer = buffer; + } + + public IEnumerator GetEnumerator() + { + return this; + } + + IEnumerator IEnumerable.GetEnumerator() + { + return GetEnumerator(); + } + + public ObjectType Current { get; private set; } + + public void Dispose() + { + } + + object IEnumerator.Current + { + get { return Current; } + } + + public bool MoveNext() + { + if (_pos >= _end) + { + return false; + } + Current = _buffer.GetDouble(_pos); + _pos += Size; + return true; + } + + public void Reset() + { + throw new NotSupportedException(); + } + } +} diff --git a/net/FlatBuffers/Enumerables/FlatBufferEnumerable.cs b/net/FlatBuffers/Enumerables/FlatBufferEnumerable.cs new file mode 100644 index 00000000000..ced1cc53690 --- /dev/null +++ b/net/FlatBuffers/Enumerables/FlatBufferEnumerable.cs @@ -0,0 +1,60 @@ +using System; +using System.Collections; +using System.Collections.Generic; + +namespace FlatBuffers +{ + using ObjectType = Byte; + + public class FlatBufferEnumerable : IEnumerable, IEnumerator + { + private int _pos; + private readonly int _end; + private readonly ByteBuffer _buffer; + private const int Size = sizeof(ObjectType); + + public FlatBufferEnumerable(int pos, int length, ByteBuffer buffer) + { + _pos = pos; + _end = pos + Size * length; + _buffer = buffer; + } + + public IEnumerator GetEnumerator() + { + return this; + } + + IEnumerator IEnumerable.GetEnumerator() + { + return GetEnumerator(); + } + + public ObjectType Current { get; private set; } + + public void Dispose() + { + } + + object IEnumerator.Current + { + get { return Current; } + } + + public bool MoveNext() + { + if (_pos >= _end) + { + return false; + } + Current = _buffer.Get(_pos); + _pos += Size; + return true; + } + + public void Reset() + { + throw new NotSupportedException(); + } + } +} diff --git a/net/FlatBuffers/Enumerables/FlatBufferFloatEnumerable.cs b/net/FlatBuffers/Enumerables/FlatBufferFloatEnumerable.cs new file mode 100644 index 00000000000..8c52181fd3c --- /dev/null +++ b/net/FlatBuffers/Enumerables/FlatBufferFloatEnumerable.cs @@ -0,0 +1,60 @@ +using System; +using System.Collections; +using System.Collections.Generic; + +namespace FlatBuffers +{ + using ObjectType = Single; + + public class FlatBufferFloatEnumerable : IEnumerable, IEnumerator + { + private int _pos; + private readonly int _end; + private readonly ByteBuffer _buffer; + private const int Size = sizeof(ObjectType); + + public FlatBufferFloatEnumerable(int pos, int length, ByteBuffer buffer) + { + _pos = pos; + _end = pos + Size * length; + _buffer = buffer; + } + + public IEnumerator GetEnumerator() + { + return this; + } + + IEnumerator IEnumerable.GetEnumerator() + { + return GetEnumerator(); + } + + public ObjectType Current { get; private set; } + + public void Dispose() + { + } + + object IEnumerator.Current + { + get { return Current; } + } + + public bool MoveNext() + { + if (_pos >= _end) + { + return false; + } + Current = _buffer.GetFloat(_pos); + _pos += Size; + return true; + } + + public void Reset() + { + throw new NotSupportedException(); + } + } +} diff --git a/net/FlatBuffers/Enumerables/FlatBufferIntEnumerable.cs b/net/FlatBuffers/Enumerables/FlatBufferIntEnumerable.cs new file mode 100644 index 00000000000..9baa02bd4c9 --- /dev/null +++ b/net/FlatBuffers/Enumerables/FlatBufferIntEnumerable.cs @@ -0,0 +1,60 @@ +using System; +using System.Collections; +using System.Collections.Generic; + +namespace FlatBuffers +{ + using ObjectType = Int32; + + public class FlatBufferIntEnumerable : IEnumerable, IEnumerator + { + private int _pos; + private readonly int _end; + private readonly ByteBuffer _buffer; + private const int Size = sizeof(ObjectType); + + public FlatBufferIntEnumerable(int pos, int length, ByteBuffer buffer) + { + _pos = pos; + _end = pos + Size * length; + _buffer = buffer; + } + + public IEnumerator GetEnumerator() + { + return this; + } + + IEnumerator IEnumerable.GetEnumerator() + { + return GetEnumerator(); + } + + public ObjectType Current { get; private set; } + + public void Dispose() + { + } + + object IEnumerator.Current + { + get { return Current; } + } + + public bool MoveNext() + { + if (_pos >= _end) + { + return false; + } + Current = _buffer.GetInt(_pos); + _pos += Size; + return true; + } + + public void Reset() + { + throw new NotSupportedException(); + } + } +} diff --git a/net/FlatBuffers/Enumerables/FlatBufferLongEnumerable.cs b/net/FlatBuffers/Enumerables/FlatBufferLongEnumerable.cs new file mode 100644 index 00000000000..c0219b51bcd --- /dev/null +++ b/net/FlatBuffers/Enumerables/FlatBufferLongEnumerable.cs @@ -0,0 +1,60 @@ +using System; +using System.Collections; +using System.Collections.Generic; + +namespace FlatBuffers +{ + using ObjectType = Int64; + + public class FlatBufferLongEnumerable : IEnumerable, IEnumerator + { + private int _pos; + private readonly int _end; + private readonly ByteBuffer _buffer; + private const int Size = sizeof(ObjectType); + + public FlatBufferLongEnumerable(int pos, int length, ByteBuffer buffer) + { + _pos = pos; + _end = pos + Size * length; + _buffer = buffer; + } + + public IEnumerator GetEnumerator() + { + return this; + } + + IEnumerator IEnumerable.GetEnumerator() + { + return GetEnumerator(); + } + + public ObjectType Current { get; private set; } + + public void Dispose() + { + } + + object IEnumerator.Current + { + get { return Current; } + } + + public bool MoveNext() + { + if (_pos >= _end) + { + return false; + } + Current = _buffer.GetLong(_pos); + _pos += Size; + return true; + } + + public void Reset() + { + throw new NotSupportedException(); + } + } +} diff --git a/net/FlatBuffers/Enumerables/FlatBufferObjectEnumerable.cs b/net/FlatBuffers/Enumerables/FlatBufferObjectEnumerable.cs new file mode 100644 index 00000000000..70d052e9963 --- /dev/null +++ b/net/FlatBuffers/Enumerables/FlatBufferObjectEnumerable.cs @@ -0,0 +1,60 @@ +using System; +using System.Collections; +using System.Collections.Generic; + +namespace FlatBuffers +{ + public class FlatBufferObjectEnumerable : IEnumerable, IEnumerator + where T : Table, new() + { + private int _pos; + private readonly int _end; + private readonly ByteBuffer _buffer; + private const int Size = sizeof(int); + + public FlatBufferObjectEnumerable(int pos, int length, ByteBuffer buffer) + { + _pos = pos; + _end = pos + Size * length; + _buffer = buffer; + } + + public IEnumerator GetEnumerator() + { + return this; + } + + IEnumerator IEnumerable.GetEnumerator() + { + return GetEnumerator(); + } + + public T Current { get; private set; } + + public void Dispose() + { + } + + object IEnumerator.Current + { + get { return Current; } + } + + public bool MoveNext() + { + if (_pos >= _end) + { + return false; + } + Current = new T(); + Current.Initialize(_pos, _buffer); + _pos += Size; + return true; + } + + public void Reset() + { + throw new NotSupportedException(); + } + } +} diff --git a/net/FlatBuffers/Enumerables/FlatBufferSbyteEnumerable.cs b/net/FlatBuffers/Enumerables/FlatBufferSbyteEnumerable.cs new file mode 100644 index 00000000000..364917473a2 --- /dev/null +++ b/net/FlatBuffers/Enumerables/FlatBufferSbyteEnumerable.cs @@ -0,0 +1,60 @@ +using System; +using System.Collections; +using System.Collections.Generic; + +namespace FlatBuffers +{ + using ObjectType = SByte; + + public class FlatBufferSbyteEnumerable : IEnumerable, IEnumerator + { + private int _pos; + private readonly int _end; + private readonly ByteBuffer _buffer; + private const int Size = sizeof(ObjectType); + + public FlatBufferSbyteEnumerable(int pos, int length, ByteBuffer buffer) + { + _pos = pos; + _end = pos + Size * length; + _buffer = buffer; + } + + public IEnumerator GetEnumerator() + { + return this; + } + + IEnumerator IEnumerable.GetEnumerator() + { + return GetEnumerator(); + } + + public ObjectType Current { get; private set; } + + public void Dispose() + { + } + + object IEnumerator.Current + { + get { return Current; } + } + + public bool MoveNext() + { + if (_pos >= _end) + { + return false; + } + Current = _buffer.GetSbyte(_pos); + _pos += Size; + return true; + } + + public void Reset() + { + throw new NotSupportedException(); + } + } +} diff --git a/net/FlatBuffers/Enumerables/FlatBufferShortEnumerable.cs b/net/FlatBuffers/Enumerables/FlatBufferShortEnumerable.cs new file mode 100644 index 00000000000..2a2af4fa540 --- /dev/null +++ b/net/FlatBuffers/Enumerables/FlatBufferShortEnumerable.cs @@ -0,0 +1,60 @@ +using System; +using System.Collections; +using System.Collections.Generic; + +namespace FlatBuffers +{ + using ObjectType = Int16; + + public class FlatBufferShortEnumerable : IEnumerable, IEnumerator + { + private int _pos; + private readonly int _end; + private readonly ByteBuffer _buffer; + private const int Size = sizeof(ObjectType); + + public FlatBufferShortEnumerable(int pos, int length, ByteBuffer buffer) + { + _pos = pos; + _end = pos + Size * length; + _buffer = buffer; + } + + public IEnumerator GetEnumerator() + { + return this; + } + + IEnumerator IEnumerable.GetEnumerator() + { + return GetEnumerator(); + } + + public ObjectType Current { get; private set; } + + public void Dispose() + { + } + + object IEnumerator.Current + { + get { return Current; } + } + + public bool MoveNext() + { + if (_pos >= _end) + { + return false; + } + Current = _buffer.GetShort(_pos); + _pos += Size; + return true; + } + + public void Reset() + { + throw new NotSupportedException(); + } + } +} diff --git a/net/FlatBuffers/Enumerables/FlatBufferStringEnumerable.cs b/net/FlatBuffers/Enumerables/FlatBufferStringEnumerable.cs new file mode 100644 index 00000000000..22958cf6507 --- /dev/null +++ b/net/FlatBuffers/Enumerables/FlatBufferStringEnumerable.cs @@ -0,0 +1,62 @@ +using System; +using System.Collections; +using System.Collections.Generic; + +namespace FlatBuffers +{ + using ObjectType = String; + + public class FlatBufferStringEnumerable : IEnumerable, IEnumerator + { + private int _pos; + private readonly int _end; + private readonly ByteBuffer _buffer; + private const int Size = sizeof(int); + + public FlatBufferStringEnumerable(int pos, int length, ByteBuffer buffer) + { + _pos = pos; + _end = pos + Size * length; + _buffer = buffer; + } + + public IEnumerator GetEnumerator() + { + return this; + } + + IEnumerator IEnumerable.GetEnumerator() + { + return GetEnumerator(); + } + + public ObjectType Current { get; private set; } + + public void Dispose() + { + } + + object IEnumerator.Current + { + get { return Current; } + } + + public bool MoveNext() + { + if (_pos >= _end) + { + return false; + } + int stringPos = _pos + _buffer.GetInt(_pos); + var len = _buffer.GetInt(stringPos); + Current = Table.StringEncoding.GetString(_buffer.Data, stringPos + sizeof(int), len); + _pos += Size; + return true; + } + + public void Reset() + { + throw new NotSupportedException(); + } + } +} diff --git a/net/FlatBuffers/Enumerables/FlatBufferStructEnumerable.cs b/net/FlatBuffers/Enumerables/FlatBufferStructEnumerable.cs new file mode 100644 index 00000000000..81f55eb6d15 --- /dev/null +++ b/net/FlatBuffers/Enumerables/FlatBufferStructEnumerable.cs @@ -0,0 +1,61 @@ +using System; +using System.Collections; +using System.Collections.Generic; + +namespace FlatBuffers +{ + public class FlatBufferStructEnumerable : IEnumerable, IEnumerator + where T : Struct, new() + { + private int _pos; + private readonly int _end; + private readonly int _size; + private readonly ByteBuffer _buffer; + + public FlatBufferStructEnumerable(int pos, int length, int size, ByteBuffer buffer) + { + _pos = pos; + _end = pos + size * length; + _size = size; + _buffer = buffer; + } + + public IEnumerator GetEnumerator() + { + return this; + } + + IEnumerator IEnumerable.GetEnumerator() + { + return GetEnumerator(); + } + + public T Current { get; private set; } + + public void Dispose() + { + } + + object IEnumerator.Current + { + get { return Current; } + } + + public bool MoveNext() + { + if (_pos >= _end) + { + return false; + } + Current = new T(); + Current.Initialize(_pos, _buffer); + _pos += _size; + return true; + } + + public void Reset() + { + throw new NotSupportedException(); + } + } +} diff --git a/net/FlatBuffers/Enumerables/FlatBufferUintEnumerable.cs b/net/FlatBuffers/Enumerables/FlatBufferUintEnumerable.cs new file mode 100644 index 00000000000..999991dc461 --- /dev/null +++ b/net/FlatBuffers/Enumerables/FlatBufferUintEnumerable.cs @@ -0,0 +1,60 @@ +using System; +using System.Collections; +using System.Collections.Generic; + +namespace FlatBuffers +{ + using ObjectType = UInt32; + + public class FlatBufferUintEnumerable : IEnumerable, IEnumerator + { + private int _pos; + private readonly int _end; + private readonly ByteBuffer _buffer; + private const int Size = sizeof(ObjectType); + + public FlatBufferUintEnumerable(int pos, int length, ByteBuffer buffer) + { + _pos = pos; + _end = pos + Size * length; + _buffer = buffer; + } + + public IEnumerator GetEnumerator() + { + return this; + } + + IEnumerator IEnumerable.GetEnumerator() + { + return GetEnumerator(); + } + + public ObjectType Current { get; private set; } + + public void Dispose() + { + } + + object IEnumerator.Current + { + get { return Current; } + } + + public bool MoveNext() + { + if (_pos >= _end) + { + return false; + } + Current = _buffer.GetUint(_pos); + _pos += Size; + return true; + } + + public void Reset() + { + throw new NotSupportedException(); + } + } +} diff --git a/net/FlatBuffers/Enumerables/FlatBufferUlongEnumerable.cs b/net/FlatBuffers/Enumerables/FlatBufferUlongEnumerable.cs new file mode 100644 index 00000000000..5ef727d5234 --- /dev/null +++ b/net/FlatBuffers/Enumerables/FlatBufferUlongEnumerable.cs @@ -0,0 +1,60 @@ +using System; +using System.Collections; +using System.Collections.Generic; + +namespace FlatBuffers +{ + using ObjectType = UInt64; + + public class FlatBufferUlongEnumerable : IEnumerable, IEnumerator + { + private int _pos; + private readonly int _end; + private readonly ByteBuffer _buffer; + private const int Size = sizeof(ObjectType); + + public FlatBufferUlongEnumerable(int pos, int length, ByteBuffer buffer) + { + _pos = pos; + _end = pos + Size * length; + _buffer = buffer; + } + + public IEnumerator GetEnumerator() + { + return this; + } + + IEnumerator IEnumerable.GetEnumerator() + { + return GetEnumerator(); + } + + public ObjectType Current { get; private set; } + + public void Dispose() + { + } + + object IEnumerator.Current + { + get { return Current; } + } + + public bool MoveNext() + { + if (_pos >= _end) + { + return false; + } + Current = _buffer.GetUlong(_pos); + _pos += Size; + return true; + } + + public void Reset() + { + throw new NotSupportedException(); + } + } +} diff --git a/net/FlatBuffers/Enumerables/FlatBufferUshortEnumerable.cs b/net/FlatBuffers/Enumerables/FlatBufferUshortEnumerable.cs new file mode 100644 index 00000000000..d9afba06a3a --- /dev/null +++ b/net/FlatBuffers/Enumerables/FlatBufferUshortEnumerable.cs @@ -0,0 +1,60 @@ +using System; +using System.Collections; +using System.Collections.Generic; + +namespace FlatBuffers +{ + using ObjectType = UInt16; + + public class FlatBufferUshortEnumerable : IEnumerable, IEnumerator + { + private int _pos; + private readonly int _end; + private readonly ByteBuffer _buffer; + private const int Size = sizeof(ObjectType); + + public FlatBufferUshortEnumerable(int pos, int length, ByteBuffer buffer) + { + _pos = pos; + _end = pos + Size * length; + _buffer = buffer; + } + + public IEnumerator GetEnumerator() + { + return this; + } + + IEnumerator IEnumerable.GetEnumerator() + { + return GetEnumerator(); + } + + public ObjectType Current { get; private set; } + + public void Dispose() + { + } + + object IEnumerator.Current + { + get { return Current; } + } + + public bool MoveNext() + { + if (_pos >= _end) + { + return false; + } + Current = _buffer.GetUshort(_pos); + _pos += Size; + return true; + } + + public void Reset() + { + throw new NotSupportedException(); + } + } +} diff --git a/net/FlatBuffers/FlatBufferConstants.cs b/net/FlatBuffers/FlatBufferConstants.cs index 162ed192343..54364af398f 100644 --- a/net/FlatBuffers/FlatBufferConstants.cs +++ b/net/FlatBuffers/FlatBufferConstants.cs @@ -14,11 +14,6 @@ * limitations under the License. */ -using System; -using System.Collections.Generic; -using System.Linq; -using System.Text; - namespace FlatBuffers { public static class FlatBufferConstants diff --git a/net/FlatBuffers/FlatBuffers.csproj b/net/FlatBuffers/FlatBuffers.csproj index 3ae938a156e..f7e54da7082 100644 --- a/net/FlatBuffers/FlatBuffers.csproj +++ b/net/FlatBuffers/FlatBuffers.csproj @@ -35,6 +35,19 @@ + + + + + + + + + + + + + diff --git a/net/FlatBuffers/Struct.cs b/net/FlatBuffers/Struct.cs index 4cd280124b1..dc7e403fb85 100644 --- a/net/FlatBuffers/Struct.cs +++ b/net/FlatBuffers/Struct.cs @@ -23,5 +23,11 @@ public abstract class Struct { protected int bb_pos; protected ByteBuffer bb; + + internal void Initialize(int pos, ByteBuffer buffer) + { + bb_pos = pos; + bb = buffer; + } } } \ No newline at end of file diff --git a/net/FlatBuffers/Table.cs b/net/FlatBuffers/Table.cs index 1a097d371c8..a778c6e8fd3 100644 --- a/net/FlatBuffers/Table.cs +++ b/net/FlatBuffers/Table.cs @@ -24,6 +24,8 @@ namespace FlatBuffers /// public abstract class Table { + internal static readonly UTF8Encoding StringEncoding = (UTF8Encoding)Encoding.UTF8; + protected int bb_pos; protected ByteBuffer bb; @@ -32,7 +34,7 @@ public abstract class Table protected int __offset(int vtableOffset) { int vtable = bb_pos - bb.GetInt(bb_pos); - return vtableOffset < bb.GetShort(vtable) ? (int)bb.GetShort(vtable + vtableOffset) : 0; + return vtableOffset < bb.GetShort(vtable) ? bb.GetShort(vtable + vtableOffset) : 0; } // Retrieve the relative offset stored at "offset" @@ -47,7 +49,7 @@ protected string __string(int offset) offset += bb.GetInt(offset); var len = bb.GetInt(offset); var startPos = offset + sizeof(int); - return Encoding.UTF8.GetString(bb.Data, startPos , len); + return StringEncoding.GetString(bb.Data, startPos, len); } // Get the length of a vector whose offset is stored at "offset" in this object. @@ -87,6 +89,10 @@ protected static bool __has_identifier(ByteBuffer bb, string ident) return true; } - + internal void Initialize(int pos, ByteBuffer buffer) + { + bb_pos = __indirect(pos); + bb = buffer; + } } } diff --git a/src/idl_gen_general.cpp b/src/idl_gen_general.cpp index b2b71465ee3..b13fb66bc25 100644 --- a/src/idl_gen_general.cpp +++ b/src/idl_gen_general.cpp @@ -728,6 +728,34 @@ static void GenStruct(const LanguageParameters &lang, const Parser &parser, code += "__vector_len(o) : 0; "; code += lang.getter_suffix; code += "}\n"; + if (lang.language == GeneratorOptions::kCSharp) { + + code += " public System.Collections.Generic.IEnumerable<" + type_name_dest + "> Get" + MakeCamel(field.name, lang.first_camel_upper) + "Enumerable()"; + code += offset_prefix; + + auto vectortype = field.value.type.VectorType(); + code += "new FlatBuffer"; + if (vectortype.base_type != BASE_TYPE_STRUCT) { + code += MakeCamel(GenTypeGet(lang, field.value.type)); + } + else if (vectortype.struct_def->fixed) { + code += "Struct"; + } + else { + code += "Object"; + } + code += "Enumerable"; + if (vectortype.base_type == BASE_TYPE_STRUCT) { + code += "<" + type_name_dest + ">"; + } + code += "(__vector(o), __vector_len(o), "; + if (vectortype.base_type == BASE_TYPE_STRUCT && vectortype.struct_def->fixed) { + code += NumToString(InlineSize(vectortype)) + ", "; + } + code += "bb) : System.Linq.Enumerable.Empty<" + type_name_dest + ">(); "; + code += lang.getter_suffix; + code += "\n"; + } } // Generate a ByteBuffer accessor for strings & vectors of scalars. if (((field.value.type.base_type == BASE_TYPE_VECTOR &&