ReadMapEnd() public abstract method

public abstract ReadMapEnd ( ) : void
return void
 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.Map) {
           {
             MessageMap = new Dictionary<string, Dictionary<int, string>>();
             TMap _map30 = iprot.ReadMapBegin();
             for( int _i31 = 0; _i31 < _map30.Count; ++_i31)
             {
               string _key32;
               Dictionary<int, string> _val33;
               _key32 = iprot.ReadString();
               {
                 _val33 = new Dictionary<int, string>();
                 TMap _map34 = iprot.ReadMapBegin();
                 for( int _i35 = 0; _i35 < _map34.Count; ++_i35)
                 {
                   int _key36;
                   string _val37;
                   _key36 = iprot.ReadI32();
                   _val37 = iprot.ReadString();
                   _val33[_key36] = _val37;
                 }
                 iprot.ReadMapEnd();
               }
               MessageMap[_key32] = _val33;
             }
             iprot.ReadMapEnd();
           }
         } else { 
           TProtocolUtil.Skip(iprot, field.Type);
         }
         break;
       default: 
         TProtocolUtil.Skip(iprot, field.Type);
         break;
     }
     iprot.ReadFieldEnd();
   }
   iprot.ReadStructEnd();
 }
Ejemplo n.º 2
0
 public void Read(TProtocol iprot)
 {
     TField field;
       TStruct struc = iprot.ReadStructBegin();
       while (true)
       {
     field = iprot.ReadFieldBegin();
     if (field.Type == TType.Stop) {
       break;
     }
     switch (field.ID)
     {
       case 1:
     if (field.Type == TType.String) {
       this.row = iprot.ReadBinary();
       this.__isset.row = true;
     } else {
       TProtocolUtil.Skip(iprot, field.Type);
     }
     break;
       case 2:
     if (field.Type == TType.Map) {
       {
         this.columns = new Dictionary<byte[], TCell>();
         TMap _map4 = iprot.ReadMapBegin();
         for( int _i5 = 0; _i5 < _map4.Count; ++_i5)
         {
           byte[] _key6;
           TCell _val7;
           _key6 = iprot.ReadBinary();
           _val7 = new TCell();
           _val7.Read(iprot);
           this.columns[_key6] = _val7;
         }
         iprot.ReadMapEnd();
       }
       this.__isset.columns = true;
     } else {
       TProtocolUtil.Skip(iprot, field.Type);
     }
     break;
       default:
     TProtocolUtil.Skip(iprot, field.Type);
     break;
     }
     iprot.ReadFieldEnd();
       }
       iprot.ReadStructEnd();
 }
Ejemplo n.º 3
0
 public void Read (TProtocol iprot)
 {
   bool isset_serialized_parts = false;
   TField field;
   iprot.ReadStructBegin();
   while (true)
   {
     field = iprot.ReadFieldBegin();
     if (field.Type == TType.Stop) { 
       break;
     }
     switch (field.ID)
     {
       case 1:
         if (field.Type == TType.Map) {
           {
             Serialized_parts = new Dictionary<string, ThriftSerializedObject>();
             TMap _map218 = iprot.ReadMapBegin();
             for( int _i219 = 0; _i219 < _map218.Count; ++_i219)
             {
               string _key220;
               ThriftSerializedObject _val221;
               _key220 = iprot.ReadString();
               _val221 = new ThriftSerializedObject();
               _val221.Read(iprot);
               Serialized_parts[_key220] = _val221;
             }
             iprot.ReadMapEnd();
           }
           isset_serialized_parts = true;
         } else { 
           TProtocolUtil.Skip(iprot, field.Type);
         }
         break;
       default: 
         TProtocolUtil.Skip(iprot, field.Type);
         break;
     }
     iprot.ReadFieldEnd();
   }
   iprot.ReadStructEnd();
   if (!isset_serialized_parts)
     throw new TProtocolException(TProtocolException.INVALID_DATA);
 }
 public void Read (TProtocol iprot)
 {
   bool isset_assignments = false;
   TField field;
   iprot.ReadStructBegin();
   while (true)
   {
     field = iprot.ReadFieldBegin();
     if (field.Type == TType.Stop) { 
       break;
     }
     switch (field.ID)
     {
       case 1:
         if (field.Type == TType.Map) {
           {
             Assignments = new Dictionary<int, LocalAssignment>();
             TMap _map232 = iprot.ReadMapBegin();
             for( int _i233 = 0; _i233 < _map232.Count; ++_i233)
             {
               int _key234;
               LocalAssignment _val235;
               _key234 = iprot.ReadI32();
               _val235 = new LocalAssignment();
               _val235.Read(iprot);
               Assignments[_key234] = _val235;
             }
             iprot.ReadMapEnd();
           }
           isset_assignments = true;
         } else { 
           TProtocolUtil.Skip(iprot, field.Type);
         }
         break;
       default: 
         TProtocolUtil.Skip(iprot, field.Type);
         break;
     }
     iprot.ReadFieldEnd();
   }
   iprot.ReadStructEnd();
   if (!isset_assignments)
     throw new TProtocolException(TProtocolException.INVALID_DATA);
 }
Ejemplo n.º 5
0
 public void Read (TProtocol iprot)
 {
   bool isset_creds = false;
   TField field;
   iprot.ReadStructBegin();
   while (true)
   {
     field = iprot.ReadFieldBegin();
     if (field.Type == TType.Stop) { 
       break;
     }
     switch (field.ID)
     {
       case 1:
         if (field.Type == TType.Map) {
           {
             Creds = new Dictionary<string, string>();
             TMap _map163 = iprot.ReadMapBegin();
             for( int _i164 = 0; _i164 < _map163.Count; ++_i164)
             {
               string _key165;
               string _val166;
               _key165 = iprot.ReadString();
               _val166 = iprot.ReadString();
               Creds[_key165] = _val166;
             }
             iprot.ReadMapEnd();
           }
           isset_creds = true;
         } else { 
           TProtocolUtil.Skip(iprot, field.Type);
         }
         break;
       default: 
         TProtocolUtil.Skip(iprot, field.Type);
         break;
     }
     iprot.ReadFieldEnd();
   }
   iprot.ReadStructEnd();
   if (!isset_creds)
     throw new TProtocolException(TProtocolException.INVALID_DATA);
 }
