Example #1
0
 public LargeDeltas(
     Bools b1,
     Bools b10,
     Bools b100,
     bool? checkTrue,
     Bools b1000,
     bool? checkFalse,
     VersioningTestV2 vertwo2000,
     HashSet<string> aSet2500,
     VersioningTestV2 vertwo3000,
     List<int?> bigNumbers
 ) {
     this.B1 = b1;
     this.B10 = b10;
     this.B100 = b100;
     this.CheckTrue = checkTrue;
     this.B1000 = b1000;
     this.CheckFalse = checkFalse;
     this.Vertwo2000 = vertwo2000;
     this.ASet2500 = aSet2500;
     this.Vertwo3000 = vertwo3000;
     this.BigNumbers = bigNumbers;
 }
        public void Read(TProtocol iprot)
        {
            iprot.IncrementRecursionDepth();
            try
            {
                TField field;
                iprot.ReadStructBegin();
                while (true)
                {
                    field = iprot.ReadFieldBegin();
                    if (field.Type == TType.Stop)
                    {
                        break;
                    }
                    switch (field.ID)
                    {
                    case 1:
                        if (field.Type == TType.Struct)
                        {
                            B1 = new Bools();
                            B1.Read(iprot);
                        }
                        else
                        {
                            TProtocolUtil.Skip(iprot, field.Type);
                        }
                        break;

                    case 10:
                        if (field.Type == TType.Struct)
                        {
                            B10 = new Bools();
                            B10.Read(iprot);
                        }
                        else
                        {
                            TProtocolUtil.Skip(iprot, field.Type);
                        }
                        break;

                    case 100:
                        if (field.Type == TType.Struct)
                        {
                            B100 = new Bools();
                            B100.Read(iprot);
                        }
                        else
                        {
                            TProtocolUtil.Skip(iprot, field.Type);
                        }
                        break;

                    case 500:
                        if (field.Type == TType.Bool)
                        {
                            Check_true = iprot.ReadBool();
                        }
                        else
                        {
                            TProtocolUtil.Skip(iprot, field.Type);
                        }
                        break;

                    case 1000:
                        if (field.Type == TType.Struct)
                        {
                            B1000 = new Bools();
                            B1000.Read(iprot);
                        }
                        else
                        {
                            TProtocolUtil.Skip(iprot, field.Type);
                        }
                        break;

                    case 1500:
                        if (field.Type == TType.Bool)
                        {
                            Check_false = iprot.ReadBool();
                        }
                        else
                        {
                            TProtocolUtil.Skip(iprot, field.Type);
                        }
                        break;

                    case 2000:
                        if (field.Type == TType.Struct)
                        {
                            Vertwo2000 = new VersioningTestV2();
                            Vertwo2000.Read(iprot);
                        }
                        else
                        {
                            TProtocolUtil.Skip(iprot, field.Type);
                        }
                        break;

                    case 2500:
                        if (field.Type == TType.Set)
                        {
                            {
                                A_set2500 = new THashSet <string>();
                                TSet _set75 = iprot.ReadSetBegin();
                                for (int _i76 = 0; _i76 < _set75.Count; ++_i76)
                                {
                                    string _elem77;
                                    _elem77 = iprot.ReadString();
                                    A_set2500.Add(_elem77);
                                }
                                iprot.ReadSetEnd();
                            }
                        }
                        else
                        {
                            TProtocolUtil.Skip(iprot, field.Type);
                        }
                        break;

                    case 3000:
                        if (field.Type == TType.Struct)
                        {
                            Vertwo3000 = new VersioningTestV2();
                            Vertwo3000.Read(iprot);
                        }
                        else
                        {
                            TProtocolUtil.Skip(iprot, field.Type);
                        }
                        break;

                    case 4000:
                        if (field.Type == TType.List)
                        {
                            {
                                Big_numbers = new List <int>();
                                TList _list78 = iprot.ReadListBegin();
                                for (int _i79 = 0; _i79 < _list78.Count; ++_i79)
                                {
                                    int _elem80;
                                    _elem80 = iprot.ReadI32();
                                    Big_numbers.Add(_elem80);
                                }
                                iprot.ReadListEnd();
                            }
                        }
                        else
                        {
                            TProtocolUtil.Skip(iprot, field.Type);
                        }
                        break;

                    default:
                        TProtocolUtil.Skip(iprot, field.Type);
                        break;
                    }
                    iprot.ReadFieldEnd();
                }
                iprot.ReadStructEnd();
            }
            finally
            {
                iprot.DecrementRecursionDepth();
            }
        }
