| /** |
| * Autogenerated by Thrift Compiler (0.14.1) |
| * |
| * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING |
| * @generated |
| */ |
| using System; |
| using System.Collections; |
| using System.Collections.Generic; |
| using System.Text; |
| using System.IO; |
| using System.Linq; |
| using System.Threading; |
| using System.Threading.Tasks; |
| using Microsoft.Extensions.Logging; |
| using Thrift; |
| using Thrift.Collections; |
| |
| using Thrift.Protocol; |
| using Thrift.Protocol.Entities; |
| using Thrift.Protocol.Utilities; |
| using Thrift.Transport; |
| using Thrift.Transport.Client; |
| using Thrift.Transport.Server; |
| using Thrift.Processor; |
| |
| |
| #pragma warning disable IDE0079 // remove unnecessary pragmas |
| #pragma warning disable IDE1006 // parts of the code use IDL spelling |
| |
| |
| public partial class TSInsertTabletReq : TBase |
| { |
| private bool _isAligned; |
| private bool _writeToTable; |
| private List<sbyte> _columnCategories; |
| private bool _isCompressed; |
| private List<sbyte> _encodingTypes; |
| private sbyte _compressType; |
| |
| public long SessionId { get; set; } |
| |
| public string PrefixPath { get; set; } |
| |
| public List<string> Measurements { get; set; } |
| |
| public byte[] Values { get; set; } |
| |
| public byte[] Timestamps { get; set; } |
| |
| public List<int> Types { get; set; } |
| |
| public int Size { get; set; } |
| |
| public bool IsAligned |
| { |
| get |
| { |
| return _isAligned; |
| } |
| set |
| { |
| __isset.isAligned = true; |
| this._isAligned = value; |
| } |
| } |
| |
| public bool WriteToTable |
| { |
| get |
| { |
| return _writeToTable; |
| } |
| set |
| { |
| __isset.writeToTable = true; |
| this._writeToTable = value; |
| } |
| } |
| |
| public List<sbyte> ColumnCategories |
| { |
| get |
| { |
| return _columnCategories; |
| } |
| set |
| { |
| __isset.columnCategories = true; |
| this._columnCategories = value; |
| } |
| } |
| |
| public bool IsCompressed |
| { |
| get |
| { |
| return _isCompressed; |
| } |
| set |
| { |
| __isset.isCompressed = true; |
| this._isCompressed = value; |
| } |
| } |
| |
| public List<sbyte> EncodingTypes |
| { |
| get |
| { |
| return _encodingTypes; |
| } |
| set |
| { |
| __isset.encodingTypes = true; |
| this._encodingTypes = value; |
| } |
| } |
| |
| public sbyte CompressType |
| { |
| get |
| { |
| return _compressType; |
| } |
| set |
| { |
| __isset.compressType = true; |
| this._compressType = value; |
| } |
| } |
| |
| |
| public Isset __isset; |
| public struct Isset |
| { |
| public bool isAligned; |
| public bool writeToTable; |
| public bool columnCategories; |
| public bool isCompressed; |
| public bool encodingTypes; |
| public bool compressType; |
| } |
| |
| public TSInsertTabletReq() |
| { |
| } |
| |
| public TSInsertTabletReq(long sessionId, string prefixPath, List<string> measurements, byte[] values, byte[] timestamps, List<int> types, int size) : this() |
| { |
| this.SessionId = sessionId; |
| this.PrefixPath = prefixPath; |
| this.Measurements = measurements; |
| this.Values = values; |
| this.Timestamps = timestamps; |
| this.Types = types; |
| this.Size = size; |
| } |
| |
| public async global::System.Threading.Tasks.Task ReadAsync(TProtocol iprot, CancellationToken cancellationToken) |
| { |
| iprot.IncrementRecursionDepth(); |
| try |
| { |
| bool isset_sessionId = false; |
| bool isset_prefixPath = false; |
| bool isset_measurements = false; |
| bool isset_values = false; |
| bool isset_timestamps = false; |
| bool isset_types = false; |
| bool isset_size = false; |
| TField field; |
| await iprot.ReadStructBeginAsync(cancellationToken); |
| while (true) |
| { |
| field = await iprot.ReadFieldBeginAsync(cancellationToken); |
| if (field.Type == TType.Stop) |
| { |
| break; |
| } |
| |
| switch (field.ID) |
| { |
| case 1: |
| if (field.Type == TType.I64) |
| { |
| SessionId = await iprot.ReadI64Async(cancellationToken); |
| isset_sessionId = true; |
| } |
| else |
| { |
| await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken); |
| } |
| break; |
| case 2: |
| if (field.Type == TType.String) |
| { |
| PrefixPath = await iprot.ReadStringAsync(cancellationToken); |
| isset_prefixPath = true; |
| } |
| else |
| { |
| await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken); |
| } |
| break; |
| case 3: |
| if (field.Type == TType.List) |
| { |
| { |
| TList _list111 = await iprot.ReadListBeginAsync(cancellationToken); |
| Measurements = new List<string>(_list111.Count); |
| for(int _i112 = 0; _i112 < _list111.Count; ++_i112) |
| { |
| string _elem113; |
| _elem113 = await iprot.ReadStringAsync(cancellationToken); |
| Measurements.Add(_elem113); |
| } |
| await iprot.ReadListEndAsync(cancellationToken); |
| } |
| isset_measurements = true; |
| } |
| else |
| { |
| await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken); |
| } |
| break; |
| case 4: |
| if (field.Type == TType.String) |
| { |
| Values = await iprot.ReadBinaryAsync(cancellationToken); |
| isset_values = true; |
| } |
| else |
| { |
| await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken); |
| } |
| break; |
| case 5: |
| if (field.Type == TType.String) |
| { |
| Timestamps = await iprot.ReadBinaryAsync(cancellationToken); |
| isset_timestamps = true; |
| } |
| else |
| { |
| await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken); |
| } |
| break; |
| case 6: |
| if (field.Type == TType.List) |
| { |
| { |
| TList _list114 = await iprot.ReadListBeginAsync(cancellationToken); |
| Types = new List<int>(_list114.Count); |
| for(int _i115 = 0; _i115 < _list114.Count; ++_i115) |
| { |
| int _elem116; |
| _elem116 = await iprot.ReadI32Async(cancellationToken); |
| Types.Add(_elem116); |
| } |
| await iprot.ReadListEndAsync(cancellationToken); |
| } |
| isset_types = true; |
| } |
| else |
| { |
| await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken); |
| } |
| break; |
| case 7: |
| if (field.Type == TType.I32) |
| { |
| Size = await iprot.ReadI32Async(cancellationToken); |
| isset_size = true; |
| } |
| else |
| { |
| await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken); |
| } |
| break; |
| case 8: |
| if (field.Type == TType.Bool) |
| { |
| IsAligned = await iprot.ReadBoolAsync(cancellationToken); |
| } |
| else |
| { |
| await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken); |
| } |
| break; |
| case 9: |
| if (field.Type == TType.Bool) |
| { |
| WriteToTable = await iprot.ReadBoolAsync(cancellationToken); |
| } |
| else |
| { |
| await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken); |
| } |
| break; |
| case 10: |
| if (field.Type == TType.List) |
| { |
| { |
| TList _list117 = await iprot.ReadListBeginAsync(cancellationToken); |
| ColumnCategories = new List<sbyte>(_list117.Count); |
| for(int _i118 = 0; _i118 < _list117.Count; ++_i118) |
| { |
| sbyte _elem119; |
| _elem119 = await iprot.ReadByteAsync(cancellationToken); |
| ColumnCategories.Add(_elem119); |
| } |
| await iprot.ReadListEndAsync(cancellationToken); |
| } |
| } |
| else |
| { |
| await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken); |
| } |
| break; |
| case 11: |
| if (field.Type == TType.Bool) |
| { |
| IsCompressed = await iprot.ReadBoolAsync(cancellationToken); |
| } |
| else |
| { |
| await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken); |
| } |
| break; |
| case 12: |
| if (field.Type == TType.List) |
| { |
| { |
| TList _list120 = await iprot.ReadListBeginAsync(cancellationToken); |
| EncodingTypes = new List<sbyte>(_list120.Count); |
| for(int _i121 = 0; _i121 < _list120.Count; ++_i121) |
| { |
| sbyte _elem122; |
| _elem122 = await iprot.ReadByteAsync(cancellationToken); |
| EncodingTypes.Add(_elem122); |
| } |
| await iprot.ReadListEndAsync(cancellationToken); |
| } |
| } |
| else |
| { |
| await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken); |
| } |
| break; |
| case 13: |
| if (field.Type == TType.Byte) |
| { |
| CompressType = await iprot.ReadByteAsync(cancellationToken); |
| } |
| else |
| { |
| await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken); |
| } |
| break; |
| default: |
| await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken); |
| break; |
| } |
| |
| await iprot.ReadFieldEndAsync(cancellationToken); |
| } |
| |
| await iprot.ReadStructEndAsync(cancellationToken); |
| if (!isset_sessionId) |
| { |
| throw new TProtocolException(TProtocolException.INVALID_DATA); |
| } |
| if (!isset_prefixPath) |
| { |
| throw new TProtocolException(TProtocolException.INVALID_DATA); |
| } |
| if (!isset_measurements) |
| { |
| throw new TProtocolException(TProtocolException.INVALID_DATA); |
| } |
| if (!isset_values) |
| { |
| throw new TProtocolException(TProtocolException.INVALID_DATA); |
| } |
| if (!isset_timestamps) |
| { |
| throw new TProtocolException(TProtocolException.INVALID_DATA); |
| } |
| if (!isset_types) |
| { |
| throw new TProtocolException(TProtocolException.INVALID_DATA); |
| } |
| if (!isset_size) |
| { |
| throw new TProtocolException(TProtocolException.INVALID_DATA); |
| } |
| } |
| finally |
| { |
| iprot.DecrementRecursionDepth(); |
| } |
| } |
| |
| public async global::System.Threading.Tasks.Task WriteAsync(TProtocol oprot, CancellationToken cancellationToken) |
| { |
| oprot.IncrementRecursionDepth(); |
| try |
| { |
| var struc = new TStruct("TSInsertTabletReq"); |
| await oprot.WriteStructBeginAsync(struc, cancellationToken); |
| var field = new TField(); |
| field.Name = "sessionId"; |
| field.Type = TType.I64; |
| field.ID = 1; |
| await oprot.WriteFieldBeginAsync(field, cancellationToken); |
| await oprot.WriteI64Async(SessionId, cancellationToken); |
| await oprot.WriteFieldEndAsync(cancellationToken); |
| if((PrefixPath != null)) |
| { |
| field.Name = "prefixPath"; |
| field.Type = TType.String; |
| field.ID = 2; |
| await oprot.WriteFieldBeginAsync(field, cancellationToken); |
| await oprot.WriteStringAsync(PrefixPath, cancellationToken); |
| await oprot.WriteFieldEndAsync(cancellationToken); |
| } |
| if((Measurements != null)) |
| { |
| field.Name = "measurements"; |
| field.Type = TType.List; |
| field.ID = 3; |
| await oprot.WriteFieldBeginAsync(field, cancellationToken); |
| { |
| await oprot.WriteListBeginAsync(new TList(TType.String, Measurements.Count), cancellationToken); |
| foreach (string _iter123 in Measurements) |
| { |
| await oprot.WriteStringAsync(_iter123, cancellationToken); |
| } |
| await oprot.WriteListEndAsync(cancellationToken); |
| } |
| await oprot.WriteFieldEndAsync(cancellationToken); |
| } |
| if((Values != null)) |
| { |
| field.Name = "values"; |
| field.Type = TType.String; |
| field.ID = 4; |
| await oprot.WriteFieldBeginAsync(field, cancellationToken); |
| await oprot.WriteBinaryAsync(Values, cancellationToken); |
| await oprot.WriteFieldEndAsync(cancellationToken); |
| } |
| if((Timestamps != null)) |
| { |
| field.Name = "timestamps"; |
| field.Type = TType.String; |
| field.ID = 5; |
| await oprot.WriteFieldBeginAsync(field, cancellationToken); |
| await oprot.WriteBinaryAsync(Timestamps, cancellationToken); |
| await oprot.WriteFieldEndAsync(cancellationToken); |
| } |
| if((Types != null)) |
| { |
| field.Name = "types"; |
| field.Type = TType.List; |
| field.ID = 6; |
| await oprot.WriteFieldBeginAsync(field, cancellationToken); |
| { |
| await oprot.WriteListBeginAsync(new TList(TType.I32, Types.Count), cancellationToken); |
| foreach (int _iter124 in Types) |
| { |
| await oprot.WriteI32Async(_iter124, cancellationToken); |
| } |
| await oprot.WriteListEndAsync(cancellationToken); |
| } |
| await oprot.WriteFieldEndAsync(cancellationToken); |
| } |
| field.Name = "size"; |
| field.Type = TType.I32; |
| field.ID = 7; |
| await oprot.WriteFieldBeginAsync(field, cancellationToken); |
| await oprot.WriteI32Async(Size, cancellationToken); |
| await oprot.WriteFieldEndAsync(cancellationToken); |
| if(__isset.isAligned) |
| { |
| field.Name = "isAligned"; |
| field.Type = TType.Bool; |
| field.ID = 8; |
| await oprot.WriteFieldBeginAsync(field, cancellationToken); |
| await oprot.WriteBoolAsync(IsAligned, cancellationToken); |
| await oprot.WriteFieldEndAsync(cancellationToken); |
| } |
| if(__isset.writeToTable) |
| { |
| field.Name = "writeToTable"; |
| field.Type = TType.Bool; |
| field.ID = 9; |
| await oprot.WriteFieldBeginAsync(field, cancellationToken); |
| await oprot.WriteBoolAsync(WriteToTable, cancellationToken); |
| await oprot.WriteFieldEndAsync(cancellationToken); |
| } |
| if((ColumnCategories != null) && __isset.columnCategories) |
| { |
| field.Name = "columnCategories"; |
| field.Type = TType.List; |
| field.ID = 10; |
| await oprot.WriteFieldBeginAsync(field, cancellationToken); |
| { |
| await oprot.WriteListBeginAsync(new TList(TType.Byte, ColumnCategories.Count), cancellationToken); |
| foreach (sbyte _iter125 in ColumnCategories) |
| { |
| await oprot.WriteByteAsync(_iter125, cancellationToken); |
| } |
| await oprot.WriteListEndAsync(cancellationToken); |
| } |
| await oprot.WriteFieldEndAsync(cancellationToken); |
| } |
| if(__isset.isCompressed) |
| { |
| field.Name = "isCompressed"; |
| field.Type = TType.Bool; |
| field.ID = 11; |
| await oprot.WriteFieldBeginAsync(field, cancellationToken); |
| await oprot.WriteBoolAsync(IsCompressed, cancellationToken); |
| await oprot.WriteFieldEndAsync(cancellationToken); |
| } |
| if((EncodingTypes != null) && __isset.encodingTypes) |
| { |
| field.Name = "encodingTypes"; |
| field.Type = TType.List; |
| field.ID = 12; |
| await oprot.WriteFieldBeginAsync(field, cancellationToken); |
| { |
| await oprot.WriteListBeginAsync(new TList(TType.Byte, EncodingTypes.Count), cancellationToken); |
| foreach (sbyte _iter126 in EncodingTypes) |
| { |
| await oprot.WriteByteAsync(_iter126, cancellationToken); |
| } |
| await oprot.WriteListEndAsync(cancellationToken); |
| } |
| await oprot.WriteFieldEndAsync(cancellationToken); |
| } |
| if(__isset.compressType) |
| { |
| field.Name = "compressType"; |
| field.Type = TType.Byte; |
| field.ID = 13; |
| await oprot.WriteFieldBeginAsync(field, cancellationToken); |
| await oprot.WriteByteAsync(CompressType, cancellationToken); |
| await oprot.WriteFieldEndAsync(cancellationToken); |
| } |
| await oprot.WriteFieldStopAsync(cancellationToken); |
| await oprot.WriteStructEndAsync(cancellationToken); |
| } |
| finally |
| { |
| oprot.DecrementRecursionDepth(); |
| } |
| } |
| |
| public override bool Equals(object that) |
| { |
| if (!(that is TSInsertTabletReq other)) return false; |
| if (ReferenceEquals(this, other)) return true; |
| return System.Object.Equals(SessionId, other.SessionId) |
| && System.Object.Equals(PrefixPath, other.PrefixPath) |
| && TCollections.Equals(Measurements, other.Measurements) |
| && TCollections.Equals(Values, other.Values) |
| && TCollections.Equals(Timestamps, other.Timestamps) |
| && TCollections.Equals(Types, other.Types) |
| && System.Object.Equals(Size, other.Size) |
| && ((__isset.isAligned == other.__isset.isAligned) && ((!__isset.isAligned) || (System.Object.Equals(IsAligned, other.IsAligned)))) |
| && ((__isset.writeToTable == other.__isset.writeToTable) && ((!__isset.writeToTable) || (System.Object.Equals(WriteToTable, other.WriteToTable)))) |
| && ((__isset.columnCategories == other.__isset.columnCategories) && ((!__isset.columnCategories) || (TCollections.Equals(ColumnCategories, other.ColumnCategories)))) |
| && ((__isset.isCompressed == other.__isset.isCompressed) && ((!__isset.isCompressed) || (System.Object.Equals(IsCompressed, other.IsCompressed)))) |
| && ((__isset.encodingTypes == other.__isset.encodingTypes) && ((!__isset.encodingTypes) || (TCollections.Equals(EncodingTypes, other.EncodingTypes)))) |
| && ((__isset.compressType == other.__isset.compressType) && ((!__isset.compressType) || (System.Object.Equals(CompressType, other.CompressType)))); |
| } |
| |
| public override int GetHashCode() { |
| int hashcode = 157; |
| unchecked { |
| hashcode = (hashcode * 397) + SessionId.GetHashCode(); |
| if((PrefixPath != null)) |
| { |
| hashcode = (hashcode * 397) + PrefixPath.GetHashCode(); |
| } |
| if((Measurements != null)) |
| { |
| hashcode = (hashcode * 397) + TCollections.GetHashCode(Measurements); |
| } |
| if((Values != null)) |
| { |
| hashcode = (hashcode * 397) + Values.GetHashCode(); |
| } |
| if((Timestamps != null)) |
| { |
| hashcode = (hashcode * 397) + Timestamps.GetHashCode(); |
| } |
| if((Types != null)) |
| { |
| hashcode = (hashcode * 397) + TCollections.GetHashCode(Types); |
| } |
| hashcode = (hashcode * 397) + Size.GetHashCode(); |
| if(__isset.isAligned) |
| { |
| hashcode = (hashcode * 397) + IsAligned.GetHashCode(); |
| } |
| if(__isset.writeToTable) |
| { |
| hashcode = (hashcode * 397) + WriteToTable.GetHashCode(); |
| } |
| if((ColumnCategories != null) && __isset.columnCategories) |
| { |
| hashcode = (hashcode * 397) + TCollections.GetHashCode(ColumnCategories); |
| } |
| if(__isset.isCompressed) |
| { |
| hashcode = (hashcode * 397) + IsCompressed.GetHashCode(); |
| } |
| if((EncodingTypes != null) && __isset.encodingTypes) |
| { |
| hashcode = (hashcode * 397) + TCollections.GetHashCode(EncodingTypes); |
| } |
| if(__isset.compressType) |
| { |
| hashcode = (hashcode * 397) + CompressType.GetHashCode(); |
| } |
| } |
| return hashcode; |
| } |
| |
| public override string ToString() |
| { |
| var sb = new StringBuilder("TSInsertTabletReq("); |
| sb.Append(", SessionId: "); |
| SessionId.ToString(sb); |
| if((PrefixPath != null)) |
| { |
| sb.Append(", PrefixPath: "); |
| PrefixPath.ToString(sb); |
| } |
| if((Measurements != null)) |
| { |
| sb.Append(", Measurements: "); |
| Measurements.ToString(sb); |
| } |
| if((Values != null)) |
| { |
| sb.Append(", Values: "); |
| Values.ToString(sb); |
| } |
| if((Timestamps != null)) |
| { |
| sb.Append(", Timestamps: "); |
| Timestamps.ToString(sb); |
| } |
| if((Types != null)) |
| { |
| sb.Append(", Types: "); |
| Types.ToString(sb); |
| } |
| sb.Append(", Size: "); |
| Size.ToString(sb); |
| if(__isset.isAligned) |
| { |
| sb.Append(", IsAligned: "); |
| IsAligned.ToString(sb); |
| } |
| if(__isset.writeToTable) |
| { |
| sb.Append(", WriteToTable: "); |
| WriteToTable.ToString(sb); |
| } |
| if((ColumnCategories != null) && __isset.columnCategories) |
| { |
| sb.Append(", ColumnCategories: "); |
| ColumnCategories.ToString(sb); |
| } |
| if(__isset.isCompressed) |
| { |
| sb.Append(", IsCompressed: "); |
| IsCompressed.ToString(sb); |
| } |
| if((EncodingTypes != null) && __isset.encodingTypes) |
| { |
| sb.Append(", EncodingTypes: "); |
| EncodingTypes.ToString(sb); |
| } |
| if(__isset.compressType) |
| { |
| sb.Append(", CompressType: "); |
| CompressType.ToString(sb); |
| } |
| sb.Append(')'); |
| return sb.ToString(); |
| } |
| } |
| |