Ejemplo n.º 6
0
 public void Read (TProtocol iprot)
 {
   bool isset_approved_workers = false;
   TField field;
   iprot.ReadStructBegin();
   while (true)
   {
     field = iprot.ReadFieldBegin();
     if (field.Type == TType.Stop) { 
       break;
     }
     switch (field.ID)
     {
       case 1:
         if (field.Type == TType.Map) {
           {
             Approved_workers = new Dictionary<string, int>();
             TMap _map227 = iprot.ReadMapBegin();
             for( int _i228 = 0; _i228 < _map227.Count; ++_i228)
             {
               string _key229;
               int _val230;
               _key229 = iprot.ReadString();
               _val230 = iprot.ReadI32();
               Approved_workers[_key229] = _val230;
             }
             iprot.ReadMapEnd();
           }
           isset_approved_workers = true;
         } else { 
           TProtocolUtil.Skip(iprot, field.Type);
         }
         break;
       default: 
         TProtocolUtil.Skip(iprot, field.Type);
         break;
     }
     iprot.ReadFieldEnd();
   }
   iprot.ReadStructEnd();
   if (!isset_approved_workers)
     throw new TProtocolException(TProtocolException.INVALID_DATA);
 }
 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.Map) {
           {
             MainMissionConfigMap = new Dictionary<int, Config.MainMissionConfig>();
             TMap _map45 = iprot.ReadMapBegin();
             for( int _i46 = 0; _i46 < _map45.Count; ++_i46)
             {
               int _key47;
               Config.MainMissionConfig _val48;
               _key47 = iprot.ReadI32();
               _val48 = new Config.MainMissionConfig();
               _val48.Read(iprot);
               MainMissionConfigMap[_key47] = _val48;
             }
             iprot.ReadMapEnd();
           }
         } else { 
           TProtocolUtil.Skip(iprot, field.Type);
         }
         break;
       default: 
         TProtocolUtil.Skip(iprot, field.Type);
         break;
     }
     iprot.ReadFieldEnd();
   }
   iprot.ReadStructEnd();
 }
 public void Read (TProtocol iprot)
 {
   TField field;
   iprot.ReadStructBegin();
   while (true)
   {
     field = iprot.ReadFieldBegin();
     if (field.Type == TType.Stop) { 
       break;
     }
     switch (field.ID)
     {
       case 10:
         if (field.Type == TType.Map) {
           {
             DifficultyConfig = new Dictionary<string, DifficultyConfig>();
             TMap _map10 = iprot.ReadMapBegin();
             for( int _i11 = 0; _i11 < _map10.Count; ++_i11)
             {
               string _key12;
               DifficultyConfig _val13;
               _key12 = iprot.ReadString();
               _val13 = new DifficultyConfig();
               _val13.Read(iprot);
               DifficultyConfig[_key12] = _val13;
             }
             iprot.ReadMapEnd();
           }
         } else { 
           TProtocolUtil.Skip(iprot, field.Type);
         }
         break;
       default: 
         TProtocolUtil.Skip(iprot, field.Type);
         break;
     }
     iprot.ReadFieldEnd();
   }
   iprot.ReadStructEnd();
 }
Ejemplo n.º 9
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 10:
         if (field.Type == TType.Map) {
           {
             EventConfig = new Dictionary<string, EventConfig>();
             TMap _map25 = iprot.ReadMapBegin();
             for( int _i26 = 0; _i26 < _map25.Count; ++_i26)
             {
               string _key27;
               EventConfig _val28;
               _key27 = iprot.ReadString();
               _val28 = new EventConfig();
               _val28.Read(iprot);
               EventConfig[_key27] = _val28;
             }
             iprot.ReadMapEnd();
           }
         } else { 
           TProtocolUtil.Skip(iprot, field.Type);
         }
         break;
       default: 
         TProtocolUtil.Skip(iprot, field.Type);
         break;
     }
     iprot.ReadFieldEnd();
   }
   iprot.ReadStructEnd();
 }
 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.Map) {
           {
             MusicConfigMap = new Dictionary<int, Config.MusicGameNoteKeyConfig>();
             TMap _map123 = iprot.ReadMapBegin();
             for( int _i124 = 0; _i124 < _map123.Count; ++_i124)
             {
               int _key125;
               Config.MusicGameNoteKeyConfig _val126;
               _key125 = iprot.ReadI32();
               _val126 = new Config.MusicGameNoteKeyConfig();
               _val126.Read(iprot);
               MusicConfigMap[_key125] = _val126;
             }
             iprot.ReadMapEnd();
           }
         } else { 
           TProtocolUtil.Skip(iprot, field.Type);
         }
         break;
       default: 
         TProtocolUtil.Skip(iprot, field.Type);
         break;
     }
     iprot.ReadFieldEnd();
   }
   iprot.ReadStructEnd();
 }
