1
2
3
4
5
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
36
37
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;
59 public int maxVersions;
60 public String compression;
61 public boolean inMemory;
62 public String bloomFilterType;
63 public int bloomFilterVectorSize;
64 public int bloomFilterNbHashes;
65 public boolean blockCacheEnabled;
66 public int timeToLive;
67
68
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
90
91 public static _Fields findByThriftId(int fieldId) {
92 switch(fieldId) {
93 case 1:
94 return NAME;
95 case 2:
96 return MAX_VERSIONS;
97 case 3:
98 return COMPRESSION;
99 case 4:
100 return IN_MEMORY;
101 case 5:
102 return BLOOM_FILTER_TYPE;
103 case 6:
104 return BLOOM_FILTER_VECTOR_SIZE;
105 case 7:
106 return BLOOM_FILTER_NB_HASHES;
107 case 8:
108 return BLOCK_CACHE_ENABLED;
109 case 9:
110 return TIME_TO_LIVE;
111 default:
112 return null;
113 }
114 }
115
116
117
118
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
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
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
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
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
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
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
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
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
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
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
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
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
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
957
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
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:
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:
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:
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:
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:
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:
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:
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:
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:
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
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