Example #3
0
 public void Read(TProtocol iprot)
 {
     TField field;
     iprot.ReadStructBegin();
     while (true)
     {
         field = iprot.ReadFieldBegin();
         if (field.Type == TType.Stop) { 
             break;
         }
         switch (field.ID)
         {
             case 1:
                 if (field.Type == TType.Struct) {
                     B1 = new Bools();
                     B1.Read(iprot);
                 } else {
                     TProtocolUtil.Skip(iprot, field.Type);
                 }
                 break;
             case 10:
                 if (field.Type == TType.Struct) {
                     B10 = new Bools();
                     B10.Read(iprot);
                 } else {
                     TProtocolUtil.Skip(iprot, field.Type);
                 }
                 break;
             case 100:
                 if (field.Type == TType.Struct) {
                     B100 = new Bools();
                     B100.Read(iprot);
                 } else {
                     TProtocolUtil.Skip(iprot, field.Type);
                 }
                 break;
             case 500:
                 if (field.Type == TType.Bool) {
                     CheckTrue = iprot.ReadBool();
                 } else {
                     TProtocolUtil.Skip(iprot, field.Type);
                 }
                 break;
             case 1000:
                 if (field.Type == TType.Struct) {
                     B1000 = new Bools();
                     B1000.Read(iprot);
                 } else {
                     TProtocolUtil.Skip(iprot, field.Type);
                 }
                 break;
             case 1500:
                 if (field.Type == TType.Bool) {
                     CheckFalse = iprot.ReadBool();
                 } else {
                     TProtocolUtil.Skip(iprot, field.Type);
                 }
                 break;
             case 2000:
                 if (field.Type == TType.Struct) {
                     Vertwo2000 = new VersioningTestV2();
                     Vertwo2000.Read(iprot);
                 } else {
                     TProtocolUtil.Skip(iprot, field.Type);
                 }
                 break;
             case 2500:
                 if (field.Type == TType.Set) {
                     {
                         ASet2500 = new HashSet<string>();
                         TSet _set0 = iprot.ReadSetBegin();
                         for(int _i1 = 0; _i1 < _set0.Count; ++_i1)
                         {
                             string _elem2 = null;
                             _elem2 = iprot.ReadString();
                             ASet2500.Add(_elem2);
                         }
                         iprot.ReadSetEnd();
                     }
                 } else {
                     TProtocolUtil.Skip(iprot, field.Type);
                 }
                 break;
             case 3000:
                 if (field.Type == TType.Struct) {
                     Vertwo3000 = new VersioningTestV2();
                     Vertwo3000.Read(iprot);
                 } else {
                     TProtocolUtil.Skip(iprot, field.Type);
                 }
                 break;
             case 4000:
                 if (field.Type == TType.List) {
                     {
                         BigNumbers = new List<int?>();
                         TList _list3 = iprot.ReadListBegin();
                         for(int _i4 = 0; _i4 < _list3.Count; ++_i4)
                         {
                             int? _elem5 = 0;
                             _elem5 = iprot.ReadI32();
                             BigNumbers.Add(_elem5);
                         }
                         iprot.ReadListEnd();
                     }
                 } else {
                     TProtocolUtil.Skip(iprot, field.Type);
                 }
                 break;
             default:
                 TProtocolUtil.Skip(iprot, field.Type);
                 break;
         }
         iprot.ReadFieldEnd();
     }
     iprot.ReadStructEnd();
 }