Ejemplo n.º 11
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.Map) {
           {
             StageConfigMap = new Dictionary<int, Config.StageConfig>();
             TMap _map50 = iprot.ReadMapBegin();
             for( int _i51 = 0; _i51 < _map50.Count; ++_i51)
             {
               int _key52;
               Config.StageConfig _val53;
               _key52 = iprot.ReadI32();
               _val53 = new Config.StageConfig();
               _val53.Read(iprot);
               StageConfigMap[_key52] = _val53;
             }
             iprot.ReadMapEnd();
           }
         } else { 
           TProtocolUtil.Skip(iprot, field.Type);
         }
         break;
       default: 
         TProtocolUtil.Skip(iprot, field.Type);
         break;
     }
     iprot.ReadFieldEnd();
   }
   iprot.ReadStructEnd();
 }
Ejemplo n.º 12
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.Map) {
           {
             FuncMap = new Dictionary<int, Config.FuncGroup>();
             TMap _map5 = iprot.ReadMapBegin();
             for( int _i6 = 0; _i6 < _map5.Count; ++_i6)
             {
               int _key7;
               Config.FuncGroup _val8;
               _key7 = iprot.ReadI32();
               _val8 = new Config.FuncGroup();
               _val8.Read(iprot);
               FuncMap[_key7] = _val8;
             }
             iprot.ReadMapEnd();
           }
         } else { 
           TProtocolUtil.Skip(iprot, field.Type);
         }
         break;
       default: 
         TProtocolUtil.Skip(iprot, field.Type);
         break;
     }
     iprot.ReadFieldEnd();
   }
   iprot.ReadStructEnd();
 }
 public void Read (TProtocol iprot)
 {
   TField field;
   iprot.ReadStructBegin();
   while (true)
   {
     field = iprot.ReadFieldBegin();
     if (field.Type == TType.Stop) { 
       break;
     }
     switch (field.ID)
     {
       case 10:
         if (field.Type == TType.Map) {
           {
             MapFileData = new Dictionary<int, EventControlData>();
             TMap _map30 = iprot.ReadMapBegin();
             for( int _i31 = 0; _i31 < _map30.Count; ++_i31)
             {
               int _key32;
               EventControlData _val33;
               _key32 = iprot.ReadI32();
               _val33 = new EventControlData();
               _val33.Read(iprot);
               MapFileData[_key32] = _val33;
             }
             iprot.ReadMapEnd();
           }
         } else { 
           TProtocolUtil.Skip(iprot, field.Type);
         }
         break;
       default: 
         TProtocolUtil.Skip(iprot, field.Type);
         break;
     }
     iprot.ReadFieldEnd();
   }
   iprot.ReadStructEnd();
 }
Ejemplo n.º 14
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.Map) {
           {
             BattleBuffTmpls = new Dictionary<int, BattleBuffTemplate>();
             TMap _map4 = iprot.ReadMapBegin();
             for( int _i5 = 0; _i5 < _map4.Count; ++_i5)
             {
               int _key6;
               BattleBuffTemplate _val7;
               _key6 = iprot.ReadI32();
               _val7 = new BattleBuffTemplate();
               _val7.Read(iprot);
               BattleBuffTmpls[_key6] = _val7;
             }
             iprot.ReadMapEnd();
           }
         } else { 
           TProtocolUtil.Skip(iprot, field.Type);
         }
         break;
       default: 
         TProtocolUtil.Skip(iprot, field.Type);
         break;
     }
     iprot.ReadFieldEnd();
   }
   iprot.ReadStructEnd();
 }
Ejemplo n.º 15
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.Map) {
           {
             TargetMap = new Dictionary<int, Config.TargetGroup>();
             TMap _map10 = iprot.ReadMapBegin();
             for( int _i11 = 0; _i11 < _map10.Count; ++_i11)
             {
               int _key12;
               Config.TargetGroup _val13;
               _key12 = iprot.ReadI32();
               _val13 = new Config.TargetGroup();
               _val13.Read(iprot);
               TargetMap[_key12] = _val13;
             }
             iprot.ReadMapEnd();
           }
         } else { 
           TProtocolUtil.Skip(iprot, field.Type);
         }
         break;
       default: 
         TProtocolUtil.Skip(iprot, field.Type);
         break;
     }
     iprot.ReadFieldEnd();
   }
   iprot.ReadStructEnd();
 }
Ejemplo n.º 16
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.Map) {
           {
             SkillConfigMap = new Dictionary<int, Config.SkillConfig>();
             TMap _map69 = iprot.ReadMapBegin();
             for( int _i70 = 0; _i70 < _map69.Count; ++_i70)
             {
               int _key71;
               Config.SkillConfig _val72;
               _key71 = iprot.ReadI32();
               _val72 = new Config.SkillConfig();
               _val72.Read(iprot);
               SkillConfigMap[_key71] = _val72;
             }
             iprot.ReadMapEnd();
           }
         } else { 
           TProtocolUtil.Skip(iprot, field.Type);
         }
         break;
       default: 
         TProtocolUtil.Skip(iprot, field.Type);
         break;
     }
     iprot.ReadFieldEnd();
   }
   iprot.ReadStructEnd();
 }
Ejemplo n.º 17
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.Map) {
           {
             RewardTmpls = new Dictionary<int, RewardTemplate>();
             TMap _map0 = iprot.ReadMapBegin();
             for( int _i1 = 0; _i1 < _map0.Count; ++_i1)
             {
               int _key2;
               RewardTemplate _val3;
               _key2 = iprot.ReadI32();
               _val3 = new RewardTemplate();
               _val3.Read(iprot);
               RewardTmpls[_key2] = _val3;
             }
             iprot.ReadMapEnd();
           }
         } else { 
           TProtocolUtil.Skip(iprot, field.Type);
         }
         break;
       default: 
         TProtocolUtil.Skip(iprot, field.Type);
         break;
     }
     iprot.ReadFieldEnd();
   }
   iprot.ReadStructEnd();
 }
