View Javadoc

1   /**
2    * Autogenerated by Thrift Compiler (0.9.0)
3    *
4    * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
5    *  @generated
6    */
7   package org.apache.hadoop.hbase.thrift.generated;
8   
9   import org.apache.commons.lang.builder.HashCodeBuilder;
10  import org.apache.thrift.scheme.IScheme;
11  import org.apache.thrift.scheme.SchemeFactory;
12  import org.apache.thrift.scheme.StandardScheme;
13  
14  import org.apache.thrift.scheme.TupleScheme;
15  import org.apache.thrift.protocol.TTupleProtocol;
16  import org.apache.thrift.protocol.TProtocolException;
17  import org.apache.thrift.EncodingUtils;
18  import org.apache.thrift.TException;
19  import java.util.List;
20  import java.util.ArrayList;
21  import java.util.Map;
22  import java.util.HashMap;
23  import java.util.EnumMap;
24  import java.util.Set;
25  import java.util.HashSet;
26  import java.util.EnumSet;
27  import java.util.Collections;
28  import java.util.BitSet;
29  import java.nio.ByteBuffer;
30  import java.util.Arrays;
31  import org.slf4j.Logger;
32  import org.slf4j.LoggerFactory;
33  
34  /**
35   * An HColumnDescriptor contains information about a column family
36   * such as the number of versions, compression settings, etc. It is
37   * used as input when creating a table or adding a column.
38   */
39  public class ColumnDescriptor implements org.apache.thrift.TBase<ColumnDescriptor, ColumnDescriptor._Fields>, java.io.Serializable, Cloneable {
40    private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("ColumnDescriptor");
41  
42    private static final org.apache.thrift.protocol.TField NAME_FIELD_DESC = new org.apache.thrift.protocol.TField("name", org.apache.thrift.protocol.TType.STRING, (short)1);
43    private static final org.apache.thrift.protocol.TField MAX_VERSIONS_FIELD_DESC = new org.apache.thrift.protocol.TField("maxVersions", org.apache.thrift.protocol.TType.I32, (short)2);
44    private static final org.apache.thrift.protocol.TField COMPRESSION_FIELD_DESC = new org.apache.thrift.protocol.TField("compression", org.apache.thrift.protocol.TType.STRING, (short)3);
45    private static final org.apache.thrift.protocol.TField IN_MEMORY_FIELD_DESC = new org.apache.thrift.protocol.TField("inMemory", org.apache.thrift.protocol.TType.BOOL, (short)4);
46    private static final org.apache.thrift.protocol.TField BLOOM_FILTER_TYPE_FIELD_DESC = new org.apache.thrift.protocol.TField("bloomFilterType", org.apache.thrift.protocol.TType.STRING, (short)5);
47    private static final org.apache.thrift.protocol.TField BLOOM_FILTER_VECTOR_SIZE_FIELD_DESC = new org.apache.thrift.protocol.TField("bloomFilterVectorSize", org.apache.thrift.protocol.TType.I32, (short)6);
48    private static final org.apache.thrift.protocol.TField BLOOM_FILTER_NB_HASHES_FIELD_DESC = new org.apache.thrift.protocol.TField("bloomFilterNbHashes", org.apache.thrift.protocol.TType.I32, (short)7);
49    private static final org.apache.thrift.protocol.TField BLOCK_CACHE_ENABLED_FIELD_DESC = new org.apache.thrift.protocol.TField("blockCacheEnabled", org.apache.thrift.protocol.TType.BOOL, (short)8);
50    private static final org.apache.thrift.protocol.TField TIME_TO_LIVE_FIELD_DESC = new org.apache.thrift.protocol.TField("timeToLive", org.apache.thrift.protocol.TType.I32, (short)9);
51  
52    private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>();
53    static {
54      schemes.put(StandardScheme.class, new ColumnDescriptorStandardSchemeFactory());
55      schemes.put(TupleScheme.class, new ColumnDescriptorTupleSchemeFactory());
56    }
57  
58    public ByteBuffer name; // required
59    public int maxVersions; // required
60    public String compression; // required
61    public boolean inMemory; // required
62    public String bloomFilterType; // required
63    public int bloomFilterVectorSize; // required
64    public int bloomFilterNbHashes; // required
65    public boolean blockCacheEnabled; // required
66    public int timeToLive; // required
67  
68    /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
69    public enum _Fields implements org.apache.thrift.TFieldIdEnum {
70      NAME((short)1, "name"),
71      MAX_VERSIONS((short)2, "maxVersions"),
72      COMPRESSION((short)3, "compression"),
73      IN_MEMORY((short)4, "inMemory"),
74      BLOOM_FILTER_TYPE((short)5, "bloomFilterType"),
75      BLOOM_FILTER_VECTOR_SIZE((short)6, "bloomFilterVectorSize"),
76      BLOOM_FILTER_NB_HASHES((short)7, "bloomFilterNbHashes"),
77      BLOCK_CACHE_ENABLED((short)8, "blockCacheEnabled"),
78      TIME_TO_LIVE((short)9, "timeToLive");
79  
80      private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();
81  
82      static {
83        for (_Fields field : EnumSet.allOf(_Fields.class)) {
84          byName.put(field.getFieldName(), field);
85        }
86      }
87  
88      /**
89       * Find the _Fields constant that matches fieldId, or null if its not found.
90       */
91      public static _Fields findByThriftId(int fieldId) {
92        switch(fieldId) {
93          case 1: // NAME
94            return NAME;
95          case 2: // MAX_VERSIONS
96            return MAX_VERSIONS;
97          case 3: // COMPRESSION
98            return COMPRESSION;
99          case 4: // IN_MEMORY
100           return IN_MEMORY;
101         case 5: // BLOOM_FILTER_TYPE
102           return BLOOM_FILTER_TYPE;
103         case 6: // BLOOM_FILTER_VECTOR_SIZE
104           return BLOOM_FILTER_VECTOR_SIZE;
105         case 7: // BLOOM_FILTER_NB_HASHES
106           return BLOOM_FILTER_NB_HASHES;
107         case 8: // BLOCK_CACHE_ENABLED
108           return BLOCK_CACHE_ENABLED;
109         case 9: // TIME_TO_LIVE
110           return TIME_TO_LIVE;
111         default:
112           return null;
113       }
114     }
115 
116     /**
117      * Find the _Fields constant that matches fieldId, throwing an exception
118      * if it is not found.
119      */
120     public static _Fields findByThriftIdOrThrow(int fieldId) {
121       _Fields fields = findByThriftId(fieldId);
122       if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
123       return fields;
124     }
125 
126     /**
127      * Find the _Fields constant that matches name, or null if its not found.
128      */
129     public static _Fields findByName(String name) {
130       return byName.get(name);
131     }
132 
133     private final short _thriftId;
134     private final String _fieldName;
135 
136     _Fields(short thriftId, String fieldName) {
137       _thriftId = thriftId;
138       _fieldName = fieldName;
139     }
140 
141     public short getThriftFieldId() {
142       return _thriftId;
143     }
144 
145     public String getFieldName() {
146       return _fieldName;
147     }
148   }
149 
150   // isset id assignments
151   private static final int __MAXVERSIONS_ISSET_ID = 0;
152   private static final int __INMEMORY_ISSET_ID = 1;
153   private static final int __BLOOMFILTERVECTORSIZE_ISSET_ID = 2;
154   private static final int __BLOOMFILTERNBHASHES_ISSET_ID = 3;
155   private static final int __BLOCKCACHEENABLED_ISSET_ID = 4;
156   private static final int __TIMETOLIVE_ISSET_ID = 5;
157   private byte __isset_bitfield = 0;
158   public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap;
159   static {
160     Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class);
161     tmpMap.put(_Fields.NAME, new org.apache.thrift.meta_data.FieldMetaData("name", org.apache.thrift.TFieldRequirementType.DEFAULT, 
162         new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING        , "Text")));
163     tmpMap.put(_Fields.MAX_VERSIONS, new org.apache.thrift.meta_data.FieldMetaData("maxVersions", org.apache.thrift.TFieldRequirementType.DEFAULT, 
164         new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.I32)));
165     tmpMap.put(_Fields.COMPRESSION, new org.apache.thrift.meta_data.FieldMetaData("compression", org.apache.thrift.TFieldRequirementType.DEFAULT, 
166         new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING)));
167     tmpMap.put(_Fields.IN_MEMORY, new org.apache.thrift.meta_data.FieldMetaData("inMemory", org.apache.thrift.TFieldRequirementType.DEFAULT, 
168         new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.BOOL)));
169     tmpMap.put(_Fields.BLOOM_FILTER_TYPE, new org.apache.thrift.meta_data.FieldMetaData("bloomFilterType", org.apache.thrift.TFieldRequirementType.DEFAULT, 
170         new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING)));
171     tmpMap.put(_Fields.BLOOM_FILTER_VECTOR_SIZE, new org.apache.thrift.meta_data.FieldMetaData("bloomFilterVectorSize", org.apache.thrift.TFieldRequirementType.DEFAULT, 
172         new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.I32)));
173     tmpMap.put(_Fields.BLOOM_FILTER_NB_HASHES, new org.apache.thrift.meta_data.FieldMetaData("bloomFilterNbHashes", org.apache.thrift.TFieldRequirementType.DEFAULT, 
174         new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.I32)));
175     tmpMap.put(_Fields.BLOCK_CACHE_ENABLED, new org.apache.thrift.meta_data.FieldMetaData("blockCacheEnabled", org.apache.thrift.TFieldRequirementType.DEFAULT, 
176         new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.BOOL)));
177     tmpMap.put(_Fields.TIME_TO_LIVE, new org.apache.thrift.meta_data.FieldMetaData("timeToLive", org.apache.thrift.TFieldRequirementType.DEFAULT, 
178         new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.I32)));
179     metaDataMap = Collections.unmodifiableMap(tmpMap);
180     org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(ColumnDescriptor.class, metaDataMap);
181   }
182 
183   public ColumnDescriptor() {
184     this.maxVersions = 3;
185 
186     this.compression = "NONE";
187 
188     this.inMemory = false;
189 
190     this.bloomFilterType = "NONE";
191 
192     this.bloomFilterVectorSize = 0;
193 
194     this.bloomFilterNbHashes = 0;
195 
196     this.blockCacheEnabled = false;
197 
198     this.timeToLive = 2147483647;
199 
200   }
201 
202   public ColumnDescriptor(
203     ByteBuffer name,
204     int maxVersions,
205     String compression,
206     boolean inMemory,
207     String bloomFilterType,
208     int bloomFilterVectorSize,
209     int bloomFilterNbHashes,
210     boolean blockCacheEnabled,
211     int timeToLive)
212   {
213     this();
214     this.name = name;
215     this.maxVersions = maxVersions;
216     setMaxVersionsIsSet(true);
217     this.compression = compression;
218     this.inMemory = inMemory;
219     setInMemoryIsSet(true);
220     this.bloomFilterType = bloomFilterType;
221     this.bloomFilterVectorSize = bloomFilterVectorSize;
222     setBloomFilterVectorSizeIsSet(true);
223     this.bloomFilterNbHashes = bloomFilterNbHashes;
224     setBloomFilterNbHashesIsSet(true);
225     this.blockCacheEnabled = blockCacheEnabled;
226     setBlockCacheEnabledIsSet(true);
227     this.timeToLive = timeToLive;
228     setTimeToLiveIsSet(true);
229   }
230 
231   /**
232    * Performs a deep copy on <i>other</i>.
233    */
234   public ColumnDescriptor(ColumnDescriptor other) {
235     __isset_bitfield = other.__isset_bitfield;
236     if (other.isSetName()) {
237       this.name = other.name;
238     }
239     this.maxVersions = other.maxVersions;
240     if (other.isSetCompression()) {
241       this.compression = other.compression;
242     }
243     this.inMemory = other.inMemory;
244     if (other.isSetBloomFilterType()) {
245       this.bloomFilterType = other.bloomFilterType;
246     }
247     this.bloomFilterVectorSize = other.bloomFilterVectorSize;
248     this.bloomFilterNbHashes = other.bloomFilterNbHashes;
249     this.blockCacheEnabled = other.blockCacheEnabled;
250     this.timeToLive = other.timeToLive;
251   }
252 
253   public ColumnDescriptor deepCopy() {
254     return new ColumnDescriptor(this);
255   }
256 
257   @Override
258   public void clear() {
259     this.name = null;
260     this.maxVersions = 3;
261 
262     this.compression = "NONE";
263 
264     this.inMemory = false;
265 
266     this.bloomFilterType = "NONE";
267 
268     this.bloomFilterVectorSize = 0;
269 
270     this.bloomFilterNbHashes = 0;
271 
272     this.blockCacheEnabled = false;
273 
274     this.timeToLive = 2147483647;
275 
276   }
277 
278   public byte[] getName() {
279     setName(org.apache.thrift.TBaseHelper.rightSize(name));
280     return name == null ? null : name.array();
281   }
282 
283   public ByteBuffer bufferForName() {
284     return name;
285   }
286 
287   public ColumnDescriptor setName(byte[] name) {
288     setName(name == null ? (ByteBuffer)null : ByteBuffer.wrap(name));
289     return this;
290   }
291 
292   public ColumnDescriptor setName(ByteBuffer name) {
293     this.name = name;
294     return this;
295   }
296 
297   public void unsetName() {
298     this.name = null;
299   }
300 
301   /** Returns true if field name is set (has been assigned a value) and false otherwise */
302   public boolean isSetName() {
303     return this.name != null;
304   }
305 
306   public void setNameIsSet(boolean value) {
307     if (!value) {
308       this.name = null;
309     }
310   }
311 
312   public int getMaxVersions() {
313     return this.maxVersions;
314   }
315 
316   public ColumnDescriptor setMaxVersions(int maxVersions) {
317     this.maxVersions = maxVersions;
318     setMaxVersionsIsSet(true);
319     return this;
320   }
321 
322   public void unsetMaxVersions() {
323     __isset_bitfield = EncodingUtils.clearBit(__isset_bitfield, __MAXVERSIONS_ISSET_ID);
324   }
325 
326   /** Returns true if field maxVersions is set (has been assigned a value) and false otherwise */
327   public boolean isSetMaxVersions() {
328     return EncodingUtils.testBit(__isset_bitfield, __MAXVERSIONS_ISSET_ID);
329   }
330 
331   public void setMaxVersionsIsSet(boolean value) {
332     __isset_bitfield = EncodingUtils.setBit(__isset_bitfield, __MAXVERSIONS_ISSET_ID, value);
333   }
334 
335   public String getCompression() {
336     return this.compression;
337   }
338 
339   public ColumnDescriptor setCompression(String compression) {
340     this.compression = compression;
341     return this;
342   }
343 
344   public void unsetCompression() {
345     this.compression = null;
346   }
347 
348   /** Returns true if field compression is set (has been assigned a value) and false otherwise */
349   public boolean isSetCompression() {
350     return this.compression != null;
351   }
352 
353   public void setCompressionIsSet(boolean value) {
354     if (!value) {
355       this.compression = null;
356     }
357   }
358 
359   public boolean isInMemory() {
360     return this.inMemory;
361   }
362 
363   public ColumnDescriptor setInMemory(boolean inMemory) {
364     this.inMemory = inMemory;
365     setInMemoryIsSet(true);
366     return this;
367   }
368 
369   public void unsetInMemory() {
370     __isset_bitfield = EncodingUtils.clearBit(__isset_bitfield, __INMEMORY_ISSET_ID);
371   }
372 
373   /** Returns true if field inMemory is set (has been assigned a value) and false otherwise */
374   public boolean isSetInMemory() {
375     return EncodingUtils.testBit(__isset_bitfield, __INMEMORY_ISSET_ID);
376   }
377 
378   public void setInMemoryIsSet(boolean value) {
379     __isset_bitfield = EncodingUtils.setBit(__isset_bitfield, __INMEMORY_ISSET_ID, value);
380   }
381 
382   public String getBloomFilterType() {
383     return this.bloomFilterType;
384   }
385 
386   public ColumnDescriptor setBloomFilterType(String bloomFilterType) {
387     this.bloomFilterType = bloomFilterType;
388     return this;
389   }
390 
391   public void unsetBloomFilterType() {
392     this.bloomFilterType = null;
393   }
394 
395   /** Returns true if field bloomFilterType is set (has been assigned a value) and false otherwise */
396   public boolean isSetBloomFilterType() {
397     return this.bloomFilterType != null;
398   }
399 
400   public void setBloomFilterTypeIsSet(boolean value) {
401     if (!value) {
402       this.bloomFilterType = null;
403     }
404   }
405 
406   public int getBloomFilterVectorSize() {
407     return this.bloomFilterVectorSize;
408   }
409 
410   public ColumnDescriptor setBloomFilterVectorSize(int bloomFilterVectorSize) {
411     this.bloomFilterVectorSize = bloomFilterVectorSize;
412     setBloomFilterVectorSizeIsSet(true);
413     return this;
414   }
415 
416   public void unsetBloomFilterVectorSize() {
417     __isset_bitfield = EncodingUtils.clearBit(__isset_bitfield, __BLOOMFILTERVECTORSIZE_ISSET_ID);
418   }
419 
420   /** Returns true if field bloomFilterVectorSize is set (has been assigned a value) and false otherwise */
421   public boolean isSetBloomFilterVectorSize() {
422     return EncodingUtils.testBit(__isset_bitfield, __BLOOMFILTERVECTORSIZE_ISSET_ID);
423   }
424 
425   public void setBloomFilterVectorSizeIsSet(boolean value) {
426     __isset_bitfield = EncodingUtils.setBit(__isset_bitfield, __BLOOMFILTERVECTORSIZE_ISSET_ID, value);
427   }
428 
429   public int getBloomFilterNbHashes() {
430     return this.bloomFilterNbHashes;
431   }
432 
433   public ColumnDescriptor setBloomFilterNbHashes(int bloomFilterNbHashes) {
434     this.bloomFilterNbHashes = bloomFilterNbHashes;
435     setBloomFilterNbHashesIsSet(true);
436     return this;
437   }
438 
439   public void unsetBloomFilterNbHashes() {
440     __isset_bitfield = EncodingUtils.clearBit(__isset_bitfield, __BLOOMFILTERNBHASHES_ISSET_ID);
441   }
442 
443   /** Returns true if field bloomFilterNbHashes is set (has been assigned a value) and false otherwise */
444   public boolean isSetBloomFilterNbHashes() {
445     return EncodingUtils.testBit(__isset_bitfield, __BLOOMFILTERNBHASHES_ISSET_ID);
446   }
447 
448   public void setBloomFilterNbHashesIsSet(boolean value) {
449     __isset_bitfield = EncodingUtils.setBit(__isset_bitfield, __BLOOMFILTERNBHASHES_ISSET_ID, value);
450   }
451 
452   public boolean isBlockCacheEnabled() {
453     return this.blockCacheEnabled;
454   }
455 
456   public ColumnDescriptor setBlockCacheEnabled(boolean blockCacheEnabled) {
457     this.blockCacheEnabled = blockCacheEnabled;
458     setBlockCacheEnabledIsSet(true);
459     return this;
460   }
461 
462   public void unsetBlockCacheEnabled() {
463     __isset_bitfield = EncodingUtils.clearBit(__isset_bitfield, __BLOCKCACHEENABLED_ISSET_ID);
464   }
465 
466   /** Returns true if field blockCacheEnabled is set (has been assigned a value) and false otherwise */
467   public boolean isSetBlockCacheEnabled() {
468     return EncodingUtils.testBit(__isset_bitfield, __BLOCKCACHEENABLED_ISSET_ID);
469   }
470 
471   public void setBlockCacheEnabledIsSet(boolean value) {
472     __isset_bitfield = EncodingUtils.setBit(__isset_bitfield, __BLOCKCACHEENABLED_ISSET_ID, value);
473   }
474 
475   public int getTimeToLive() {
476     return this.timeToLive;
477   }
478 
479   public ColumnDescriptor setTimeToLive(int timeToLive) {
480     this.timeToLive = timeToLive;
481     setTimeToLiveIsSet(true);
482     return this;
483   }
484 
485   public void unsetTimeToLive() {
486     __isset_bitfield = EncodingUtils.clearBit(__isset_bitfield, __TIMETOLIVE_ISSET_ID);
487   }
488 
489   /** Returns true if field timeToLive is set (has been assigned a value) and false otherwise */
490   public boolean isSetTimeToLive() {
491     return EncodingUtils.testBit(__isset_bitfield, __TIMETOLIVE_ISSET_ID);
492   }
493 
494   public void setTimeToLiveIsSet(boolean value) {
495     __isset_bitfield = EncodingUtils.setBit(__isset_bitfield, __TIMETOLIVE_ISSET_ID, value);
496   }
497 
498   public void setFieldValue(_Fields field, Object value) {
499     switch (field) {
500     case NAME:
501       if (value == null) {
502         unsetName();
503       } else {
504         setName((ByteBuffer)value);
505       }
506       break;
507 
508     case MAX_VERSIONS:
509       if (value == null) {
510         unsetMaxVersions();
511       } else {
512         setMaxVersions((Integer)value);
513       }
514       break;
515 
516     case COMPRESSION:
517       if (value == null) {
518         unsetCompression();
519       } else {
520         setCompression((String)value);
521       }
522       break;
523 
524     case IN_MEMORY:
525       if (value == null) {
526         unsetInMemory();
527       } else {
528         setInMemory((Boolean)value);
529       }
530       break;
531 
532     case BLOOM_FILTER_TYPE:
533       if (value == null) {
534         unsetBloomFilterType();
535       } else {
536         setBloomFilterType((String)value);
537       }
538       break;
539 
540     case BLOOM_FILTER_VECTOR_SIZE:
541       if (value == null) {
542         unsetBloomFilterVectorSize();
543       } else {
544         setBloomFilterVectorSize((Integer)value);
545       }
546       break;
547 
548     case BLOOM_FILTER_NB_HASHES:
549       if (value == null) {
550         unsetBloomFilterNbHashes();
551       } else {
552         setBloomFilterNbHashes((Integer)value);
553       }
554       break;
555 
556     case BLOCK_CACHE_ENABLED:
557       if (value == null) {
558         unsetBlockCacheEnabled();
559       } else {
560         setBlockCacheEnabled((Boolean)value);
561       }
562       break;
563 
564     case TIME_TO_LIVE:
565       if (value == null) {
566         unsetTimeToLive();
567       } else {
568         setTimeToLive((Integer)value);
569       }
570       break;
571 
572     }
573   }
574 
575   public Object getFieldValue(_Fields field) {
576     switch (field) {
577     case NAME:
578       return getName();
579 
580     case MAX_VERSIONS:
581       return Integer.valueOf(getMaxVersions());
582 
583     case COMPRESSION:
584       return getCompression();
585 
586     case IN_MEMORY:
587       return Boolean.valueOf(isInMemory());
588 
589     case BLOOM_FILTER_TYPE:
590       return getBloomFilterType();
591 
592     case BLOOM_FILTER_VECTOR_SIZE:
593       return Integer.valueOf(getBloomFilterVectorSize());
594 
595     case BLOOM_FILTER_NB_HASHES:
596       return Integer.valueOf(getBloomFilterNbHashes());
597 
598     case BLOCK_CACHE_ENABLED:
599       return Boolean.valueOf(isBlockCacheEnabled());
600 
601     case TIME_TO_LIVE:
602       return Integer.valueOf(getTimeToLive());
603 
604     }
605     throw new IllegalStateException();
606   }
607 
608   /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */
609   public boolean isSet(_Fields field) {
610     if (field == null) {
611       throw new IllegalArgumentException();
612     }
613 
614     switch (field) {
615     case NAME:
616       return isSetName();
617     case MAX_VERSIONS:
618       return isSetMaxVersions();
619     case COMPRESSION:
620       return isSetCompression();
621     case IN_MEMORY:
622       return isSetInMemory();
623     case BLOOM_FILTER_TYPE:
624       return isSetBloomFilterType();
625     case BLOOM_FILTER_VECTOR_SIZE:
626       return isSetBloomFilterVectorSize();
627     case BLOOM_FILTER_NB_HASHES:
628       return isSetBloomFilterNbHashes();
629     case BLOCK_CACHE_ENABLED:
630       return isSetBlockCacheEnabled();
631     case TIME_TO_LIVE:
632       return isSetTimeToLive();
633     }
634     throw new IllegalStateException();
635   }
636 
637   @Override
638   public boolean equals(Object that) {
639     if (that == null)
640       return false;
641     if (that instanceof ColumnDescriptor)
642       return this.equals((ColumnDescriptor)that);
643     return false;
644   }
645 
646   public boolean equals(ColumnDescriptor that) {
647     if (that == null)
648       return false;
649 
650     boolean this_present_name = true && this.isSetName();
651     boolean that_present_name = true && that.isSetName();
652     if (this_present_name || that_present_name) {
653       if (!(this_present_name && that_present_name))
654         return false;
655       if (!this.name.equals(that.name))
656         return false;
657     }
658 
659     boolean this_present_maxVersions = true;
660     boolean that_present_maxVersions = true;
661     if (this_present_maxVersions || that_present_maxVersions) {
662       if (!(this_present_maxVersions && that_present_maxVersions))
663         return false;
664       if (this.maxVersions != that.maxVersions)
665         return false;
666     }
667 
668     boolean this_present_compression = true && this.isSetCompression();
669     boolean that_present_compression = true && that.isSetCompression();
670     if (this_present_compression || that_present_compression) {
671       if (!(this_present_compression && that_present_compression))
672         return false;
673       if (!this.compression.equals(that.compression))
674         return false;
675     }
676 
677     boolean this_present_inMemory = true;
678     boolean that_present_inMemory = true;
679     if (this_present_inMemory || that_present_inMemory) {
680       if (!(this_present_inMemory && that_present_inMemory))
681         return false;
682       if (this.inMemory != that.inMemory)
683         return false;
684     }
685 
686     boolean this_present_bloomFilterType = true && this.isSetBloomFilterType();
687     boolean that_present_bloomFilterType = true && that.isSetBloomFilterType();
688     if (this_present_bloomFilterType || that_present_bloomFilterType) {
689       if (!(this_present_bloomFilterType && that_present_bloomFilterType))
690         return false;
691       if (!this.bloomFilterType.equals(that.bloomFilterType))
692         return false;
693     }
694 
695     boolean this_present_bloomFilterVectorSize = true;
696     boolean that_present_bloomFilterVectorSize = true;
697     if (this_present_bloomFilterVectorSize || that_present_bloomFilterVectorSize) {
698       if (!(this_present_bloomFilterVectorSize && that_present_bloomFilterVectorSize))
699         return false;
700       if (this.bloomFilterVectorSize != that.bloomFilterVectorSize)
701         return false;
702     }
703 
704     boolean this_present_bloomFilterNbHashes = true;
705     boolean that_present_bloomFilterNbHashes = true;
706     if (this_present_bloomFilterNbHashes || that_present_bloomFilterNbHashes) {
707       if (!(this_present_bloomFilterNbHashes && that_present_bloomFilterNbHashes))
708         return false;
709       if (this.bloomFilterNbHashes != that.bloomFilterNbHashes)
710         return false;
711     }
712 
713     boolean this_present_blockCacheEnabled = true;
714     boolean that_present_blockCacheEnabled = true;
715     if (this_present_blockCacheEnabled || that_present_blockCacheEnabled) {
716       if (!(this_present_blockCacheEnabled && that_present_blockCacheEnabled))
717         return false;
718       if (this.blockCacheEnabled != that.blockCacheEnabled)
719         return false;
720     }
721 
722     boolean this_present_timeToLive = true;
723     boolean that_present_timeToLive = true;
724     if (this_present_timeToLive || that_present_timeToLive) {
725       if (!(this_present_timeToLive && that_present_timeToLive))
726         return false;
727       if (this.timeToLive != that.timeToLive)
728         return false;
729     }
730 
731     return true;
732   }
733 
734   @Override
735   public int hashCode() {
736     HashCodeBuilder builder = new HashCodeBuilder();
737 
738     boolean present_name = true && (isSetName());
739     builder.append(present_name);
740     if (present_name)
741       builder.append(name);
742 
743     boolean present_maxVersions = true;
744     builder.append(present_maxVersions);
745     if (present_maxVersions)
746       builder.append(maxVersions);
747 
748     boolean present_compression = true && (isSetCompression());
749     builder.append(present_compression);
750     if (present_compression)
751       builder.append(compression);
752 
753     boolean present_inMemory = true;
754     builder.append(present_inMemory);
755     if (present_inMemory)
756       builder.append(inMemory);
757 
758     boolean present_bloomFilterType = true && (isSetBloomFilterType());
759     builder.append(present_bloomFilterType);
760     if (present_bloomFilterType)
761       builder.append(bloomFilterType);
762 
763     boolean present_bloomFilterVectorSize = true;
764     builder.append(present_bloomFilterVectorSize);
765     if (present_bloomFilterVectorSize)
766       builder.append(bloomFilterVectorSize);
767 
768     boolean present_bloomFilterNbHashes = true;
769     builder.append(present_bloomFilterNbHashes);
770     if (present_bloomFilterNbHashes)
771       builder.append(bloomFilterNbHashes);
772 
773     boolean present_blockCacheEnabled = true;
774     builder.append(present_blockCacheEnabled);
775     if (present_blockCacheEnabled)
776       builder.append(blockCacheEnabled);
777 
778     boolean present_timeToLive = true;
779     builder.append(present_timeToLive);
780     if (present_timeToLive)
781       builder.append(timeToLive);
782 
783     return builder.toHashCode();
784   }
785 
786   public int compareTo(ColumnDescriptor other) {
787     if (!getClass().equals(other.getClass())) {
788       return getClass().getName().compareTo(other.getClass().getName());
789     }
790 
791     int lastComparison = 0;
792     ColumnDescriptor typedOther = (ColumnDescriptor)other;
793 
794     lastComparison = Boolean.valueOf(isSetName()).compareTo(typedOther.isSetName());
795     if (lastComparison != 0) {
796       return lastComparison;
797     }
798     if (isSetName()) {
799       lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.name, typedOther.name);
800       if (lastComparison != 0) {
801         return lastComparison;
802       }
803     }
804     lastComparison = Boolean.valueOf(isSetMaxVersions()).compareTo(typedOther.isSetMaxVersions());
805     if (lastComparison != 0) {
806       return lastComparison;
807     }
808     if (isSetMaxVersions()) {
809       lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.maxVersions, typedOther.maxVersions);
810       if (lastComparison != 0) {
811         return lastComparison;
812       }
813     }
814     lastComparison = Boolean.valueOf(isSetCompression()).compareTo(typedOther.isSetCompression());
815     if (lastComparison != 0) {
816       return lastComparison;
817     }
818     if (isSetCompression()) {
819       lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.compression, typedOther.compression);
820       if (lastComparison != 0) {
821         return lastComparison;
822       }
823     }
824     lastComparison = Boolean.valueOf(isSetInMemory()).compareTo(typedOther.isSetInMemory());
825     if (lastComparison != 0) {
826       return lastComparison;
827     }
828     if (isSetInMemory()) {
829       lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.inMemory, typedOther.inMemory);
830       if (lastComparison != 0) {
831         return lastComparison;
832       }
833     }
834     lastComparison = Boolean.valueOf(isSetBloomFilterType()).compareTo(typedOther.isSetBloomFilterType());
835     if (lastComparison != 0) {
836       return lastComparison;
837     }
838     if (isSetBloomFilterType()) {
839       lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.bloomFilterType, typedOther.bloomFilterType);
840       if (lastComparison != 0) {
841         return lastComparison;
842       }
843     }
844     lastComparison = Boolean.valueOf(isSetBloomFilterVectorSize()).compareTo(typedOther.isSetBloomFilterVectorSize());
845     if (lastComparison != 0) {
846       return lastComparison;
847     }
848     if (isSetBloomFilterVectorSize()) {
849       lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.bloomFilterVectorSize, typedOther.bloomFilterVectorSize);
850       if (lastComparison != 0) {
851         return lastComparison;
852       }
853     }
854     lastComparison = Boolean.valueOf(isSetBloomFilterNbHashes()).compareTo(typedOther.isSetBloomFilterNbHashes());
855     if (lastComparison != 0) {
856       return lastComparison;
857     }
858     if (isSetBloomFilterNbHashes()) {
859       lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.bloomFilterNbHashes, typedOther.bloomFilterNbHashes);
860       if (lastComparison != 0) {
861         return lastComparison;
862       }
863     }
864     lastComparison = Boolean.valueOf(isSetBlockCacheEnabled()).compareTo(typedOther.isSetBlockCacheEnabled());
865     if (lastComparison != 0) {
866       return lastComparison;
867     }
868     if (isSetBlockCacheEnabled()) {
869       lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.blockCacheEnabled, typedOther.blockCacheEnabled);
870       if (lastComparison != 0) {
871         return lastComparison;
872       }
873     }
874     lastComparison = Boolean.valueOf(isSetTimeToLive()).compareTo(typedOther.isSetTimeToLive());
875     if (lastComparison != 0) {
876       return lastComparison;
877     }
878     if (isSetTimeToLive()) {
879       lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.timeToLive, typedOther.timeToLive);
880       if (lastComparison != 0) {
881         return lastComparison;
882       }
883     }
884     return 0;
885   }
886 
887   public _Fields fieldForId(int fieldId) {
888     return _Fields.findByThriftId(fieldId);
889   }
890 
891   public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException {
892     schemes.get(iprot.getScheme()).getScheme().read(iprot, this);
893   }
894 
895   public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException {
896     schemes.get(oprot.getScheme()).getScheme().write(oprot, this);
897   }
898 
899   @Override
900   public String toString() {
901     StringBuilder sb = new StringBuilder("ColumnDescriptor(");
902     boolean first = true;
903 
904     sb.append("name:");
905     if (this.name == null) {
906       sb.append("null");
907     } else {
908       sb.append(this.name);
909     }
910     first = false;
911     if (!first) sb.append(", ");
912     sb.append("maxVersions:");
913     sb.append(this.maxVersions);
914     first = false;
915     if (!first) sb.append(", ");
916     sb.append("compression:");
917     if (this.compression == null) {
918       sb.append("null");
919     } else {
920       sb.append(this.compression);
921     }
922     first = false;
923     if (!first) sb.append(", ");
924     sb.append("inMemory:");
925     sb.append(this.inMemory);
926     first = false;
927     if (!first) sb.append(", ");
928     sb.append("bloomFilterType:");
929     if (this.bloomFilterType == null) {
930       sb.append("null");
931     } else {
932       sb.append(this.bloomFilterType);
933     }
934     first = false;
935     if (!first) sb.append(", ");
936     sb.append("bloomFilterVectorSize:");
937     sb.append(this.bloomFilterVectorSize);
938     first = false;
939     if (!first) sb.append(", ");
940     sb.append("bloomFilterNbHashes:");
941     sb.append(this.bloomFilterNbHashes);
942     first = false;
943     if (!first) sb.append(", ");
944     sb.append("blockCacheEnabled:");
945     sb.append(this.blockCacheEnabled);
946     first = false;
947     if (!first) sb.append(", ");
948     sb.append("timeToLive:");
949     sb.append(this.timeToLive);
950     first = false;
951     sb.append(")");
952     return sb.toString();
953   }
954 
955   public void validate() throws org.apache.thrift.TException {
956     // check for required fields
957     // check for sub-struct validity
958   }
959 
960   private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException {
961     try {
962       write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out)));
963     } catch (org.apache.thrift.TException te) {
964       throw new java.io.IOException(te);
965     }
966   }
967 
968   private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, ClassNotFoundException {
969     try {
970       // it doesn't seem like you should have to do this, but java serialization is wacky, and doesn't call the default constructor.
971       __isset_bitfield = 0;
972       read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
973     } catch (org.apache.thrift.TException te) {
974       throw new java.io.IOException(te);
975     }
976   }
977 
978   private static class ColumnDescriptorStandardSchemeFactory implements SchemeFactory {
979     public ColumnDescriptorStandardScheme getScheme() {
980       return new ColumnDescriptorStandardScheme();
981     }
982   }
983 
984   private static class ColumnDescriptorStandardScheme extends StandardScheme<ColumnDescriptor> {
985 
986     public void read(org.apache.thrift.protocol.TProtocol iprot, ColumnDescriptor struct) throws org.apache.thrift.TException {
987       org.apache.thrift.protocol.TField schemeField;
988       iprot.readStructBegin();
989       while (true)
990       {
991         schemeField = iprot.readFieldBegin();
992         if (schemeField.type == org.apache.thrift.protocol.TType.STOP) { 
993           break;
994         }
995         switch (schemeField.id) {
996           case 1: // NAME
997             if (schemeField.type == org.apache.thrift.protocol.TType.STRING) {
998               struct.name = iprot.readBinary();
999               struct.setNameIsSet(true);
1000             } else { 
1001               org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
1002             }
1003             break;
1004           case 2: // MAX_VERSIONS
1005             if (schemeField.type == org.apache.thrift.protocol.TType.I32) {
1006               struct.maxVersions = iprot.readI32();
1007               struct.setMaxVersionsIsSet(true);
1008             } else { 
1009               org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
1010             }
1011             break;
1012           case 3: // COMPRESSION
1013             if (schemeField.type == org.apache.thrift.protocol.TType.STRING) {
1014               struct.compression = iprot.readString();
1015               struct.setCompressionIsSet(true);
1016             } else { 
1017               org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
1018             }
1019             break;
1020           case 4: // IN_MEMORY
1021             if (schemeField.type == org.apache.thrift.protocol.TType.BOOL) {
1022               struct.inMemory = iprot.readBool();
1023               struct.setInMemoryIsSet(true);
1024             } else { 
1025               org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
1026             }
1027             break;
1028           case 5: // BLOOM_FILTER_TYPE
1029             if (schemeField.type == org.apache.thrift.protocol.TType.STRING) {
1030               struct.bloomFilterType = iprot.readString();
1031               struct.setBloomFilterTypeIsSet(true);
1032             } else { 
1033               org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
1034             }
1035             break;
1036           case 6: // BLOOM_FILTER_VECTOR_SIZE
1037             if (schemeField.type == org.apache.thrift.protocol.TType.I32) {
1038               struct.bloomFilterVectorSize = iprot.readI32();
1039               struct.setBloomFilterVectorSizeIsSet(true);
1040             } else { 
1041               org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
1042             }
1043             break;
1044           case 7: // BLOOM_FILTER_NB_HASHES
1045             if (schemeField.type == org.apache.thrift.protocol.TType.I32) {
1046               struct.bloomFilterNbHashes = iprot.readI32();
1047               struct.setBloomFilterNbHashesIsSet(true);
1048             } else { 
1049               org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
1050             }
1051             break;
1052           case 8: // BLOCK_CACHE_ENABLED
1053             if (schemeField.type == org.apache.thrift.protocol.TType.BOOL) {
1054               struct.blockCacheEnabled = iprot.readBool();
1055               struct.setBlockCacheEnabledIsSet(true);
1056             } else { 
1057               org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
1058             }
1059             break;
1060           case 9: // TIME_TO_LIVE
1061             if (schemeField.type == org.apache.thrift.protocol.TType.I32) {
1062               struct.timeToLive = iprot.readI32();
1063               struct.setTimeToLiveIsSet(true);
1064             } else { 
1065               org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
1066             }
1067             break;
1068           default:
1069             org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
1070         }
1071         iprot.readFieldEnd();
1072       }
1073       iprot.readStructEnd();
1074 
1075       // check for required fields of primitive type, which can't be checked in the validate method
1076       struct.validate();
1077     }
1078 
1079     public void write(org.apache.thrift.protocol.TProtocol oprot, ColumnDescriptor struct) throws org.apache.thrift.TException {
1080       struct.validate();
1081 
1082       oprot.writeStructBegin(STRUCT_DESC);
1083       if (struct.name != null) {
1084         oprot.writeFieldBegin(NAME_FIELD_DESC);
1085         oprot.writeBinary(struct.name);
1086         oprot.writeFieldEnd();
1087       }
1088       oprot.writeFieldBegin(MAX_VERSIONS_FIELD_DESC);
1089       oprot.writeI32(struct.maxVersions);
1090       oprot.writeFieldEnd();
1091       if (struct.compression != null) {
1092         oprot.writeFieldBegin(COMPRESSION_FIELD_DESC);
1093         oprot.writeString(struct.compression);
1094         oprot.writeFieldEnd();
1095       }
1096       oprot.writeFieldBegin(IN_MEMORY_FIELD_DESC);
1097       oprot.writeBool(struct.inMemory);
1098       oprot.writeFieldEnd();
1099       if (struct.bloomFilterType != null) {
1100         oprot.writeFieldBegin(BLOOM_FILTER_TYPE_FIELD_DESC);
1101         oprot.writeString(struct.bloomFilterType);
1102         oprot.writeFieldEnd();
1103       }
1104       oprot.writeFieldBegin(BLOOM_FILTER_VECTOR_SIZE_FIELD_DESC);
1105       oprot.writeI32(struct.bloomFilterVectorSize);
1106       oprot.writeFieldEnd();
1107       oprot.writeFieldBegin(BLOOM_FILTER_NB_HASHES_FIELD_DESC);
1108       oprot.writeI32(struct.bloomFilterNbHashes);
1109       oprot.writeFieldEnd();
1110       oprot.writeFieldBegin(BLOCK_CACHE_ENABLED_FIELD_DESC);
1111       oprot.writeBool(struct.blockCacheEnabled);
1112       oprot.writeFieldEnd();
1113       oprot.writeFieldBegin(TIME_TO_LIVE_FIELD_DESC);
1114       oprot.writeI32(struct.timeToLive);
1115       oprot.writeFieldEnd();
1116       oprot.writeFieldStop();
1117       oprot.writeStructEnd();
1118     }
1119 
1120   }
1121 
1122   private static class ColumnDescriptorTupleSchemeFactory implements SchemeFactory {
1123     public ColumnDescriptorTupleScheme getScheme() {
1124       return new ColumnDescriptorTupleScheme();
1125     }
1126   }
1127 
1128   private static class ColumnDescriptorTupleScheme extends TupleScheme<ColumnDescriptor> {
1129 
1130     @Override
1131     public void write(org.apache.thrift.protocol.TProtocol prot, ColumnDescriptor struct) throws org.apache.thrift.TException {
1132       TTupleProtocol oprot = (TTupleProtocol) prot;
1133       BitSet optionals = new BitSet();
1134       if (struct.isSetName()) {
1135         optionals.set(0);
1136       }
1137       if (struct.isSetMaxVersions()) {
1138         optionals.set(1);
1139       }
1140       if (struct.isSetCompression()) {
1141         optionals.set(2);
1142       }
1143       if (struct.isSetInMemory()) {
1144         optionals.set(3);
1145       }
1146       if (struct.isSetBloomFilterType()) {
1147         optionals.set(4);
1148       }
1149       if (struct.isSetBloomFilterVectorSize()) {
1150         optionals.set(5);
1151       }
1152       if (struct.isSetBloomFilterNbHashes()) {
1153         optionals.set(6);
1154       }
1155       if (struct.isSetBlockCacheEnabled()) {
1156         optionals.set(7);
1157       }
1158       if (struct.isSetTimeToLive()) {
1159         optionals.set(8);
1160       }
1161       oprot.writeBitSet(optionals, 9);
1162       if (struct.isSetName()) {
1163         oprot.writeBinary(struct.name);
1164       }
1165       if (struct.isSetMaxVersions()) {
1166         oprot.writeI32(struct.maxVersions);
1167       }
1168       if (struct.isSetCompression()) {
1169         oprot.writeString(struct.compression);
1170       }
1171       if (struct.isSetInMemory()) {
1172         oprot.writeBool(struct.inMemory);
1173       }
1174       if (struct.isSetBloomFilterType()) {
1175         oprot.writeString(struct.bloomFilterType);
1176       }
1177       if (struct.isSetBloomFilterVectorSize()) {
1178         oprot.writeI32(struct.bloomFilterVectorSize);
1179       }
1180       if (struct.isSetBloomFilterNbHashes()) {
1181         oprot.writeI32(struct.bloomFilterNbHashes);
1182       }
1183       if (struct.isSetBlockCacheEnabled()) {
1184         oprot.writeBool(struct.blockCacheEnabled);
1185       }
1186       if (struct.isSetTimeToLive()) {
1187         oprot.writeI32(struct.timeToLive);
1188       }
1189     }
1190 
1191     @Override
1192     public void read(org.apache.thrift.protocol.TProtocol prot, ColumnDescriptor struct) throws org.apache.thrift.TException {
1193       TTupleProtocol iprot = (TTupleProtocol) prot;
1194       BitSet incoming = iprot.readBitSet(9);
1195       if (incoming.get(0)) {
1196         struct.name = iprot.readBinary();
1197         struct.setNameIsSet(true);
1198       }
1199       if (incoming.get(1)) {
1200         struct.maxVersions = iprot.readI32();
1201         struct.setMaxVersionsIsSet(true);
1202       }
1203       if (incoming.get(2)) {
1204         struct.compression = iprot.readString();
1205         struct.setCompressionIsSet(true);
1206       }
1207       if (incoming.get(3)) {
1208         struct.inMemory = iprot.readBool();
1209         struct.setInMemoryIsSet(true);
1210       }
1211       if (incoming.get(4)) {
1212         struct.bloomFilterType = iprot.readString();
1213         struct.setBloomFilterTypeIsSet(true);
1214       }
1215       if (incoming.get(5)) {
1216         struct.bloomFilterVectorSize = iprot.readI32();
1217         struct.setBloomFilterVectorSizeIsSet(true);
1218       }
1219       if (incoming.get(6)) {
1220         struct.bloomFilterNbHashes = iprot.readI32();
1221         struct.setBloomFilterNbHashesIsSet(true);
1222       }
1223       if (incoming.get(7)) {
1224         struct.blockCacheEnabled = iprot.readBool();
1225         struct.setBlockCacheEnabledIsSet(true);
1226       }
1227       if (incoming.get(8)) {
1228         struct.timeToLive = iprot.readI32();
1229         struct.setTimeToLiveIsSet(true);
1230       }
1231     }
1232   }
1233 
1234 }
1235