Пример #1
0
        public void Read(TProtocol iprot)
        {
            bool   isset_keyspace = false;
            bool   isset_name     = 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.String)
                    {
                        Keyspace       = iprot.ReadString();
                        isset_keyspace = true;
                    }
                    else
                    {
                        TProtocolUtil.Skip(iprot, field.Type);
                    }
                    break;

                case 2:
                    if (field.Type == TType.String)
                    {
                        Name       = iprot.ReadString();
                        isset_name = true;
                    }
                    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 _list55 = iprot.ReadListBegin();
                            for (int _i56 = 0; _i56 < _list55.Count; ++_i56)
                            {
                                ColumnDef _elem57 = new ColumnDef();
                                _elem57 = new ColumnDef();
                                _elem57.Read(iprot);
                                Column_metadata.Add(_elem57);
                            }
                            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 _map58 = iprot.ReadMapBegin();
                            for (int _i59 = 0; _i59 < _map58.Count; ++_i59)
                            {
                                string _key60;
                                string _val61;
                                _key60 = iprot.ReadString();
                                _val61 = iprot.ReadString();
                                Compaction_strategy_options[_key60] = _val61;
                            }
                            iprot.ReadMapEnd();
                        }
                    }
                    else
                    {
                        TProtocolUtil.Skip(iprot, field.Type);
                    }
                    break;

                case 32:
                    if (field.Type == TType.Map)
                    {
                        {
                            Compression_options = new Dictionary <string, string>();
                            TMap _map62 = iprot.ReadMapBegin();
                            for (int _i63 = 0; _i63 < _map62.Count; ++_i63)
                            {
                                string _key64;
                                string _val65;
                                _key64 = iprot.ReadString();
                                _val65 = iprot.ReadString();
                                Compression_options[_key64] = _val65;
                            }
                            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 38:
                    if (field.Type == TType.Bool)
                    {
                        Populate_io_cache_on_flush = iprot.ReadBool();
                    }
                    else
                    {
                        TProtocolUtil.Skip(iprot, field.Type);
                    }
                    break;

                case 39:
                    if (field.Type == TType.I32)
                    {
                        Memtable_flush_period_in_ms = iprot.ReadI32();
                    }
                    else
                    {
                        TProtocolUtil.Skip(iprot, field.Type);
                    }
                    break;

                case 40:
                    if (field.Type == TType.I32)
                    {
                        Default_time_to_live = iprot.ReadI32();
                    }
                    else
                    {
                        TProtocolUtil.Skip(iprot, field.Type);
                    }
                    break;

                case 41:
                    if (field.Type == TType.I32)
                    {
                        Index_interval = iprot.ReadI32();
                    }
                    else
                    {
                        TProtocolUtil.Skip(iprot, field.Type);
                    }
                    break;

                case 42:
                    if (field.Type == TType.String)
                    {
                        Speculative_retry = iprot.ReadString();
                    }
                    else
                    {
                        TProtocolUtil.Skip(iprot, field.Type);
                    }
                    break;

                case 43:
                    if (field.Type == TType.List)
                    {
                        {
                            Triggers = new List <TriggerDef>();
                            TList _list66 = iprot.ReadListBegin();
                            for (int _i67 = 0; _i67 < _list66.Count; ++_i67)
                            {
                                TriggerDef _elem68 = new TriggerDef();
                                _elem68 = new TriggerDef();
                                _elem68.Read(iprot);
                                Triggers.Add(_elem68);
                            }
                            iprot.ReadListEnd();
                        }
                    }
                    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();
            if (!isset_keyspace)
            {
                throw new TProtocolException(TProtocolException.INVALID_DATA);
            }
            if (!isset_name)
            {
                throw new TProtocolException(TProtocolException.INVALID_DATA);
            }
        }
Пример #2
0
 public void Read (TProtocol iprot)
 {
   bool isset_keyspace = false;
   bool isset_name = 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.String) {
           Keyspace = iprot.ReadString();
           isset_keyspace = true;
         } else { 
           TProtocolUtil.Skip(iprot, field.Type);
         }
         break;
       case 2:
         if (field.Type == TType.String) {
           Name = iprot.ReadString();
           isset_name = true;
         } 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 _list55 = iprot.ReadListBegin();
             for( int _i56 = 0; _i56 < _list55.Count; ++_i56)
             {
               ColumnDef _elem57 = new ColumnDef();
               _elem57 = new ColumnDef();
               _elem57.Read(iprot);
               Column_metadata.Add(_elem57);
             }
             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 _map58 = iprot.ReadMapBegin();
             for( int _i59 = 0; _i59 < _map58.Count; ++_i59)
             {
               string _key60;
               string _val61;
               _key60 = iprot.ReadString();
               _val61 = iprot.ReadString();
               Compaction_strategy_options[_key60] = _val61;
             }
             iprot.ReadMapEnd();
           }
         } else { 
           TProtocolUtil.Skip(iprot, field.Type);
         }
         break;
       case 32:
         if (field.Type == TType.Map) {
           {
             Compression_options = new Dictionary<string, string>();
             TMap _map62 = iprot.ReadMapBegin();
             for( int _i63 = 0; _i63 < _map62.Count; ++_i63)
             {
               string _key64;
               string _val65;
               _key64 = iprot.ReadString();
               _val65 = iprot.ReadString();
               Compression_options[_key64] = _val65;
             }
             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 38:
         if (field.Type == TType.Bool) {
           Populate_io_cache_on_flush = iprot.ReadBool();
         } else { 
           TProtocolUtil.Skip(iprot, field.Type);
         }
         break;
       case 39:
         if (field.Type == TType.I32) {
           Memtable_flush_period_in_ms = iprot.ReadI32();
         } else { 
           TProtocolUtil.Skip(iprot, field.Type);
         }
         break;
       case 40:
         if (field.Type == TType.I32) {
           Default_time_to_live = iprot.ReadI32();
         } else { 
           TProtocolUtil.Skip(iprot, field.Type);
         }
         break;
       case 41:
         if (field.Type == TType.I32) {
           Index_interval = iprot.ReadI32();
         } else { 
           TProtocolUtil.Skip(iprot, field.Type);
         }
         break;
       case 42:
         if (field.Type == TType.String) {
           Speculative_retry = iprot.ReadString();
         } else { 
           TProtocolUtil.Skip(iprot, field.Type);
         }
         break;
       case 43:
         if (field.Type == TType.List) {
           {
             Triggers = new List<TriggerDef>();
             TList _list66 = iprot.ReadListBegin();
             for( int _i67 = 0; _i67 < _list66.Count; ++_i67)
             {
               TriggerDef _elem68 = new TriggerDef();
               _elem68 = new TriggerDef();
               _elem68.Read(iprot);
               Triggers.Add(_elem68);
             }
             iprot.ReadListEnd();
           }
         } 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();
   if (!isset_keyspace)
     throw new TProtocolException(TProtocolException.INVALID_DATA);
   if (!isset_name)
     throw new TProtocolException(TProtocolException.INVALID_DATA);
 }