Ejemplo n.º 18
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.Map) {
           {
             ItemIndexeChanges = new Dictionary<short, short>();
             TMap _map13 = iprot.ReadMapBegin();
             for( int _i14 = 0; _i14 < _map13.Count; ++_i14)
             {
               short _key15;
               short _val16;
               _key15 = iprot.ReadI16();
               _val16 = iprot.ReadI16();
               ItemIndexeChanges[_key15] = _val16;
             }
             iprot.ReadMapEnd();
           }
         } else { 
           TProtocolUtil.Skip(iprot, field.Type);
         }
         break;
       default: 
         TProtocolUtil.Skip(iprot, field.Type);
         break;
     }
     iprot.ReadFieldEnd();
   }
   iprot.ReadStructEnd();
 }
 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.Map) {
       {
         Credentials = new Dictionary<string, string>();
         TMap _map28 = iprot.ReadMapBegin();
         for( int _i29 = 0; _i29 < _map28.Count; ++_i29)
         {
           string _key30;
           string _val31;
           _key30 = iprot.ReadString();
           _val31 = iprot.ReadString();
           Credentials[_key30] = _val31;
         }
         iprot.ReadMapEnd();
       }
     } else {
       TProtocolUtil.Skip(iprot, field.Type);
     }
     break;
       default:
     TProtocolUtil.Skip(iprot, field.Type);
     break;
     }
     iprot.ReadFieldEnd();
       }
       iprot.ReadStructEnd();
 }
Ejemplo n.º 20
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 10:
         if (field.Type == TType.Map) {
           {
             MapTalent = new Dictionary<string, int>();
             TMap _map0 = iprot.ReadMapBegin();
             for( int _i1 = 0; _i1 < _map0.Count; ++_i1)
             {
               string _key2;
               int _val3;
               _key2 = iprot.ReadString();
               _val3 = iprot.ReadI32();
               MapTalent[_key2] = _val3;
             }
             iprot.ReadMapEnd();
           }
         } else { 
           TProtocolUtil.Skip(iprot, field.Type);
         }
         break;
       default: 
         TProtocolUtil.Skip(iprot, field.Type);
         break;
     }
     iprot.ReadFieldEnd();
   }
   iprot.ReadStructEnd();
 }
Ejemplo n.º 21
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.I32) {
       Ack = (AckType)iprot.ReadI32();
     } else {
       TProtocolUtil.Skip(iprot, field.Type);
     }
     break;
       case 2:
     if (field.Type == TType.String) {
       EbayTokenID = iprot.ReadString();
     } else {
       TProtocolUtil.Skip(iprot, field.Type);
     }
     break;
       case 3:
     if (field.Type == TType.String) {
       InventoryID = iprot.ReadString();
     } else {
       TProtocolUtil.Skip(iprot, field.Type);
     }
     break;
       case 4:
     if (field.Type == TType.String) {
       ItemID = iprot.ReadString();
     } else {
       TProtocolUtil.Skip(iprot, field.Type);
     }
     break;
       case 5:
     if (field.Type == TType.List) {
       {
         Messages = new List<Dictionary<string, string>>();
         TList _list72 = iprot.ReadListBegin();
         for( int _i73 = 0; _i73 < _list72.Count; ++_i73)
         {
           Dictionary<string, string> _elem74 = new Dictionary<string, string>();
           {
             _elem74 = new Dictionary<string, string>();
             TMap _map75 = iprot.ReadMapBegin();
             for( int _i76 = 0; _i76 < _map75.Count; ++_i76)
             {
               string _key77;
               string _val78;
               _key77 = iprot.ReadString();
               _val78 = iprot.ReadString();
               _elem74[_key77] = _val78;
             }
             iprot.ReadMapEnd();
           }
           Messages.Add(_elem74);
         }
         iprot.ReadListEnd();
       }
     } else {
       TProtocolUtil.Skip(iprot, field.Type);
     }
     break;
       default:
     TProtocolUtil.Skip(iprot, field.Type);
     break;
     }
     iprot.ReadFieldEnd();
       }
       iprot.ReadStructEnd();
 }
Ejemplo n.º 22
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.String) {
           Keyspace = iprot.ReadString();
         } else { 
           TProtocolUtil.Skip(iprot, field.Type);
         }
         break;
       case 2:
         if (field.Type == TType.String) {
           Name = iprot.ReadString();
         } else { 
           TProtocolUtil.Skip(iprot, field.Type);
         }
         break;
       case 3:
         if (field.Type == TType.String) {
           Column_type = iprot.ReadString();
         } else { 
           TProtocolUtil.Skip(iprot, field.Type);
         }
         break;
       case 5:
         if (field.Type == TType.String) {
           Comparator_type = iprot.ReadString();
         } else { 
           TProtocolUtil.Skip(iprot, field.Type);
         }
         break;
       case 6:
         if (field.Type == TType.String) {
           Subcomparator_type = iprot.ReadString();
         } else { 
           TProtocolUtil.Skip(iprot, field.Type);
         }
         break;
       case 8:
         if (field.Type == TType.String) {
           Comment = iprot.ReadString();
         } else { 
           TProtocolUtil.Skip(iprot, field.Type);
         }
         break;
       case 12:
         if (field.Type == TType.Double) {
           Read_repair_chance = iprot.ReadDouble();
         } else { 
           TProtocolUtil.Skip(iprot, field.Type);
         }
         break;
       case 13:
         if (field.Type == TType.List) {
           {
             Column_metadata = new List<ColumnDef>();
             TList _list46 = iprot.ReadListBegin();
             for( int _i47 = 0; _i47 < _list46.Count; ++_i47)
             {
               ColumnDef _elem48 = new ColumnDef();
               _elem48 = new ColumnDef();
               _elem48.Read(iprot);
               Column_metadata.Add(_elem48);
             }
             iprot.ReadListEnd();
           }
         } else { 
           TProtocolUtil.Skip(iprot, field.Type);
         }
         break;
       case 14:
         if (field.Type == TType.I32) {
           Gc_grace_seconds = iprot.ReadI32();
         } else { 
           TProtocolUtil.Skip(iprot, field.Type);
         }
         break;
       case 15:
         if (field.Type == TType.String) {
           Default_validation_class = iprot.ReadString();
         } else { 
           TProtocolUtil.Skip(iprot, field.Type);
         }
         break;
       case 16:
         if (field.Type == TType.I32) {
           Id = iprot.ReadI32();
         } else { 
           TProtocolUtil.Skip(iprot, field.Type);
         }
         break;
       case 17:
         if (field.Type == TType.I32) {
           Min_compaction_threshold = iprot.ReadI32();
         } else { 
           TProtocolUtil.Skip(iprot, field.Type);
         }
         break;
       case 18:
         if (field.Type == TType.I32) {
           Max_compaction_threshold = iprot.ReadI32();
         } else { 
           TProtocolUtil.Skip(iprot, field.Type);
         }
         break;
       case 24:
         if (field.Type == TType.Bool) {
           Replicate_on_write = iprot.ReadBool();
         } else { 
           TProtocolUtil.Skip(iprot, field.Type);
         }
         break;
       case 26:
         if (field.Type == TType.String) {
           Key_validation_class = iprot.ReadString();
         } else { 
           TProtocolUtil.Skip(iprot, field.Type);
         }
         break;
       case 28:
         if (field.Type == TType.String) {
           Key_alias = iprot.ReadBinary();
         } else { 
           TProtocolUtil.Skip(iprot, field.Type);
         }
         break;
       case 29:
         if (field.Type == TType.String) {
           Compaction_strategy = iprot.ReadString();
         } else { 
           TProtocolUtil.Skip(iprot, field.Type);
         }
         break;
       case 30:
         if (field.Type == TType.Map) {
           {
             Compaction_strategy_options = new Dictionary<string, string>();
             TMap _map49 = iprot.ReadMapBegin();
             for( int _i50 = 0; _i50 < _map49.Count; ++_i50)
             {
               string _key51;
               string _val52;
               _key51 = iprot.ReadString();
               _val52 = iprot.ReadString();
               Compaction_strategy_options[_key51] = _val52;
             }
             iprot.ReadMapEnd();
           }
         } else { 
           TProtocolUtil.Skip(iprot, field.Type);
         }
         break;
       case 32:
         if (field.Type == TType.Map) {
           {
             Compression_options = new Dictionary<string, string>();
             TMap _map53 = iprot.ReadMapBegin();
             for( int _i54 = 0; _i54 < _map53.Count; ++_i54)
             {
               string _key55;
               string _val56;
               _key55 = iprot.ReadString();
               _val56 = iprot.ReadString();
               Compression_options[_key55] = _val56;
             }
             iprot.ReadMapEnd();
           }
         } else { 
           TProtocolUtil.Skip(iprot, field.Type);
         }
         break;
       case 33:
         if (field.Type == TType.Double) {
           Bloom_filter_fp_chance = iprot.ReadDouble();
         } else { 
           TProtocolUtil.Skip(iprot, field.Type);
         }
         break;
       case 34:
         if (field.Type == TType.String) {
           Caching = iprot.ReadString();
         } else { 
           TProtocolUtil.Skip(iprot, field.Type);
         }
         break;
       case 37:
         if (field.Type == TType.Double) {
           Dclocal_read_repair_chance = iprot.ReadDouble();
         } else { 
           TProtocolUtil.Skip(iprot, field.Type);
         }
         break;
       case 9:
         if (field.Type == TType.Double) {
           Row_cache_size = iprot.ReadDouble();
         } else { 
           TProtocolUtil.Skip(iprot, field.Type);
         }
         break;
       case 11:
         if (field.Type == TType.Double) {
           Key_cache_size = iprot.ReadDouble();
         } else { 
           TProtocolUtil.Skip(iprot, field.Type);
         }
         break;
       case 19:
         if (field.Type == TType.I32) {
           Row_cache_save_period_in_seconds = iprot.ReadI32();
         } else { 
           TProtocolUtil.Skip(iprot, field.Type);
         }
         break;
       case 20:
         if (field.Type == TType.I32) {
           Key_cache_save_period_in_seconds = iprot.ReadI32();
         } else { 
           TProtocolUtil.Skip(iprot, field.Type);
         }
         break;
       case 21:
         if (field.Type == TType.I32) {
           Memtable_flush_after_mins = iprot.ReadI32();
         } else { 
           TProtocolUtil.Skip(iprot, field.Type);
         }
         break;
       case 22:
         if (field.Type == TType.I32) {
           Memtable_throughput_in_mb = iprot.ReadI32();
         } else { 
           TProtocolUtil.Skip(iprot, field.Type);
         }
         break;
       case 23:
         if (field.Type == TType.Double) {
           Memtable_operations_in_millions = iprot.ReadDouble();
         } else { 
           TProtocolUtil.Skip(iprot, field.Type);
         }
         break;
       case 25:
         if (field.Type == TType.Double) {
           Merge_shards_chance = iprot.ReadDouble();
         } else { 
           TProtocolUtil.Skip(iprot, field.Type);
         }
         break;
       case 27:
         if (field.Type == TType.String) {
           Row_cache_provider = iprot.ReadString();
         } else { 
           TProtocolUtil.Skip(iprot, field.Type);
         }
         break;
       case 31:
         if (field.Type == TType.I32) {
           Row_cache_keys_to_save = iprot.ReadI32();
         } else { 
           TProtocolUtil.Skip(iprot, field.Type);
         }
         break;
       default: 
         TProtocolUtil.Skip(iprot, field.Type);
         break;
     }
     iprot.ReadFieldEnd();
   }
   iprot.ReadStructEnd();
 }
Ejemplo n.º 23
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.Set) {
           {
             KeysOnly = new THashSet<string>();
             TSet _set8 = iprot.ReadSetBegin();
             for( int _i9 = 0; _i9 < _set8.Count; ++_i9)
             {
               string _elem10 = null;
               _elem10 = iprot.ReadString();
               KeysOnly.Add(_elem10);
             }
             iprot.ReadSetEnd();
           }
         } else { 
           TProtocolUtil.Skip(iprot, field.Type);
         }
         break;
       case 2:
         if (field.Type == TType.Map) {
           {
             FullMap = new Dictionary<string, string>();
             TMap _map11 = iprot.ReadMapBegin();
             for( int _i12 = 0; _i12 < _map11.Count; ++_i12)
             {
               string _key13;
               string _val14;
               _key13 = iprot.ReadString();
               _val14 = iprot.ReadString();
               FullMap[_key13] = _val14;
             }
             iprot.ReadMapEnd();
           }
         } else { 
           TProtocolUtil.Skip(iprot, field.Type);
         }
         break;
       default: 
         TProtocolUtil.Skip(iprot, field.Type);
         break;
     }
     iprot.ReadFieldEnd();
   }
   iprot.ReadStructEnd();
 }
Ejemplo n.º 24
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 0:
       if (field.Type == TType.Map) {
     {
       Success = new Dictionary<byte[], List<ColumnOrSuperColumn>>();
       TMap _map91 = iprot.ReadMapBegin();
       for( int _i92 = 0; _i92 < _map91.Count; ++_i92)
       {
         byte[] _key93;
         List<ColumnOrSuperColumn> _val94;
         _key93 = iprot.ReadBinary();
         {
           _val94 = new List<ColumnOrSuperColumn>();
           TList _list95 = iprot.ReadListBegin();
           for( int _i96 = 0; _i96 < _list95.Count; ++_i96)
           {
             ColumnOrSuperColumn _elem97 = new ColumnOrSuperColumn();
             _elem97 = new ColumnOrSuperColumn();
             _elem97.Read(iprot);
             _val94.Add(_elem97);
           }
           iprot.ReadListEnd();
         }
         Success[_key93] = _val94;
       }
       iprot.ReadMapEnd();
     }
       } else {
     TProtocolUtil.Skip(iprot, field.Type);
       }
       break;
     case 1:
       if (field.Type == TType.Struct) {
     Ire = new InvalidRequestException();
     Ire.Read(iprot);
       } else {
     TProtocolUtil.Skip(iprot, field.Type);
       }
       break;
     case 2:
       if (field.Type == TType.Struct) {
     Ue = new UnavailableException();
     Ue.Read(iprot);
       } else {
     TProtocolUtil.Skip(iprot, field.Type);
       }
       break;
     case 3:
       if (field.Type == TType.Struct) {
     Te = new TimedOutException();
     Te.Read(iprot);
       } else {
     TProtocolUtil.Skip(iprot, field.Type);
       }
       break;
     default:
       TProtocolUtil.Skip(iprot, field.Type);
       break;
       }
       iprot.ReadFieldEnd();
     }
     iprot.ReadStructEnd();
 }
 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.Map) {
           {
             NotebookCounts = new Dictionary<string, int>();
             TMap _map76 = iprot.ReadMapBegin();
             for( int _i77 = 0; _i77 < _map76.Count; ++_i77)
             {
               string _key78;
               int _val79;
               _key78 = iprot.ReadString();
               _val79 = iprot.ReadI32();
               NotebookCounts[_key78] = _val79;
             }
             iprot.ReadMapEnd();
           }
         } else { 
           TProtocolUtil.Skip(iprot, field.Type);
         }
         break;
       case 2:
         if (field.Type == TType.Map) {
           {
             TagCounts = new Dictionary<string, int>();
             TMap _map80 = iprot.ReadMapBegin();
             for( int _i81 = 0; _i81 < _map80.Count; ++_i81)
             {
               string _key82;
               int _val83;
               _key82 = iprot.ReadString();
               _val83 = iprot.ReadI32();
               TagCounts[_key82] = _val83;
             }
             iprot.ReadMapEnd();
           }
         } else { 
           TProtocolUtil.Skip(iprot, field.Type);
         }
         break;
       case 3:
         if (field.Type == TType.I32) {
           TrashCount = iprot.ReadI32();
         } else { 
           TProtocolUtil.Skip(iprot, field.Type);
         }
         break;
       default: 
         TProtocolUtil.Skip(iprot, field.Type);
         break;
     }
     iprot.ReadFieldEnd();
   }
   iprot.ReadStructEnd();
 }
Ejemplo n.º 26
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.Map) {
     {
       Mutation_map = new Dictionary<byte[], Dictionary<string, List<Mutation>>>();
       TMap _map117 = iprot.ReadMapBegin();
       for( int _i118 = 0; _i118 < _map117.Count; ++_i118)
       {
         byte[] _key119;
         Dictionary<string, List<Mutation>> _val120;
         _key119 = iprot.ReadBinary();
         {
           _val120 = new Dictionary<string, List<Mutation>>();
           TMap _map121 = iprot.ReadMapBegin();
           for( int _i122 = 0; _i122 < _map121.Count; ++_i122)
           {
             string _key123;
             List<Mutation> _val124;
             _key123 = iprot.ReadString();
             {
               _val124 = new List<Mutation>();
               TList _list125 = iprot.ReadListBegin();
               for( int _i126 = 0; _i126 < _list125.Count; ++_i126)
               {
                 Mutation _elem127 = new Mutation();
                 _elem127 = new Mutation();
                 _elem127.Read(iprot);
                 _val124.Add(_elem127);
               }
               iprot.ReadListEnd();
             }
             _val120[_key123] = _val124;
           }
           iprot.ReadMapEnd();
         }
         Mutation_map[_key119] = _val120;
       }
       iprot.ReadMapEnd();
     }
       } else {
     TProtocolUtil.Skip(iprot, field.Type);
       }
       break;
     case 2:
       if (field.Type == TType.I32) {
     Consistency_level = (ConsistencyLevel)iprot.ReadI32();
       } else {
     TProtocolUtil.Skip(iprot, field.Type);
       }
       break;
     default:
       TProtocolUtil.Skip(iprot, field.Type);
       break;
       }
       iprot.ReadFieldEnd();
     }
     iprot.ReadStructEnd();
 }
Ejemplo n.º 27
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 0:
       if (field.Type == TType.Map) {
     {
       Success = new Dictionary<byte[], int>();
       TMap _map104 = iprot.ReadMapBegin();
       for( int _i105 = 0; _i105 < _map104.Count; ++_i105)
       {
         byte[] _key106;
         int _val107;
         _key106 = iprot.ReadBinary();
         _val107 = iprot.ReadI32();
         Success[_key106] = _val107;
       }
       iprot.ReadMapEnd();
     }
       } else {
     TProtocolUtil.Skip(iprot, field.Type);
       }
       break;
     case 1:
       if (field.Type == TType.Struct) {
     Ire = new InvalidRequestException();
     Ire.Read(iprot);
       } else {
     TProtocolUtil.Skip(iprot, field.Type);
       }
       break;
     case 2:
       if (field.Type == TType.Struct) {
     Ue = new UnavailableException();
     Ue.Read(iprot);
       } else {
     TProtocolUtil.Skip(iprot, field.Type);
       }
       break;
     case 3:
       if (field.Type == TType.Struct) {
     Te = new TimedOutException();
     Te.Read(iprot);
       } else {
     TProtocolUtil.Skip(iprot, field.Type);
       }
       break;
     default:
       TProtocolUtil.Skip(iprot, field.Type);
       break;
       }
       iprot.ReadFieldEnd();
     }
     iprot.ReadStructEnd();
 }
Ejemplo n.º 28
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 0:
       if (field.Type == TType.Map) {
     {
       Success = new Dictionary<string, List<string>>();
       TMap _map131 = iprot.ReadMapBegin();
       for( int _i132 = 0; _i132 < _map131.Count; ++_i132)
       {
         string _key133;
         List<string> _val134;
         _key133 = iprot.ReadString();
         {
           _val134 = new List<string>();
           TList _list135 = iprot.ReadListBegin();
           for( int _i136 = 0; _i136 < _list135.Count; ++_i136)
           {
             string _elem137 = null;
             _elem137 = iprot.ReadString();
             _val134.Add(_elem137);
           }
           iprot.ReadListEnd();
         }
         Success[_key133] = _val134;
       }
       iprot.ReadMapEnd();
     }
       } else {
     TProtocolUtil.Skip(iprot, field.Type);
       }
       break;
     case 1:
       if (field.Type == TType.Struct) {
     Ire = new InvalidRequestException();
     Ire.Read(iprot);
       } else {
     TProtocolUtil.Skip(iprot, field.Type);
       }
       break;
     default:
       TProtocolUtil.Skip(iprot, field.Type);
       break;
       }
       iprot.ReadFieldEnd();
     }
     iprot.ReadStructEnd();
 }
Ejemplo n.º 29
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 10:
         if (field.Type == TType.Map) {
           {
             HeroGroup1List = new Dictionary<int, List<long>>();
             TMap _map8 = iprot.ReadMapBegin();
             for( int _i9 = 0; _i9 < _map8.Count; ++_i9)
             {
               int _key10;
               List<long> _val11;
               _key10 = iprot.ReadI32();
               {
                 _val11 = new List<long>();
                 TList _list12 = iprot.ReadListBegin();
                 for( int _i13 = 0; _i13 < _list12.Count; ++_i13)
                 {
                   long _elem14 = 0;
                   _elem14 = iprot.ReadI64();
                   _val11.Add(_elem14);
                 }
                 iprot.ReadListEnd();
               }
               HeroGroup1List[_key10] = _val11;
             }
             iprot.ReadMapEnd();
           }
         } else { 
           TProtocolUtil.Skip(iprot, field.Type);
         }
         break;
       case 20:
         if (field.Type == TType.Map) {
           {
             HeroGroup2List = new Dictionary<int, List<long>>();
             TMap _map15 = iprot.ReadMapBegin();
             for( int _i16 = 0; _i16 < _map15.Count; ++_i16)
             {
               int _key17;
               List<long> _val18;
               _key17 = iprot.ReadI32();
               {
                 _val18 = new List<long>();
                 TList _list19 = iprot.ReadListBegin();
                 for( int _i20 = 0; _i20 < _list19.Count; ++_i20)
                 {
                   long _elem21 = 0;
                   _elem21 = iprot.ReadI64();
                   _val18.Add(_elem21);
                 }
                 iprot.ReadListEnd();
               }
               HeroGroup2List[_key17] = _val18;
             }
             iprot.ReadMapEnd();
           }
         } else { 
           TProtocolUtil.Skip(iprot, field.Type);
         }
         break;
       case 30:
         if (field.Type == TType.Map) {
           {
             HeroGroup3List = new Dictionary<int, List<long>>();
             TMap _map22 = iprot.ReadMapBegin();
             for( int _i23 = 0; _i23 < _map22.Count; ++_i23)
             {
               int _key24;
               List<long> _val25;
               _key24 = iprot.ReadI32();
               {
                 _val25 = new List<long>();
                 TList _list26 = iprot.ReadListBegin();
                 for( int _i27 = 0; _i27 < _list26.Count; ++_i27)
                 {
                   long _elem28 = 0;
                   _elem28 = iprot.ReadI64();
                   _val25.Add(_elem28);
                 }
                 iprot.ReadListEnd();
               }
               HeroGroup3List[_key24] = _val25;
             }
             iprot.ReadMapEnd();
           }
         } else { 
           TProtocolUtil.Skip(iprot, field.Type);
         }
         break;
       default: 
         TProtocolUtil.Skip(iprot, field.Type);
         break;
     }
     iprot.ReadFieldEnd();
   }
   iprot.ReadStructEnd();
 }
Ejemplo n.º 30
0
        public static void Skip(TProtocol prot, TType type)
        {
            prot.IncrementRecursionDepth();
            try
            {
                switch (type)
                {
                case TType.Bool:
                    prot.ReadBool();
                    break;

                case TType.Byte:
                    prot.ReadByte();
                    break;

                case TType.I16:
                    prot.ReadI16();
                    break;

                case TType.I32:
                    prot.ReadI32();
                    break;

                case TType.I64:
                    prot.ReadI64();
                    break;

                case TType.Double:
                    prot.ReadDouble();
                    break;

                case TType.String:
                    // Don't try to decode the string, just skip it.
                    prot.ReadBinary();
                    break;

                case TType.Struct:
                    prot.ReadStructBegin();
                    while (true)
                    {
                        TField field = prot.ReadFieldBegin();
                        if (field.Type == TType.Stop)
                        {
                            break;
                        }
                        Skip(prot, field.Type);
                        prot.ReadFieldEnd();
                    }
                    prot.ReadStructEnd();
                    break;

                case TType.Map:
                    TMap map = prot.ReadMapBegin();
                    for (int i = 0; i < map.Count; i++)
                    {
                        Skip(prot, map.KeyType);
                        Skip(prot, map.ValueType);
                    }
                    prot.ReadMapEnd();
                    break;

                case TType.Set:
                    TSet set = prot.ReadSetBegin();
                    for (int i = 0; i < set.Count; i++)
                    {
                        Skip(prot, set.ElementType);
                    }
                    prot.ReadSetEnd();
                    break;

                case TType.List:
                    TList list = prot.ReadListBegin();
                    for (int i = 0; i < list.Count; i++)
                    {
                        Skip(prot, list.ElementType);
                    }
                    prot.ReadListEnd();
                    break;

                default:
                    throw new TProtocolException(TProtocolException.INVALID_DATA, "Unknown data type " + type.ToString("d"));
                }
            }
            finally
            {
                prot.DecrementRecursionDepth();
            }
        }
Ejemplo n.º 31
0
        public static void Skip(TProtocol prot, TType type)
        {
            switch (type)
            {
            case TType.Bool:
                prot.ReadBool();
                break;

            case TType.Byte:
                prot.ReadByte();
                break;

            case TType.I16:
                prot.ReadI16();
                break;

            case TType.I32:
                prot.ReadI32();
                break;

            case TType.I64:
                prot.ReadI64();
                break;

            case TType.Double:
                prot.ReadDouble();
                break;

            case TType.String:
                // Don't try to decode the string, just skip it.
                prot.ReadBinary();
                break;

            case TType.Struct:
                prot.ReadStructBegin();
                while (true)
                {
                    TField field = prot.ReadFieldBegin();
                    if (field.Type == TType.Stop)
                    {
                        break;
                    }
                    Skip(prot, field.Type);
                    prot.ReadFieldEnd();
                }
                prot.ReadStructEnd();
                break;

            case TType.Map:
                TMap map = prot.ReadMapBegin();
                for (int i = 0; i < map.Count; i++)
                {
                    Skip(prot, map.KeyType);
                    Skip(prot, map.ValueType);
                }
                prot.ReadMapEnd();
                break;

            case TType.Set:
                TSet set = prot.ReadSetBegin();
                for (int i = 0; i < set.Count; i++)
                {
                    Skip(prot, set.ElementType);
                }
                prot.ReadSetEnd();
                break;

            case TType.List:
                TList list = prot.ReadListBegin();
                for (int i = 0; i < list.Count; i++)
                {
                    Skip(prot, list.ElementType);
                }
                prot.ReadListEnd();
                break;
            }
        }
Ejemplo n.º 32
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.String) {
           Name = iprot.ReadBinary();
         } else { 
           TProtocolUtil.Skip(iprot, field.Type);
         }
         break;
       case 2:
         if (field.Type == TType.String) {
           Validation_class = iprot.ReadString();
         } else { 
           TProtocolUtil.Skip(iprot, field.Type);
         }
         break;
       case 3:
         if (field.Type == TType.I32) {
           Index_type = (IndexType)iprot.ReadI32();
         } else { 
           TProtocolUtil.Skip(iprot, field.Type);
         }
         break;
       case 4:
         if (field.Type == TType.String) {
           Index_name = iprot.ReadString();
         } else { 
           TProtocolUtil.Skip(iprot, field.Type);
         }
         break;
       case 5:
         if (field.Type == TType.Map) {
           {
             Index_options = new Dictionary<string, string>();
             TMap _map41 = iprot.ReadMapBegin();
             for( int _i42 = 0; _i42 < _map41.Count; ++_i42)
             {
               string _key43;
               string _val44;
               _key43 = iprot.ReadString();
               _val44 = iprot.ReadString();
               Index_options[_key43] = _val44;
             }
             iprot.ReadMapEnd();
           }
         } else { 
           TProtocolUtil.Skip(iprot, field.Type);
         }
         break;
       default: 
         TProtocolUtil.Skip(iprot, field.Type);
         break;
     }
     iprot.ReadFieldEnd();
   }
   iprot.ReadStructEnd();
 }