http://git-wip-us.apache.org/repos/asf/hbase/blob/7820ba1d/hbase-thrift/src/main/java/org/apache/hadoop/hbase/thrift2/generated/TColumnFamilyDescriptor.java ---------------------------------------------------------------------- diff --git a/hbase-thrift/src/main/java/org/apache/hadoop/hbase/thrift2/generated/TColumnFamilyDescriptor.java b/hbase-thrift/src/main/java/org/apache/hadoop/hbase/thrift2/generated/TColumnFamilyDescriptor.java new file mode 100644 index 0000000..03cb2f6 --- /dev/null +++ b/hbase-thrift/src/main/java/org/apache/hadoop/hbase/thrift2/generated/TColumnFamilyDescriptor.java @@ -0,0 +1,2519 @@ +/** + * Autogenerated by Thrift Compiler (0.9.3) + * + * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING + * @generated + */ +package org.apache.hadoop.hbase.thrift2.generated; + +import org.apache.thrift.scheme.IScheme; +import org.apache.thrift.scheme.SchemeFactory; +import org.apache.thrift.scheme.StandardScheme; + +import org.apache.thrift.scheme.TupleScheme; +import org.apache.thrift.protocol.TTupleProtocol; +import org.apache.thrift.protocol.TProtocolException; +import org.apache.thrift.EncodingUtils; +import org.apache.thrift.TException; +import org.apache.thrift.async.AsyncMethodCallback; +import org.apache.thrift.server.AbstractNonblockingServer.*; +import java.util.List; +import java.util.ArrayList; +import java.util.Map; +import java.util.HashMap; +import java.util.EnumMap; +import java.util.Set; +import java.util.HashSet; +import java.util.EnumSet; +import java.util.Collections; +import java.util.BitSet; +import java.nio.ByteBuffer; +import java.util.Arrays; +import javax.annotation.Generated; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +@SuppressWarnings({"cast", "rawtypes", "serial", "unchecked"}) +@Generated(value = "Autogenerated by Thrift Compiler (0.9.3)", date = "2018-12-27") +public class TColumnFamilyDescriptor implements org.apache.thrift.TBase<TColumnFamilyDescriptor, TColumnFamilyDescriptor._Fields>, java.io.Serializable, Cloneable, Comparable<TColumnFamilyDescriptor> { + private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("TColumnFamilyDescriptor"); + + 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); + private static final org.apache.thrift.protocol.TField ATTRIBUTES_FIELD_DESC = new org.apache.thrift.protocol.TField("attributes", org.apache.thrift.protocol.TType.MAP, (short)2); + private static final org.apache.thrift.protocol.TField CONFIGURATION_FIELD_DESC = new org.apache.thrift.protocol.TField("configuration", org.apache.thrift.protocol.TType.MAP, (short)3); + private static final org.apache.thrift.protocol.TField BLOCK_SIZE_FIELD_DESC = new org.apache.thrift.protocol.TField("blockSize", org.apache.thrift.protocol.TType.I32, (short)4); + private static final org.apache.thrift.protocol.TField BLOOMN_FILTER_TYPE_FIELD_DESC = new org.apache.thrift.protocol.TField("bloomnFilterType", org.apache.thrift.protocol.TType.I32, (short)5); + private static final org.apache.thrift.protocol.TField COMPRESSION_TYPE_FIELD_DESC = new org.apache.thrift.protocol.TField("compressionType", org.apache.thrift.protocol.TType.I32, (short)6); + private static final org.apache.thrift.protocol.TField DFS_REPLICATION_FIELD_DESC = new org.apache.thrift.protocol.TField("dfsReplication", org.apache.thrift.protocol.TType.I16, (short)7); + private static final org.apache.thrift.protocol.TField DATA_BLOCK_ENCODING_FIELD_DESC = new org.apache.thrift.protocol.TField("dataBlockEncoding", org.apache.thrift.protocol.TType.I32, (short)8); + private static final org.apache.thrift.protocol.TField KEEP_DELETED_CELLS_FIELD_DESC = new org.apache.thrift.protocol.TField("keepDeletedCells", org.apache.thrift.protocol.TType.I32, (short)9); + 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)10); + private static final org.apache.thrift.protocol.TField MIN_VERSIONS_FIELD_DESC = new org.apache.thrift.protocol.TField("minVersions", org.apache.thrift.protocol.TType.I32, (short)11); + private static final org.apache.thrift.protocol.TField SCOPE_FIELD_DESC = new org.apache.thrift.protocol.TField("scope", org.apache.thrift.protocol.TType.I32, (short)12); + 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)13); + 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)14); + private static final org.apache.thrift.protocol.TField CACHE_BLOOMS_ON_WRITE_FIELD_DESC = new org.apache.thrift.protocol.TField("cacheBloomsOnWrite", org.apache.thrift.protocol.TType.BOOL, (short)15); + private static final org.apache.thrift.protocol.TField CACHE_DATA_ON_WRITE_FIELD_DESC = new org.apache.thrift.protocol.TField("cacheDataOnWrite", org.apache.thrift.protocol.TType.BOOL, (short)16); + private static final org.apache.thrift.protocol.TField CACHE_INDEXES_ON_WRITE_FIELD_DESC = new org.apache.thrift.protocol.TField("cacheIndexesOnWrite", org.apache.thrift.protocol.TType.BOOL, (short)17); + private static final org.apache.thrift.protocol.TField COMPRESS_TAGS_FIELD_DESC = new org.apache.thrift.protocol.TField("compressTags", org.apache.thrift.protocol.TType.BOOL, (short)18); + private static final org.apache.thrift.protocol.TField EVICT_BLOCKS_ON_CLOSE_FIELD_DESC = new org.apache.thrift.protocol.TField("evictBlocksOnClose", org.apache.thrift.protocol.TType.BOOL, (short)19); + 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)20); + + private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>(); + static { + schemes.put(StandardScheme.class, new TColumnFamilyDescriptorStandardSchemeFactory()); + schemes.put(TupleScheme.class, new TColumnFamilyDescriptorTupleSchemeFactory()); + } + + public ByteBuffer name; // required + public Map<ByteBuffer,ByteBuffer> attributes; // optional + public Map<String,String> configuration; // optional + public int blockSize; // optional + /** + * + * @see TBloomFilterType + */ + public TBloomFilterType bloomnFilterType; // optional + /** + * + * @see TCompressionAlgorithm + */ + public TCompressionAlgorithm compressionType; // optional + public short dfsReplication; // optional + /** + * + * @see TDataBlockEncoding + */ + public TDataBlockEncoding dataBlockEncoding; // optional + /** + * + * @see TKeepDeletedCells + */ + public TKeepDeletedCells keepDeletedCells; // optional + public int maxVersions; // optional + public int minVersions; // optional + public int scope; // optional + public int timeToLive; // optional + public boolean blockCacheEnabled; // optional + public boolean cacheBloomsOnWrite; // optional + public boolean cacheDataOnWrite; // optional + public boolean cacheIndexesOnWrite; // optional + public boolean compressTags; // optional + public boolean evictBlocksOnClose; // optional + public boolean inMemory; // optional + + /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */ + public enum _Fields implements org.apache.thrift.TFieldIdEnum { + NAME((short)1, "name"), + ATTRIBUTES((short)2, "attributes"), + CONFIGURATION((short)3, "configuration"), + BLOCK_SIZE((short)4, "blockSize"), + /** + * + * @see TBloomFilterType + */ + BLOOMN_FILTER_TYPE((short)5, "bloomnFilterType"), + /** + * + * @see TCompressionAlgorithm + */ + COMPRESSION_TYPE((short)6, "compressionType"), + DFS_REPLICATION((short)7, "dfsReplication"), + /** + * + * @see TDataBlockEncoding + */ + DATA_BLOCK_ENCODING((short)8, "dataBlockEncoding"), + /** + * + * @see TKeepDeletedCells + */ + KEEP_DELETED_CELLS((short)9, "keepDeletedCells"), + MAX_VERSIONS((short)10, "maxVersions"), + MIN_VERSIONS((short)11, "minVersions"), + SCOPE((short)12, "scope"), + TIME_TO_LIVE((short)13, "timeToLive"), + BLOCK_CACHE_ENABLED((short)14, "blockCacheEnabled"), + CACHE_BLOOMS_ON_WRITE((short)15, "cacheBloomsOnWrite"), + CACHE_DATA_ON_WRITE((short)16, "cacheDataOnWrite"), + CACHE_INDEXES_ON_WRITE((short)17, "cacheIndexesOnWrite"), + COMPRESS_TAGS((short)18, "compressTags"), + EVICT_BLOCKS_ON_CLOSE((short)19, "evictBlocksOnClose"), + IN_MEMORY((short)20, "inMemory"); + + private static final Map<String, _Fields> byName = new HashMap<String, _Fields>(); + + static { + for (_Fields field : EnumSet.allOf(_Fields.class)) { + byName.put(field.getFieldName(), field); + } + } + + /** + * Find the _Fields constant that matches fieldId, or null if its not found. + */ + public static _Fields findByThriftId(int fieldId) { + switch(fieldId) { + case 1: // NAME + return NAME; + case 2: // ATTRIBUTES + return ATTRIBUTES; + case 3: // CONFIGURATION + return CONFIGURATION; + case 4: // BLOCK_SIZE + return BLOCK_SIZE; + case 5: // BLOOMN_FILTER_TYPE + return BLOOMN_FILTER_TYPE; + case 6: // COMPRESSION_TYPE + return COMPRESSION_TYPE; + case 7: // DFS_REPLICATION + return DFS_REPLICATION; + case 8: // DATA_BLOCK_ENCODING + return DATA_BLOCK_ENCODING; + case 9: // KEEP_DELETED_CELLS + return KEEP_DELETED_CELLS; + case 10: // MAX_VERSIONS + return MAX_VERSIONS; + case 11: // MIN_VERSIONS + return MIN_VERSIONS; + case 12: // SCOPE + return SCOPE; + case 13: // TIME_TO_LIVE + return TIME_TO_LIVE; + case 14: // BLOCK_CACHE_ENABLED + return BLOCK_CACHE_ENABLED; + case 15: // CACHE_BLOOMS_ON_WRITE + return CACHE_BLOOMS_ON_WRITE; + case 16: // CACHE_DATA_ON_WRITE + return CACHE_DATA_ON_WRITE; + case 17: // CACHE_INDEXES_ON_WRITE + return CACHE_INDEXES_ON_WRITE; + case 18: // COMPRESS_TAGS + return COMPRESS_TAGS; + case 19: // EVICT_BLOCKS_ON_CLOSE + return EVICT_BLOCKS_ON_CLOSE; + case 20: // IN_MEMORY + return IN_MEMORY; + default: + return null; + } + } + + /** + * Find the _Fields constant that matches fieldId, throwing an exception + * if it is not found. + */ + public static _Fields findByThriftIdOrThrow(int fieldId) { + _Fields fields = findByThriftId(fieldId); + if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!"); + return fields; + } + + /** + * Find the _Fields constant that matches name, or null if its not found. + */ + public static _Fields findByName(String name) { + return byName.get(name); + } + + private final short _thriftId; + private final String _fieldName; + + _Fields(short thriftId, String fieldName) { + _thriftId = thriftId; + _fieldName = fieldName; + } + + public short getThriftFieldId() { + return _thriftId; + } + + public String getFieldName() { + return _fieldName; + } + } + + // isset id assignments + private static final int __BLOCKSIZE_ISSET_ID = 0; + private static final int __DFSREPLICATION_ISSET_ID = 1; + private static final int __MAXVERSIONS_ISSET_ID = 2; + private static final int __MINVERSIONS_ISSET_ID = 3; + private static final int __SCOPE_ISSET_ID = 4; + private static final int __TIMETOLIVE_ISSET_ID = 5; + private static final int __BLOCKCACHEENABLED_ISSET_ID = 6; + private static final int __CACHEBLOOMSONWRITE_ISSET_ID = 7; + private static final int __CACHEDATAONWRITE_ISSET_ID = 8; + private static final int __CACHEINDEXESONWRITE_ISSET_ID = 9; + private static final int __COMPRESSTAGS_ISSET_ID = 10; + private static final int __EVICTBLOCKSONCLOSE_ISSET_ID = 11; + private static final int __INMEMORY_ISSET_ID = 12; + private short __isset_bitfield = 0; + private static final _Fields optionals[] = {_Fields.ATTRIBUTES,_Fields.CONFIGURATION,_Fields.BLOCK_SIZE,_Fields.BLOOMN_FILTER_TYPE,_Fields.COMPRESSION_TYPE,_Fields.DFS_REPLICATION,_Fields.DATA_BLOCK_ENCODING,_Fields.KEEP_DELETED_CELLS,_Fields.MAX_VERSIONS,_Fields.MIN_VERSIONS,_Fields.SCOPE,_Fields.TIME_TO_LIVE,_Fields.BLOCK_CACHE_ENABLED,_Fields.CACHE_BLOOMS_ON_WRITE,_Fields.CACHE_DATA_ON_WRITE,_Fields.CACHE_INDEXES_ON_WRITE,_Fields.COMPRESS_TAGS,_Fields.EVICT_BLOCKS_ON_CLOSE,_Fields.IN_MEMORY}; + public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap; + static { + Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class); + tmpMap.put(_Fields.NAME, new org.apache.thrift.meta_data.FieldMetaData("name", org.apache.thrift.TFieldRequirementType.REQUIRED, + new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING , true))); + tmpMap.put(_Fields.ATTRIBUTES, new org.apache.thrift.meta_data.FieldMetaData("attributes", org.apache.thrift.TFieldRequirementType.OPTIONAL, + new org.apache.thrift.meta_data.MapMetaData(org.apache.thrift.protocol.TType.MAP, + new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING , true), + new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING , true)))); + tmpMap.put(_Fields.CONFIGURATION, new org.apache.thrift.meta_data.FieldMetaData("configuration", org.apache.thrift.TFieldRequirementType.OPTIONAL, + new org.apache.thrift.meta_data.MapMetaData(org.apache.thrift.protocol.TType.MAP, + new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING), + new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING)))); + tmpMap.put(_Fields.BLOCK_SIZE, new org.apache.thrift.meta_data.FieldMetaData("blockSize", org.apache.thrift.TFieldRequirementType.OPTIONAL, + new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.I32))); + tmpMap.put(_Fields.BLOOMN_FILTER_TYPE, new org.apache.thrift.meta_data.FieldMetaData("bloomnFilterType", org.apache.thrift.TFieldRequirementType.OPTIONAL, + new org.apache.thrift.meta_data.EnumMetaData(org.apache.thrift.protocol.TType.ENUM, TBloomFilterType.class))); + tmpMap.put(_Fields.COMPRESSION_TYPE, new org.apache.thrift.meta_data.FieldMetaData("compressionType", org.apache.thrift.TFieldRequirementType.OPTIONAL, + new org.apache.thrift.meta_data.EnumMetaData(org.apache.thrift.protocol.TType.ENUM, TCompressionAlgorithm.class))); + tmpMap.put(_Fields.DFS_REPLICATION, new org.apache.thrift.meta_data.FieldMetaData("dfsReplication", org.apache.thrift.TFieldRequirementType.OPTIONAL, + new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.I16))); + tmpMap.put(_Fields.DATA_BLOCK_ENCODING, new org.apache.thrift.meta_data.FieldMetaData("dataBlockEncoding", org.apache.thrift.TFieldRequirementType.OPTIONAL, + new org.apache.thrift.meta_data.EnumMetaData(org.apache.thrift.protocol.TType.ENUM, TDataBlockEncoding.class))); + tmpMap.put(_Fields.KEEP_DELETED_CELLS, new org.apache.thrift.meta_data.FieldMetaData("keepDeletedCells", org.apache.thrift.TFieldRequirementType.OPTIONAL, + new org.apache.thrift.meta_data.EnumMetaData(org.apache.thrift.protocol.TType.ENUM, TKeepDeletedCells.class))); + tmpMap.put(_Fields.MAX_VERSIONS, new org.apache.thrift.meta_data.FieldMetaData("maxVersions", org.apache.thrift.TFieldRequirementType.OPTIONAL, + new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.I32))); + tmpMap.put(_Fields.MIN_VERSIONS, new org.apache.thrift.meta_data.FieldMetaData("minVersions", org.apache.thrift.TFieldRequirementType.OPTIONAL, + new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.I32))); + tmpMap.put(_Fields.SCOPE, new org.apache.thrift.meta_data.FieldMetaData("scope", org.apache.thrift.TFieldRequirementType.OPTIONAL, + new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.I32))); + tmpMap.put(_Fields.TIME_TO_LIVE, new org.apache.thrift.meta_data.FieldMetaData("timeToLive", org.apache.thrift.TFieldRequirementType.OPTIONAL, + new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.I32))); + tmpMap.put(_Fields.BLOCK_CACHE_ENABLED, new org.apache.thrift.meta_data.FieldMetaData("blockCacheEnabled", org.apache.thrift.TFieldRequirementType.OPTIONAL, + new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.BOOL))); + tmpMap.put(_Fields.CACHE_BLOOMS_ON_WRITE, new org.apache.thrift.meta_data.FieldMetaData("cacheBloomsOnWrite", org.apache.thrift.TFieldRequirementType.OPTIONAL, + new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.BOOL))); + tmpMap.put(_Fields.CACHE_DATA_ON_WRITE, new org.apache.thrift.meta_data.FieldMetaData("cacheDataOnWrite", org.apache.thrift.TFieldRequirementType.OPTIONAL, + new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.BOOL))); + tmpMap.put(_Fields.CACHE_INDEXES_ON_WRITE, new org.apache.thrift.meta_data.FieldMetaData("cacheIndexesOnWrite", org.apache.thrift.TFieldRequirementType.OPTIONAL, + new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.BOOL))); + tmpMap.put(_Fields.COMPRESS_TAGS, new org.apache.thrift.meta_data.FieldMetaData("compressTags", org.apache.thrift.TFieldRequirementType.OPTIONAL, + new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.BOOL))); + tmpMap.put(_Fields.EVICT_BLOCKS_ON_CLOSE, new org.apache.thrift.meta_data.FieldMetaData("evictBlocksOnClose", org.apache.thrift.TFieldRequirementType.OPTIONAL, + new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.BOOL))); + tmpMap.put(_Fields.IN_MEMORY, new org.apache.thrift.meta_data.FieldMetaData("inMemory", org.apache.thrift.TFieldRequirementType.OPTIONAL, + new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.BOOL))); + metaDataMap = Collections.unmodifiableMap(tmpMap); + org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(TColumnFamilyDescriptor.class, metaDataMap); + } + + public TColumnFamilyDescriptor() { + } + + public TColumnFamilyDescriptor( + ByteBuffer name) + { + this(); + this.name = org.apache.thrift.TBaseHelper.copyBinary(name); + } + + /** + * Performs a deep copy on <i>other</i>. + */ + public TColumnFamilyDescriptor(TColumnFamilyDescriptor other) { + __isset_bitfield = other.__isset_bitfield; + if (other.isSetName()) { + this.name = org.apache.thrift.TBaseHelper.copyBinary(other.name); + } + if (other.isSetAttributes()) { + Map<ByteBuffer,ByteBuffer> __this__attributes = new HashMap<ByteBuffer,ByteBuffer>(other.attributes); + this.attributes = __this__attributes; + } + if (other.isSetConfiguration()) { + Map<String,String> __this__configuration = new HashMap<String,String>(other.configuration); + this.configuration = __this__configuration; + } + this.blockSize = other.blockSize; + if (other.isSetBloomnFilterType()) { + this.bloomnFilterType = other.bloomnFilterType; + } + if (other.isSetCompressionType()) { + this.compressionType = other.compressionType; + } + this.dfsReplication = other.dfsReplication; + if (other.isSetDataBlockEncoding()) { + this.dataBlockEncoding = other.dataBlockEncoding; + } + if (other.isSetKeepDeletedCells()) { + this.keepDeletedCells = other.keepDeletedCells; + } + this.maxVersions = other.maxVersions; + this.minVersions = other.minVersions; + this.scope = other.scope; + this.timeToLive = other.timeToLive; + this.blockCacheEnabled = other.blockCacheEnabled; + this.cacheBloomsOnWrite = other.cacheBloomsOnWrite; + this.cacheDataOnWrite = other.cacheDataOnWrite; + this.cacheIndexesOnWrite = other.cacheIndexesOnWrite; + this.compressTags = other.compressTags; + this.evictBlocksOnClose = other.evictBlocksOnClose; + this.inMemory = other.inMemory; + } + + public TColumnFamilyDescriptor deepCopy() { + return new TColumnFamilyDescriptor(this); + } + + @Override + public void clear() { + this.name = null; + this.attributes = null; + this.configuration = null; + setBlockSizeIsSet(false); + this.blockSize = 0; + this.bloomnFilterType = null; + this.compressionType = null; + setDfsReplicationIsSet(false); + this.dfsReplication = 0; + this.dataBlockEncoding = null; + this.keepDeletedCells = null; + setMaxVersionsIsSet(false); + this.maxVersions = 0; + setMinVersionsIsSet(false); + this.minVersions = 0; + setScopeIsSet(false); + this.scope = 0; + setTimeToLiveIsSet(false); + this.timeToLive = 0; + setBlockCacheEnabledIsSet(false); + this.blockCacheEnabled = false; + setCacheBloomsOnWriteIsSet(false); + this.cacheBloomsOnWrite = false; + setCacheDataOnWriteIsSet(false); + this.cacheDataOnWrite = false; + setCacheIndexesOnWriteIsSet(false); + this.cacheIndexesOnWrite = false; + setCompressTagsIsSet(false); + this.compressTags = false; + setEvictBlocksOnCloseIsSet(false); + this.evictBlocksOnClose = false; + setInMemoryIsSet(false); + this.inMemory = false; + } + + public byte[] getName() { + setName(org.apache.thrift.TBaseHelper.rightSize(name)); + return name == null ? null : name.array(); + } + + public ByteBuffer bufferForName() { + return org.apache.thrift.TBaseHelper.copyBinary(name); + } + + public TColumnFamilyDescriptor setName(byte[] name) { + this.name = name == null ? (ByteBuffer)null : ByteBuffer.wrap(Arrays.copyOf(name, name.length)); + return this; + } + + public TColumnFamilyDescriptor setName(ByteBuffer name) { + this.name = org.apache.thrift.TBaseHelper.copyBinary(name); + return this; + } + + public void unsetName() { + this.name = null; + } + + /** Returns true if field name is set (has been assigned a value) and false otherwise */ + public boolean isSetName() { + return this.name != null; + } + + public void setNameIsSet(boolean value) { + if (!value) { + this.name = null; + } + } + + public int getAttributesSize() { + return (this.attributes == null) ? 0 : this.attributes.size(); + } + + public void putToAttributes(ByteBuffer key, ByteBuffer val) { + if (this.attributes == null) { + this.attributes = new HashMap<ByteBuffer,ByteBuffer>(); + } + this.attributes.put(key, val); + } + + public Map<ByteBuffer,ByteBuffer> getAttributes() { + return this.attributes; + } + + public TColumnFamilyDescriptor setAttributes(Map<ByteBuffer,ByteBuffer> attributes) { + this.attributes = attributes; + return this; + } + + public void unsetAttributes() { + this.attributes = null; + } + + /** Returns true if field attributes is set (has been assigned a value) and false otherwise */ + public boolean isSetAttributes() { + return this.attributes != null; + } + + public void setAttributesIsSet(boolean value) { + if (!value) { + this.attributes = null; + } + } + + public int getConfigurationSize() { + return (this.configuration == null) ? 0 : this.configuration.size(); + } + + public void putToConfiguration(String key, String val) { + if (this.configuration == null) { + this.configuration = new HashMap<String,String>(); + } + this.configuration.put(key, val); + } + + public Map<String,String> getConfiguration() { + return this.configuration; + } + + public TColumnFamilyDescriptor setConfiguration(Map<String,String> configuration) { + this.configuration = configuration; + return this; + } + + public void unsetConfiguration() { + this.configuration = null; + } + + /** Returns true if field configuration is set (has been assigned a value) and false otherwise */ + public boolean isSetConfiguration() { + return this.configuration != null; + } + + public void setConfigurationIsSet(boolean value) { + if (!value) { + this.configuration = null; + } + } + + public int getBlockSize() { + return this.blockSize; + } + + public TColumnFamilyDescriptor setBlockSize(int blockSize) { + this.blockSize = blockSize; + setBlockSizeIsSet(true); + return this; + } + + public void unsetBlockSize() { + __isset_bitfield = EncodingUtils.clearBit(__isset_bitfield, __BLOCKSIZE_ISSET_ID); + } + + /** Returns true if field blockSize is set (has been assigned a value) and false otherwise */ + public boolean isSetBlockSize() { + return EncodingUtils.testBit(__isset_bitfield, __BLOCKSIZE_ISSET_ID); + } + + public void setBlockSizeIsSet(boolean value) { + __isset_bitfield = EncodingUtils.setBit(__isset_bitfield, __BLOCKSIZE_ISSET_ID, value); + } + + /** + * + * @see TBloomFilterType + */ + public TBloomFilterType getBloomnFilterType() { + return this.bloomnFilterType; + } + + /** + * + * @see TBloomFilterType + */ + public TColumnFamilyDescriptor setBloomnFilterType(TBloomFilterType bloomnFilterType) { + this.bloomnFilterType = bloomnFilterType; + return this; + } + + public void unsetBloomnFilterType() { + this.bloomnFilterType = null; + } + + /** Returns true if field bloomnFilterType is set (has been assigned a value) and false otherwise */ + public boolean isSetBloomnFilterType() { + return this.bloomnFilterType != null; + } + + public void setBloomnFilterTypeIsSet(boolean value) { + if (!value) { + this.bloomnFilterType = null; + } + } + + /** + * + * @see TCompressionAlgorithm + */ + public TCompressionAlgorithm getCompressionType() { + return this.compressionType; + } + + /** + * + * @see TCompressionAlgorithm + */ + public TColumnFamilyDescriptor setCompressionType(TCompressionAlgorithm compressionType) { + this.compressionType = compressionType; + return this; + } + + public void unsetCompressionType() { + this.compressionType = null; + } + + /** Returns true if field compressionType is set (has been assigned a value) and false otherwise */ + public boolean isSetCompressionType() { + return this.compressionType != null; + } + + public void setCompressionTypeIsSet(boolean value) { + if (!value) { + this.compressionType = null; + } + } + + public short getDfsReplication() { + return this.dfsReplication; + } + + public TColumnFamilyDescriptor setDfsReplication(short dfsReplication) { + this.dfsReplication = dfsReplication; + setDfsReplicationIsSet(true); + return this; + } + + public void unsetDfsReplication() { + __isset_bitfield = EncodingUtils.clearBit(__isset_bitfield, __DFSREPLICATION_ISSET_ID); + } + + /** Returns true if field dfsReplication is set (has been assigned a value) and false otherwise */ + public boolean isSetDfsReplication() { + return EncodingUtils.testBit(__isset_bitfield, __DFSREPLICATION_ISSET_ID); + } + + public void setDfsReplicationIsSet(boolean value) { + __isset_bitfield = EncodingUtils.setBit(__isset_bitfield, __DFSREPLICATION_ISSET_ID, value); + } + + /** + * + * @see TDataBlockEncoding + */ + public TDataBlockEncoding getDataBlockEncoding() { + return this.dataBlockEncoding; + } + + /** + * + * @see TDataBlockEncoding + */ + public TColumnFamilyDescriptor setDataBlockEncoding(TDataBlockEncoding dataBlockEncoding) { + this.dataBlockEncoding = dataBlockEncoding; + return this; + } + + public void unsetDataBlockEncoding() { + this.dataBlockEncoding = null; + } + + /** Returns true if field dataBlockEncoding is set (has been assigned a value) and false otherwise */ + public boolean isSetDataBlockEncoding() { + return this.dataBlockEncoding != null; + } + + public void setDataBlockEncodingIsSet(boolean value) { + if (!value) { + this.dataBlockEncoding = null; + } + } + + /** + * + * @see TKeepDeletedCells + */ + public TKeepDeletedCells getKeepDeletedCells() { + return this.keepDeletedCells; + } + + /** + * + * @see TKeepDeletedCells + */ + public TColumnFamilyDescriptor setKeepDeletedCells(TKeepDeletedCells keepDeletedCells) { + this.keepDeletedCells = keepDeletedCells; + return this; + } + + public void unsetKeepDeletedCells() { + this.keepDeletedCells = null; + } + + /** Returns true if field keepDeletedCells is set (has been assigned a value) and false otherwise */ + public boolean isSetKeepDeletedCells() { + return this.keepDeletedCells != null; + } + + public void setKeepDeletedCellsIsSet(boolean value) { + if (!value) { + this.keepDeletedCells = null; + } + } + + public int getMaxVersions() { + return this.maxVersions; + } + + public TColumnFamilyDescriptor setMaxVersions(int maxVersions) { + this.maxVersions = maxVersions; + setMaxVersionsIsSet(true); + return this; + } + + public void unsetMaxVersions() { + __isset_bitfield = EncodingUtils.clearBit(__isset_bitfield, __MAXVERSIONS_ISSET_ID); + } + + /** Returns true if field maxVersions is set (has been assigned a value) and false otherwise */ + public boolean isSetMaxVersions() { + return EncodingUtils.testBit(__isset_bitfield, __MAXVERSIONS_ISSET_ID); + } + + public void setMaxVersionsIsSet(boolean value) { + __isset_bitfield = EncodingUtils.setBit(__isset_bitfield, __MAXVERSIONS_ISSET_ID, value); + } + + public int getMinVersions() { + return this.minVersions; + } + + public TColumnFamilyDescriptor setMinVersions(int minVersions) { + this.minVersions = minVersions; + setMinVersionsIsSet(true); + return this; + } + + public void unsetMinVersions() { + __isset_bitfield = EncodingUtils.clearBit(__isset_bitfield, __MINVERSIONS_ISSET_ID); + } + + /** Returns true if field minVersions is set (has been assigned a value) and false otherwise */ + public boolean isSetMinVersions() { + return EncodingUtils.testBit(__isset_bitfield, __MINVERSIONS_ISSET_ID); + } + + public void setMinVersionsIsSet(boolean value) { + __isset_bitfield = EncodingUtils.setBit(__isset_bitfield, __MINVERSIONS_ISSET_ID, value); + } + + public int getScope() { + return this.scope; + } + + public TColumnFamilyDescriptor setScope(int scope) { + this.scope = scope; + setScopeIsSet(true); + return this; + } + + public void unsetScope() { + __isset_bitfield = EncodingUtils.clearBit(__isset_bitfield, __SCOPE_ISSET_ID); + } + + /** Returns true if field scope is set (has been assigned a value) and false otherwise */ + public boolean isSetScope() { + return EncodingUtils.testBit(__isset_bitfield, __SCOPE_ISSET_ID); + } + + public void setScopeIsSet(boolean value) { + __isset_bitfield = EncodingUtils.setBit(__isset_bitfield, __SCOPE_ISSET_ID, value); + } + + public int getTimeToLive() { + return this.timeToLive; + } + + public TColumnFamilyDescriptor setTimeToLive(int timeToLive) { + this.timeToLive = timeToLive; + setTimeToLiveIsSet(true); + return this; + } + + public void unsetTimeToLive() { + __isset_bitfield = EncodingUtils.clearBit(__isset_bitfield, __TIMETOLIVE_ISSET_ID); + } + + /** Returns true if field timeToLive is set (has been assigned a value) and false otherwise */ + public boolean isSetTimeToLive() { + return EncodingUtils.testBit(__isset_bitfield, __TIMETOLIVE_ISSET_ID); + } + + public void setTimeToLiveIsSet(boolean value) { + __isset_bitfield = EncodingUtils.setBit(__isset_bitfield, __TIMETOLIVE_ISSET_ID, value); + } + + public boolean isBlockCacheEnabled() { + return this.blockCacheEnabled; + } + + public TColumnFamilyDescriptor setBlockCacheEnabled(boolean blockCacheEnabled) { + this.blockCacheEnabled = blockCacheEnabled; + setBlockCacheEnabledIsSet(true); + return this; + } + + public void unsetBlockCacheEnabled() { + __isset_bitfield = EncodingUtils.clearBit(__isset_bitfield, __BLOCKCACHEENABLED_ISSET_ID); + } + + /** Returns true if field blockCacheEnabled is set (has been assigned a value) and false otherwise */ + public boolean isSetBlockCacheEnabled() { + return EncodingUtils.testBit(__isset_bitfield, __BLOCKCACHEENABLED_ISSET_ID); + } + + public void setBlockCacheEnabledIsSet(boolean value) { + __isset_bitfield = EncodingUtils.setBit(__isset_bitfield, __BLOCKCACHEENABLED_ISSET_ID, value); + } + + public boolean isCacheBloomsOnWrite() { + return this.cacheBloomsOnWrite; + } + + public TColumnFamilyDescriptor setCacheBloomsOnWrite(boolean cacheBloomsOnWrite) { + this.cacheBloomsOnWrite = cacheBloomsOnWrite; + setCacheBloomsOnWriteIsSet(true); + return this; + } + + public void unsetCacheBloomsOnWrite() { + __isset_bitfield = EncodingUtils.clearBit(__isset_bitfield, __CACHEBLOOMSONWRITE_ISSET_ID); + } + + /** Returns true if field cacheBloomsOnWrite is set (has been assigned a value) and false otherwise */ + public boolean isSetCacheBloomsOnWrite() { + return EncodingUtils.testBit(__isset_bitfield, __CACHEBLOOMSONWRITE_ISSET_ID); + } + + public void setCacheBloomsOnWriteIsSet(boolean value) { + __isset_bitfield = EncodingUtils.setBit(__isset_bitfield, __CACHEBLOOMSONWRITE_ISSET_ID, value); + } + + public boolean isCacheDataOnWrite() { + return this.cacheDataOnWrite; + } + + public TColumnFamilyDescriptor setCacheDataOnWrite(boolean cacheDataOnWrite) { + this.cacheDataOnWrite = cacheDataOnWrite; + setCacheDataOnWriteIsSet(true); + return this; + } + + public void unsetCacheDataOnWrite() { + __isset_bitfield = EncodingUtils.clearBit(__isset_bitfield, __CACHEDATAONWRITE_ISSET_ID); + } + + /** Returns true if field cacheDataOnWrite is set (has been assigned a value) and false otherwise */ + public boolean isSetCacheDataOnWrite() { + return EncodingUtils.testBit(__isset_bitfield, __CACHEDATAONWRITE_ISSET_ID); + } + + public void setCacheDataOnWriteIsSet(boolean value) { + __isset_bitfield = EncodingUtils.setBit(__isset_bitfield, __CACHEDATAONWRITE_ISSET_ID, value); + } + + public boolean isCacheIndexesOnWrite() { + return this.cacheIndexesOnWrite; + } + + public TColumnFamilyDescriptor setCacheIndexesOnWrite(boolean cacheIndexesOnWrite) { + this.cacheIndexesOnWrite = cacheIndexesOnWrite; + setCacheIndexesOnWriteIsSet(true); + return this; + } + + public void unsetCacheIndexesOnWrite() { + __isset_bitfield = EncodingUtils.clearBit(__isset_bitfield, __CACHEINDEXESONWRITE_ISSET_ID); + } + + /** Returns true if field cacheIndexesOnWrite is set (has been assigned a value) and false otherwise */ + public boolean isSetCacheIndexesOnWrite() { + return EncodingUtils.testBit(__isset_bitfield, __CACHEINDEXESONWRITE_ISSET_ID); + } + + public void setCacheIndexesOnWriteIsSet(boolean value) { + __isset_bitfield = EncodingUtils.setBit(__isset_bitfield, __CACHEINDEXESONWRITE_ISSET_ID, value); + } + + public boolean isCompressTags() { + return this.compressTags; + } + + public TColumnFamilyDescriptor setCompressTags(boolean compressTags) { + this.compressTags = compressTags; + setCompressTagsIsSet(true); + return this; + } + + public void unsetCompressTags() { + __isset_bitfield = EncodingUtils.clearBit(__isset_bitfield, __COMPRESSTAGS_ISSET_ID); + } + + /** Returns true if field compressTags is set (has been assigned a value) and false otherwise */ + public boolean isSetCompressTags() { + return EncodingUtils.testBit(__isset_bitfield, __COMPRESSTAGS_ISSET_ID); + } + + public void setCompressTagsIsSet(boolean value) { + __isset_bitfield = EncodingUtils.setBit(__isset_bitfield, __COMPRESSTAGS_ISSET_ID, value); + } + + public boolean isEvictBlocksOnClose() { + return this.evictBlocksOnClose; + } + + public TColumnFamilyDescriptor setEvictBlocksOnClose(boolean evictBlocksOnClose) { + this.evictBlocksOnClose = evictBlocksOnClose; + setEvictBlocksOnCloseIsSet(true); + return this; + } + + public void unsetEvictBlocksOnClose() { + __isset_bitfield = EncodingUtils.clearBit(__isset_bitfield, __EVICTBLOCKSONCLOSE_ISSET_ID); + } + + /** Returns true if field evictBlocksOnClose is set (has been assigned a value) and false otherwise */ + public boolean isSetEvictBlocksOnClose() { + return EncodingUtils.testBit(__isset_bitfield, __EVICTBLOCKSONCLOSE_ISSET_ID); + } + + public void setEvictBlocksOnCloseIsSet(boolean value) { + __isset_bitfield = EncodingUtils.setBit(__isset_bitfield, __EVICTBLOCKSONCLOSE_ISSET_ID, value); + } + + public boolean isInMemory() { + return this.inMemory; + } + + public TColumnFamilyDescriptor setInMemory(boolean inMemory) { + this.inMemory = inMemory; + setInMemoryIsSet(true); + return this; + } + + public void unsetInMemory() { + __isset_bitfield = EncodingUtils.clearBit(__isset_bitfield, __INMEMORY_ISSET_ID); + } + + /** Returns true if field inMemory is set (has been assigned a value) and false otherwise */ + public boolean isSetInMemory() { + return EncodingUtils.testBit(__isset_bitfield, __INMEMORY_ISSET_ID); + } + + public void setInMemoryIsSet(boolean value) { + __isset_bitfield = EncodingUtils.setBit(__isset_bitfield, __INMEMORY_ISSET_ID, value); + } + + public void setFieldValue(_Fields field, Object value) { + switch (field) { + case NAME: + if (value == null) { + unsetName(); + } else { + setName((ByteBuffer)value); + } + break; + + case ATTRIBUTES: + if (value == null) { + unsetAttributes(); + } else { + setAttributes((Map<ByteBuffer,ByteBuffer>)value); + } + break; + + case CONFIGURATION: + if (value == null) { + unsetConfiguration(); + } else { + setConfiguration((Map<String,String>)value); + } + break; + + case BLOCK_SIZE: + if (value == null) { + unsetBlockSize(); + } else { + setBlockSize((Integer)value); + } + break; + + case BLOOMN_FILTER_TYPE: + if (value == null) { + unsetBloomnFilterType(); + } else { + setBloomnFilterType((TBloomFilterType)value); + } + break; + + case COMPRESSION_TYPE: + if (value == null) { + unsetCompressionType(); + } else { + setCompressionType((TCompressionAlgorithm)value); + } + break; + + case DFS_REPLICATION: + if (value == null) { + unsetDfsReplication(); + } else { + setDfsReplication((Short)value); + } + break; + + case DATA_BLOCK_ENCODING: + if (value == null) { + unsetDataBlockEncoding(); + } else { + setDataBlockEncoding((TDataBlockEncoding)value); + } + break; + + case KEEP_DELETED_CELLS: + if (value == null) { + unsetKeepDeletedCells(); + } else { + setKeepDeletedCells((TKeepDeletedCells)value); + } + break; + + case MAX_VERSIONS: + if (value == null) { + unsetMaxVersions(); + } else { + setMaxVersions((Integer)value); + } + break; + + case MIN_VERSIONS: + if (value == null) { + unsetMinVersions(); + } else { + setMinVersions((Integer)value); + } + break; + + case SCOPE: + if (value == null) { + unsetScope(); + } else { + setScope((Integer)value); + } + break; + + case TIME_TO_LIVE: + if (value == null) { + unsetTimeToLive(); + } else { + setTimeToLive((Integer)value); + } + break; + + case BLOCK_CACHE_ENABLED: + if (value == null) { + unsetBlockCacheEnabled(); + } else { + setBlockCacheEnabled((Boolean)value); + } + break; + + case CACHE_BLOOMS_ON_WRITE: + if (value == null) { + unsetCacheBloomsOnWrite(); + } else { + setCacheBloomsOnWrite((Boolean)value); + } + break; + + case CACHE_DATA_ON_WRITE: + if (value == null) { + unsetCacheDataOnWrite(); + } else { + setCacheDataOnWrite((Boolean)value); + } + break; + + case CACHE_INDEXES_ON_WRITE: + if (value == null) { + unsetCacheIndexesOnWrite(); + } else { + setCacheIndexesOnWrite((Boolean)value); + } + break; + + case COMPRESS_TAGS: + if (value == null) { + unsetCompressTags(); + } else { + setCompressTags((Boolean)value); + } + break; + + case EVICT_BLOCKS_ON_CLOSE: + if (value == null) { + unsetEvictBlocksOnClose(); + } else { + setEvictBlocksOnClose((Boolean)value); + } + break; + + case IN_MEMORY: + if (value == null) { + unsetInMemory(); + } else { + setInMemory((Boolean)value); + } + break; + + } + } + + public Object getFieldValue(_Fields field) { + switch (field) { + case NAME: + return getName(); + + case ATTRIBUTES: + return getAttributes(); + + case CONFIGURATION: + return getConfiguration(); + + case BLOCK_SIZE: + return getBlockSize(); + + case BLOOMN_FILTER_TYPE: + return getBloomnFilterType(); + + case COMPRESSION_TYPE: + return getCompressionType(); + + case DFS_REPLICATION: + return getDfsReplication(); + + case DATA_BLOCK_ENCODING: + return getDataBlockEncoding(); + + case KEEP_DELETED_CELLS: + return getKeepDeletedCells(); + + case MAX_VERSIONS: + return getMaxVersions(); + + case MIN_VERSIONS: + return getMinVersions(); + + case SCOPE: + return getScope(); + + case TIME_TO_LIVE: + return getTimeToLive(); + + case BLOCK_CACHE_ENABLED: + return isBlockCacheEnabled(); + + case CACHE_BLOOMS_ON_WRITE: + return isCacheBloomsOnWrite(); + + case CACHE_DATA_ON_WRITE: + return isCacheDataOnWrite(); + + case CACHE_INDEXES_ON_WRITE: + return isCacheIndexesOnWrite(); + + case COMPRESS_TAGS: + return isCompressTags(); + + case EVICT_BLOCKS_ON_CLOSE: + return isEvictBlocksOnClose(); + + case IN_MEMORY: + return isInMemory(); + + } + throw new IllegalStateException(); + } + + /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */ + public boolean isSet(_Fields field) { + if (field == null) { + throw new IllegalArgumentException(); + } + + switch (field) { + case NAME: + return isSetName(); + case ATTRIBUTES: + return isSetAttributes(); + case CONFIGURATION: + return isSetConfiguration(); + case BLOCK_SIZE: + return isSetBlockSize(); + case BLOOMN_FILTER_TYPE: + return isSetBloomnFilterType(); + case COMPRESSION_TYPE: + return isSetCompressionType(); + case DFS_REPLICATION: + return isSetDfsReplication(); + case DATA_BLOCK_ENCODING: + return isSetDataBlockEncoding(); + case KEEP_DELETED_CELLS: + return isSetKeepDeletedCells(); + case MAX_VERSIONS: + return isSetMaxVersions(); + case MIN_VERSIONS: + return isSetMinVersions(); + case SCOPE: + return isSetScope(); + case TIME_TO_LIVE: + return isSetTimeToLive(); + case BLOCK_CACHE_ENABLED: + return isSetBlockCacheEnabled(); + case CACHE_BLOOMS_ON_WRITE: + return isSetCacheBloomsOnWrite(); + case CACHE_DATA_ON_WRITE: + return isSetCacheDataOnWrite(); + case CACHE_INDEXES_ON_WRITE: + return isSetCacheIndexesOnWrite(); + case COMPRESS_TAGS: + return isSetCompressTags(); + case EVICT_BLOCKS_ON_CLOSE: + return isSetEvictBlocksOnClose(); + case IN_MEMORY: + return isSetInMemory(); + } + throw new IllegalStateException(); + } + + @Override + public boolean equals(Object that) { + if (that == null) + return false; + if (that instanceof TColumnFamilyDescriptor) + return this.equals((TColumnFamilyDescriptor)that); + return false; + } + + public boolean equals(TColumnFamilyDescriptor that) { + if (that == null) + return false; + + boolean this_present_name = true && this.isSetName(); + boolean that_present_name = true && that.isSetName(); + if (this_present_name || that_present_name) { + if (!(this_present_name && that_present_name)) + return false; + if (!this.name.equals(that.name)) + return false; + } + + boolean this_present_attributes = true && this.isSetAttributes(); + boolean that_present_attributes = true && that.isSetAttributes(); + if (this_present_attributes || that_present_attributes) { + if (!(this_present_attributes && that_present_attributes)) + return false; + if (!this.attributes.equals(that.attributes)) + return false; + } + + boolean this_present_configuration = true && this.isSetConfiguration(); + boolean that_present_configuration = true && that.isSetConfiguration(); + if (this_present_configuration || that_present_configuration) { + if (!(this_present_configuration && that_present_configuration)) + return false; + if (!this.configuration.equals(that.configuration)) + return false; + } + + boolean this_present_blockSize = true && this.isSetBlockSize(); + boolean that_present_blockSize = true && that.isSetBlockSize(); + if (this_present_blockSize || that_present_blockSize) { + if (!(this_present_blockSize && that_present_blockSize)) + return false; + if (this.blockSize != that.blockSize) + return false; + } + + boolean this_present_bloomnFilterType = true && this.isSetBloomnFilterType(); + boolean that_present_bloomnFilterType = true && that.isSetBloomnFilterType(); + if (this_present_bloomnFilterType || that_present_bloomnFilterType) { + if (!(this_present_bloomnFilterType && that_present_bloomnFilterType)) + return false; + if (!this.bloomnFilterType.equals(that.bloomnFilterType)) + return false; + } + + boolean this_present_compressionType = true && this.isSetCompressionType(); + boolean that_present_compressionType = true && that.isSetCompressionType(); + if (this_present_compressionType || that_present_compressionType) { + if (!(this_present_compressionType && that_present_compressionType)) + return false; + if (!this.compressionType.equals(that.compressionType)) + return false; + } + + boolean this_present_dfsReplication = true && this.isSetDfsReplication(); + boolean that_present_dfsReplication = true && that.isSetDfsReplication(); + if (this_present_dfsReplication || that_present_dfsReplication) { + if (!(this_present_dfsReplication && that_present_dfsReplication)) + return false; + if (this.dfsReplication != that.dfsReplication) + return false; + } + + boolean this_present_dataBlockEncoding = true && this.isSetDataBlockEncoding(); + boolean that_present_dataBlockEncoding = true && that.isSetDataBlockEncoding(); + if (this_present_dataBlockEncoding || that_present_dataBlockEncoding) { + if (!(this_present_dataBlockEncoding && that_present_dataBlockEncoding)) + return false; + if (!this.dataBlockEncoding.equals(that.dataBlockEncoding)) + return false; + } + + boolean this_present_keepDeletedCells = true && this.isSetKeepDeletedCells(); + boolean that_present_keepDeletedCells = true && that.isSetKeepDeletedCells(); + if (this_present_keepDeletedCells || that_present_keepDeletedCells) { + if (!(this_present_keepDeletedCells && that_present_keepDeletedCells)) + return false; + if (!this.keepDeletedCells.equals(that.keepDeletedCells)) + return false; + } + + boolean this_present_maxVersions = true && this.isSetMaxVersions(); + boolean that_present_maxVersions = true && that.isSetMaxVersions(); + if (this_present_maxVersions || that_present_maxVersions) { + if (!(this_present_maxVersions && that_present_maxVersions)) + return false; + if (this.maxVersions != that.maxVersions) + return false; + } + + boolean this_present_minVersions = true && this.isSetMinVersions(); + boolean that_present_minVersions = true && that.isSetMinVersions(); + if (this_present_minVersions || that_present_minVersions) { + if (!(this_present_minVersions && that_present_minVersions)) + return false; + if (this.minVersions != that.minVersions) + return false; + } + + boolean this_present_scope = true && this.isSetScope(); + boolean that_present_scope = true && that.isSetScope(); + if (this_present_scope || that_present_scope) { + if (!(this_present_scope && that_present_scope)) + return false; + if (this.scope != that.scope) + return false; + } + + boolean this_present_timeToLive = true && this.isSetTimeToLive(); + boolean that_present_timeToLive = true && that.isSetTimeToLive(); + if (this_present_timeToLive || that_present_timeToLive) { + if (!(this_present_timeToLive && that_present_timeToLive)) + return false; + if (this.timeToLive != that.timeToLive) + return false; + } + + boolean this_present_blockCacheEnabled = true && this.isSetBlockCacheEnabled(); + boolean that_present_blockCacheEnabled = true && that.isSetBlockCacheEnabled(); + if (this_present_blockCacheEnabled || that_present_blockCacheEnabled) { + if (!(this_present_blockCacheEnabled && that_present_blockCacheEnabled)) + return false; + if (this.blockCacheEnabled != that.blockCacheEnabled) + return false; + } + + boolean this_present_cacheBloomsOnWrite = true && this.isSetCacheBloomsOnWrite(); + boolean that_present_cacheBloomsOnWrite = true && that.isSetCacheBloomsOnWrite(); + if (this_present_cacheBloomsOnWrite || that_present_cacheBloomsOnWrite) { + if (!(this_present_cacheBloomsOnWrite && that_present_cacheBloomsOnWrite)) + return false; + if (this.cacheBloomsOnWrite != that.cacheBloomsOnWrite) + return false; + } + + boolean this_present_cacheDataOnWrite = true && this.isSetCacheDataOnWrite(); + boolean that_present_cacheDataOnWrite = true && that.isSetCacheDataOnWrite(); + if (this_present_cacheDataOnWrite || that_present_cacheDataOnWrite) { + if (!(this_present_cacheDataOnWrite && that_present_cacheDataOnWrite)) + return false; + if (this.cacheDataOnWrite != that.cacheDataOnWrite) + return false; + } + + boolean this_present_cacheIndexesOnWrite = true && this.isSetCacheIndexesOnWrite(); + boolean that_present_cacheIndexesOnWrite = true && that.isSetCacheIndexesOnWrite(); + if (this_present_cacheIndexesOnWrite || that_present_cacheIndexesOnWrite) { + if (!(this_present_cacheIndexesOnWrite && that_present_cacheIndexesOnWrite)) + return false; + if (this.cacheIndexesOnWrite != that.cacheIndexesOnWrite) + return false; + } + + boolean this_present_compressTags = true && this.isSetCompressTags(); + boolean that_present_compressTags = true && that.isSetCompressTags(); + if (this_present_compressTags || that_present_compressTags) { + if (!(this_present_compressTags && that_present_compressTags)) + return false; + if (this.compressTags != that.compressTags) + return false; + } + + boolean this_present_evictBlocksOnClose = true && this.isSetEvictBlocksOnClose(); + boolean that_present_evictBlocksOnClose = true && that.isSetEvictBlocksOnClose(); + if (this_present_evictBlocksOnClose || that_present_evictBlocksOnClose) { + if (!(this_present_evictBlocksOnClose && that_present_evictBlocksOnClose)) + return false; + if (this.evictBlocksOnClose != that.evictBlocksOnClose) + return false; + } + + boolean this_present_inMemory = true && this.isSetInMemory(); + boolean that_present_inMemory = true && that.isSetInMemory(); + if (this_present_inMemory || that_present_inMemory) { + if (!(this_present_inMemory && that_present_inMemory)) + return false; + if (this.inMemory != that.inMemory) + return false; + } + + return true; + } + + @Override + public int hashCode() { + List<Object> list = new ArrayList<Object>(); + + boolean present_name = true && (isSetName()); + list.add(present_name); + if (present_name) + list.add(name); + + boolean present_attributes = true && (isSetAttributes()); + list.add(present_attributes); + if (present_attributes) + list.add(attributes); + + boolean present_configuration = true && (isSetConfiguration()); + list.add(present_configuration); + if (present_configuration) + list.add(configuration); + + boolean present_blockSize = true && (isSetBlockSize()); + list.add(present_blockSize); + if (present_blockSize) + list.add(blockSize); + + boolean present_bloomnFilterType = true && (isSetBloomnFilterType()); + list.add(present_bloomnFilterType); + if (present_bloomnFilterType) + list.add(bloomnFilterType.getValue()); + + boolean present_compressionType = true && (isSetCompressionType()); + list.add(present_compressionType); + if (present_compressionType) + list.add(compressionType.getValue()); + + boolean present_dfsReplication = true && (isSetDfsReplication()); + list.add(present_dfsReplication); + if (present_dfsReplication) + list.add(dfsReplication); + + boolean present_dataBlockEncoding = true && (isSetDataBlockEncoding()); + list.add(present_dataBlockEncoding); + if (present_dataBlockEncoding) + list.add(dataBlockEncoding.getValue()); + + boolean present_keepDeletedCells = true && (isSetKeepDeletedCells()); + list.add(present_keepDeletedCells); + if (present_keepDeletedCells) + list.add(keepDeletedCells.getValue()); + + boolean present_maxVersions = true && (isSetMaxVersions()); + list.add(present_maxVersions); + if (present_maxVersions) + list.add(maxVersions); + + boolean present_minVersions = true && (isSetMinVersions()); + list.add(present_minVersions); + if (present_minVersions) + list.add(minVersions); + + boolean present_scope = true && (isSetScope()); + list.add(present_scope); + if (present_scope) + list.add(scope); + + boolean present_timeToLive = true && (isSetTimeToLive()); + list.add(present_timeToLive); + if (present_timeToLive) + list.add(timeToLive); + + boolean present_blockCacheEnabled = true && (isSetBlockCacheEnabled()); + list.add(present_blockCacheEnabled); + if (present_blockCacheEnabled) + list.add(blockCacheEnabled); + + boolean present_cacheBloomsOnWrite = true && (isSetCacheBloomsOnWrite()); + list.add(present_cacheBloomsOnWrite); + if (present_cacheBloomsOnWrite) + list.add(cacheBloomsOnWrite); + + boolean present_cacheDataOnWrite = true && (isSetCacheDataOnWrite()); + list.add(present_cacheDataOnWrite); + if (present_cacheDataOnWrite) + list.add(cacheDataOnWrite); + + boolean present_cacheIndexesOnWrite = true && (isSetCacheIndexesOnWrite()); + list.add(present_cacheIndexesOnWrite); + if (present_cacheIndexesOnWrite) + list.add(cacheIndexesOnWrite); + + boolean present_compressTags = true && (isSetCompressTags()); + list.add(present_compressTags); + if (present_compressTags) + list.add(compressTags); + + boolean present_evictBlocksOnClose = true && (isSetEvictBlocksOnClose()); + list.add(present_evictBlocksOnClose); + if (present_evictBlocksOnClose) + list.add(evictBlocksOnClose); + + boolean present_inMemory = true && (isSetInMemory()); + list.add(present_inMemory); + if (present_inMemory) + list.add(inMemory); + + return list.hashCode(); + } + + @Override + public int compareTo(TColumnFamilyDescriptor other) { + if (!getClass().equals(other.getClass())) { + return getClass().getName().compareTo(other.getClass().getName()); + } + + int lastComparison = 0; + + lastComparison = Boolean.valueOf(isSetName()).compareTo(other.isSetName()); + if (lastComparison != 0) { + return lastComparison; + } + if (isSetName()) { + lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.name, other.name); + if (lastComparison != 0) { + return lastComparison; + } + } + lastComparison = Boolean.valueOf(isSetAttributes()).compareTo(other.isSetAttributes()); + if (lastComparison != 0) { + return lastComparison; + } + if (isSetAttributes()) { + lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.attributes, other.attributes); + if (lastComparison != 0) { + return lastComparison; + } + } + lastComparison = Boolean.valueOf(isSetConfiguration()).compareTo(other.isSetConfiguration()); + if (lastComparison != 0) { + return lastComparison; + } + if (isSetConfiguration()) { + lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.configuration, other.configuration); + if (lastComparison != 0) { + return lastComparison; + } + } + lastComparison = Boolean.valueOf(isSetBlockSize()).compareTo(other.isSetBlockSize()); + if (lastComparison != 0) { + return lastComparison; + } + if (isSetBlockSize()) { + lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.blockSize, other.blockSize); + if (lastComparison != 0) { + return lastComparison; + } + } + lastComparison = Boolean.valueOf(isSetBloomnFilterType()).compareTo(other.isSetBloomnFilterType()); + if (lastComparison != 0) { + return lastComparison; + } + if (isSetBloomnFilterType()) { + lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.bloomnFilterType, other.bloomnFilterType); + if (lastComparison != 0) { + return lastComparison; + } + } + lastComparison = Boolean.valueOf(isSetCompressionType()).compareTo(other.isSetCompressionType()); + if (lastComparison != 0) { + return lastComparison; + } + if (isSetCompressionType()) { + lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.compressionType, other.compressionType); + if (lastComparison != 0) { + return lastComparison; + } + } + lastComparison = Boolean.valueOf(isSetDfsReplication()).compareTo(other.isSetDfsReplication()); + if (lastComparison != 0) { + return lastComparison; + } + if (isSetDfsReplication()) { + lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.dfsReplication, other.dfsReplication); + if (lastComparison != 0) { + return lastComparison; + } + } + lastComparison = Boolean.valueOf(isSetDataBlockEncoding()).compareTo(other.isSetDataBlockEncoding()); + if (lastComparison != 0) { + return lastComparison; + } + if (isSetDataBlockEncoding()) { + lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.dataBlockEncoding, other.dataBlockEncoding); + if (lastComparison != 0) { + return lastComparison; + } + } + lastComparison = Boolean.valueOf(isSetKeepDeletedCells()).compareTo(other.isSetKeepDeletedCells()); + if (lastComparison != 0) { + return lastComparison; + } + if (isSetKeepDeletedCells()) { + lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.keepDeletedCells, other.keepDeletedCells); + if (lastComparison != 0) { + return lastComparison; + } + } + lastComparison = Boolean.valueOf(isSetMaxVersions()).compareTo(other.isSetMaxVersions()); + if (lastComparison != 0) { + return lastComparison; + } + if (isSetMaxVersions()) { + lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.maxVersions, other.maxVersions); + if (lastComparison != 0) { + return lastComparison; + } + } + lastComparison = Boolean.valueOf(isSetMinVersions()).compareTo(other.isSetMinVersions()); + if (lastComparison != 0) { + return lastComparison; + } + if (isSetMinVersions()) { + lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.minVersions, other.minVersions); + if (lastComparison != 0) { + return lastComparison; + } + } + lastComparison = Boolean.valueOf(isSetScope()).compareTo(other.isSetScope()); + if (lastComparison != 0) { + return lastComparison; + } + if (isSetScope()) { + lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.scope, other.scope); + if (lastComparison != 0) { + return lastComparison; + } + } + lastComparison = Boolean.valueOf(isSetTimeToLive()).compareTo(other.isSetTimeToLive()); + if (lastComparison != 0) { + return lastComparison; + } + if (isSetTimeToLive()) { + lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.timeToLive, other.timeToLive); + if (lastComparison != 0) { + return lastComparison; + } + } + lastComparison = Boolean.valueOf(isSetBlockCacheEnabled()).compareTo(other.isSetBlockCacheEnabled()); + if (lastComparison != 0) { + return lastComparison; + } + if (isSetBlockCacheEnabled()) { + lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.blockCacheEnabled, other.blockCacheEnabled); + if (lastComparison != 0) { + return lastComparison; + } + } + lastComparison = Boolean.valueOf(isSetCacheBloomsOnWrite()).compareTo(other.isSetCacheBloomsOnWrite()); + if (lastComparison != 0) { + return lastComparison; + } + if (isSetCacheBloomsOnWrite()) { + lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.cacheBloomsOnWrite, other.cacheBloomsOnWrite); + if (lastComparison != 0) { + return lastComparison; + } + } + lastComparison = Boolean.valueOf(isSetCacheDataOnWrite()).compareTo(other.isSetCacheDataOnWrite()); + if (lastComparison != 0) { + return lastComparison; + } + if (isSetCacheDataOnWrite()) { + lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.cacheDataOnWrite, other.cacheDataOnWrite); + if (lastComparison != 0) { + return lastComparison; + } + } + lastComparison = Boolean.valueOf(isSetCacheIndexesOnWrite()).compareTo(other.isSetCacheIndexesOnWrite()); + if (lastComparison != 0) { + return lastComparison; + } + if (isSetCacheIndexesOnWrite()) { + lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.cacheIndexesOnWrite, other.cacheIndexesOnWrite); + if (lastComparison != 0) { + return lastComparison; + } + } + lastComparison = Boolean.valueOf(isSetCompressTags()).compareTo(other.isSetCompressTags()); + if (lastComparison != 0) { + return lastComparison; + } + if (isSetCompressTags()) { + lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.compressTags, other.compressTags); + if (lastComparison != 0) { + return lastComparison; + } + } + lastComparison = Boolean.valueOf(isSetEvictBlocksOnClose()).compareTo(other.isSetEvictBlocksOnClose()); + if (lastComparison != 0) { + return lastComparison; + } + if (isSetEvictBlocksOnClose()) { + lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.evictBlocksOnClose, other.evictBlocksOnClose); + if (lastComparison != 0) { + return lastComparison; + } + } + lastComparison = Boolean.valueOf(isSetInMemory()).compareTo(other.isSetInMemory()); + if (lastComparison != 0) { + return lastComparison; + } + if (isSetInMemory()) { + lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.inMemory, other.inMemory); + if (lastComparison != 0) { + return lastComparison; + } + } + return 0; + } + + public _Fields fieldForId(int fieldId) { + return _Fields.findByThriftId(fieldId); + } + + public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException { + schemes.get(iprot.getScheme()).getScheme().read(iprot, this); + } + + public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException { + schemes.get(oprot.getScheme()).getScheme().write(oprot, this); + } + + @Override + public String toString() { + StringBuilder sb = new StringBuilder("TColumnFamilyDescriptor("); + boolean first = true; + + sb.append("name:"); + if (this.name == null) { + sb.append("null"); + } else { + org.apache.thrift.TBaseHelper.toString(this.name, sb); + } + first = false; + if (isSetAttributes()) { + if (!first) sb.append(", "); + sb.append("attributes:"); + if (this.attributes == null) { + sb.append("null"); + } else { + sb.append(this.attributes); + } + first = false; + } + if (isSetConfiguration()) { + if (!first) sb.append(", "); + sb.append("configuration:"); + if (this.configuration == null) { + sb.append("null"); + } else { + sb.append(this.configuration); + } + first = false; + } + if (isSetBlockSize()) { + if (!first) sb.append(", "); + sb.append("blockSize:"); + sb.append(this.blockSize); + first = false; + } + if (isSetBloomnFilterType()) { + if (!first) sb.append(", "); + sb.append("bloomnFilterType:"); + if (this.bloomnFilterType == null) { + sb.append("null"); + } else { + sb.append(this.bloomnFilterType); + } + first = false; + } + if (isSetCompressionType()) { + if (!first) sb.append(", "); + sb.append("compressionType:"); + if (this.compressionType == null) { + sb.append("null"); + } else { + sb.append(this.compressionType); + } + first = false; + } + if (isSetDfsReplication()) { + if (!first) sb.append(", "); + sb.append("dfsReplication:"); + sb.append(this.dfsReplication); + first = false; + } + if (isSetDataBlockEncoding()) { + if (!first) sb.append(", "); + sb.append("dataBlockEncoding:"); + if (this.dataBlockEncoding == null) { + sb.append("null"); + } else { + sb.append(this.dataBlockEncoding); + } + first = false; + } + if (isSetKeepDeletedCells()) { + if (!first) sb.append(", "); + sb.append("keepDeletedCells:"); + if (this.keepDeletedCells == null) { + sb.append("null"); + } else { + sb.append(this.keepDeletedCells); + } + first = false; + } + if (isSetMaxVersions()) { + if (!first) sb.append(", "); + sb.append("maxVersions:"); + sb.append(this.maxVersions); + first = false; + } + if (isSetMinVersions()) { + if (!first) sb.append(", "); + sb.append("minVersions:"); + sb.append(this.minVersions); + first = false; + } + if (isSetScope()) { + if (!first) sb.append(", "); + sb.append("scope:"); + sb.append(this.scope); + first = false; + } + if (isSetTimeToLive()) { + if (!first) sb.append(", "); + sb.append("timeToLive:"); + sb.append(this.timeToLive); + first = false; + } + if (isSetBlockCacheEnabled()) { + if (!first) sb.append(", "); + sb.append("blockCacheEnabled:"); + sb.append(this.blockCacheEnabled); + first = false; + } + if (isSetCacheBloomsOnWrite()) { + if (!first) sb.append(", "); + sb.append("cacheBloomsOnWrite:"); + sb.append(this.cacheBloomsOnWrite); + first = false; + } + if (isSetCacheDataOnWrite()) { + if (!first) sb.append(", "); + sb.append("cacheDataOnWrite:"); + sb.append(this.cacheDataOnWrite); + first = false; + } + if (isSetCacheIndexesOnWrite()) { + if (!first) sb.append(", "); + sb.append("cacheIndexesOnWrite:"); + sb.append(this.cacheIndexesOnWrite); + first = false; + } + if (isSetCompressTags()) { + if (!first) sb.append(", "); + sb.append("compressTags:"); + sb.append(this.compressTags); + first = false; + } + if (isSetEvictBlocksOnClose()) { + if (!first) sb.append(", "); + sb.append("evictBlocksOnClose:"); + sb.append(this.evictBlocksOnClose); + first = false; + } + if (isSetInMemory()) { + if (!first) sb.append(", "); + sb.append("inMemory:"); + sb.append(this.inMemory); + first = false; + } + sb.append(")"); + return sb.toString(); + } + + public void validate() throws org.apache.thrift.TException { + // check for required fields + if (name == null) { + throw new org.apache.thrift.protocol.TProtocolException("Required field 'name' was not present! Struct: " + toString()); + } + // check for sub-struct validity + } + + private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException { + try { + write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out))); + } catch (org.apache.thrift.TException te) { + throw new java.io.IOException(te); + } + } + + private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, ClassNotFoundException { + try { + // it doesn't seem like you should have to do this, but java serialization is wacky, and doesn't call the default constructor. + __isset_bitfield = 0; + read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in))); + } catch (org.apache.thrift.TException te) { + throw new java.io.IOException(te); + } + } + + private static class TColumnFamilyDescriptorStandardSchemeFactory implements SchemeFactory { + public TColumnFamilyDescriptorStandardScheme getScheme() { + return new TColumnFamilyDescriptorStandardScheme(); + } + } + + private static class TColumnFamilyDescriptorStandardScheme extends StandardScheme<TColumnFamilyDescriptor> { + + public void read(org.apache.thrift.protocol.TProtocol iprot, TColumnFamilyDescriptor struct) throws org.apache.thrift.TException { + org.apache.thrift.protocol.TField schemeField; + iprot.readStructBegin(); + while (true) + { + schemeField = iprot.readFieldBegin(); + if (schemeField.type == org.apache.thrift.protocol.TType.STOP) { + break; + } + switch (schemeField.id) { + case 1: // NAME + if (schemeField.type == org.apache.thrift.protocol.TType.STRING) { + struct.name = iprot.readBinary(); + struct.setNameIsSet(true); + } else { + org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); + } + break; + case 2: // ATTRIBUTES + if (schemeField.type == org.apache.thrift.protocol.TType.MAP) { + { + org.apache.thrift.protocol.TMap _map142 = iprot.readMapBegin(); + struct.attributes = new HashMap<ByteBuffer,ByteBuffer>(2*_map142.size); + ByteBuffer _key143; + ByteBuffer _val144; + for (int _i145 = 0; _i145 < _map142.size; ++_i145) + { + _key143 = iprot.readBinary(); + _val144 = iprot.readBinary(); + struct.attributes.put(_key143, _val144); + } + iprot.readMapEnd(); + } + struct.setAttributesIsSet(true); + } else { + org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); + } + break; + case 3: // CONFIGURATION + if (schemeField.type == org.apache.thrift.protocol.TType.MAP) { + { + org.apache.thrift.protocol.TMap _map146 = iprot.readMapBegin(); + struct.configuration = new HashMap<String,String>(2*_map146.size); + String _key147; + String _val148; + for (int _i149 = 0; _i149 < _map146.size; ++_i149) + { + _key147 = iprot.readString(); + _val148 = iprot.readString(); + struct.configuration.put(_key147, _val148); + } + iprot.readMapEnd(); + } + struct.setConfigurationIsSet(true); + } else { + org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); + } + break; + case 4: // BLOCK_SIZE + if (schemeField.type == org.apache.thrift.protocol.TType.I32) { + struct.blockSize = iprot.readI32(); + struct.setBlockSizeIsSet(true); + } else { + org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); + } + break; + case 5: // BLOOMN_FILTER_TYPE + if (schemeField.type == org.apache.thrift.protocol.TType.I32) { + struct.bloomnFilterType = org.apache.hadoop.hbase.thrift2.generated.TBloomFilterType.findByValue(iprot.readI32()); + struct.setBloomnFilterTypeIsSet(true); + } else { + org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); + } + break; + case 6: // COMPRESSION_TYPE + if (schemeField.type == org.apache.thrift.protocol.TType.I32) { + struct.compressionType = org.apache.hadoop.hbase.thrift2.generated.TCompressionAlgorithm.findByValue(iprot.readI32()); + struct.setCompressionTypeIsSet(true); + } else { + org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); + } + break; + case 7: // DFS_REPLICATION + if (schemeField.type == org.apache.thrift.protocol.TType.I16) { + struct.dfsReplication = iprot.readI16(); + struct.setDfsReplicationIsSet(true); + } else { + org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); + } + break; + case 8: // DATA_BLOCK_ENCODING + if (schemeField.type == org.apache.thrift.protocol.TType.I32) { + struct.dataBlockEncoding = org.apache.hadoop.hbase.thrift2.generated.TDataBlockEncoding.findByValue(iprot.readI32()); + struct.setDataBlockEncodingIsSet(true); + } else { + org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); + } + break; + case 9: // KEEP_DELETED_CELLS + if (schemeField.type == org.apache.thrift.protocol.TType.I32) { + struct.keepDeletedCells = org.apache.hadoop.hbase.thrift2.generated.TKeepDeletedCells.findByValue(iprot.readI32()); + struct.setKeepDeletedCellsIsSet(true); + } else { + org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); + } + break; + case 10: // MAX_VERSIONS + if (schemeField.type == org.apache.thrift.protocol.TType.I32) { + struct.maxVersions = iprot.readI32(); + struct.setMaxVersionsIsSet(true); + } else { + org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); + } + break; + case 11: // MIN_VERSIONS + if (schemeField.type == org.apache.thrift.protocol.TType.I32) { + struct.minVersions = iprot.readI32(); + struct.setMinVersionsIsSet(true); + } else { + org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); + } + break; + case 12: // SCOPE + if (schemeField.type == org.apache.thrift.protocol.TType.I32) { + struct.scope = iprot.readI32(); + struct.setScopeIsSet(true); + } else { + org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); + } + break; + case 13: // TIME_TO_LIVE + if (schemeField.type == org.apache.thrift.protocol.TType.I32) { + struct.timeToLive = iprot.readI32(); + struct.setTimeToLiveIsSet(true); + } else { + org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); + } + break; + case 14: // BLOCK_CACHE_ENABLED + if (schemeField.type == org.apache.thrift.protocol.TType.BOOL) { + struct.blockCacheEnabled = iprot.readBool(); + struct.setBlockCacheEnabledIsSet(true); + } else { + org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); + } + break; + case 15: // CACHE_BLOOMS_ON_WRITE + if (schemeField.type == org.apache.thrift.protocol.TType.BOOL) { + struct.cacheBloomsOnWrite = iprot.readBool(); + struct.setCacheBloomsOnWriteIsSet(true); + } else { + org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); + } + break; + case 16: // CACHE_DATA_ON_WRITE + if (schemeField.type == org.apache.thrift.protocol.TType.BOOL) { + struct.cacheDataOnWrite = iprot.readBool(); + struct.setCacheDataOnWriteIsSet(true); + } else { + org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); + } + break; + case 17: // CACHE_INDEXES_ON_WRITE + if (schemeField.type == org.apache.thrift.protocol.TType.BOOL) { + struct.cacheIndexesOnWrite = iprot.readBool(); + struct.setCacheIndexesOnWriteIsSet(true); + } else { + org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); + } + break; + case 18: // COMPRESS_TAGS + if (schemeField.type == org.apache.thrift.protocol.TType.BOOL) { + struct.compressTags = iprot.readBool(); + struct.setCompressTagsIsSet(true); + } else { + org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); + } + break; + case 19: // EVICT_BLOCKS_ON_CLOSE + if (schemeField.type == org.apache.thrift.protocol.TType.BOOL) { + struct.evictBlocksOnClose = iprot.readBool(); + struct.setEvictBlocksOnCloseIsSet(true); + } else { + org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); + } + break; + case 20: // IN_MEMORY + if (schemeField.type == org.apache.thrift.protocol.TType.BOOL) { + struct.inMemory = iprot.readBool(); + struct.setInMemoryIsSet(true); + } else { + org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); + } + break; + default: + org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); + } + iprot.readFieldEnd(); + } + iprot.readStructEnd(); + + // check for required fields of primitive type, which can't be checked in the validate method + struct.validate(); + } + + public void write(org.apache.thrift.protocol.TProtocol oprot, TColumnFamilyDescriptor struct) throws org.apache.thrift.TException { + struct.validate(); + + oprot.writeStructBegin(STRUCT_DESC); + if (struct.name != null) { + oprot.writeFieldBegin(NAME_FIELD_DESC); + oprot.writeBinary(struct.name); + oprot.writeFieldEnd(); + } + if (struct.attributes != null) { + if (struct.isSetAttributes()) { + oprot.writeFieldBegin(ATTRIBUTES_FIELD_DESC); + { + oprot.writeMapBegin(new org.apache.thrift.protocol.TMap(org.apache.thrift.protocol.TType.STRING, org.apache.thrift.protocol.TType.STRING, struct.attributes.size())); + for (Map.Entry<ByteBuffer, ByteBuffer> _iter150 : struct.attributes.entrySet()) + { + oprot.writeBinary(_iter150.getKey()); + oprot.writeBinary(_iter150.getValue()); + } + oprot.writeMapEnd(); + } + oprot.writeFieldEnd(); + } + } + if (struct.configuration != null) { + if (struct.isSetConfiguration()) { + oprot.writeFieldBegin(CONFIGURATION_FIELD_DESC); + { + oprot.writeMapBegin(new org.apache.thrift.protocol.TMap(org.apache.thrift.protocol.TType.STRING, org.apache.thrift.protocol.TType.STRING, struct.configuration.size())); + for (Map.Entry<String, String> _iter151 : struct.configuration.entrySet()) + { + oprot.writeString(_iter151.getKey()); + oprot.writeString(_iter151.getValue()); + } + oprot.writeMapEnd(); + } + oprot.writeFieldEnd(); + } + } + if (struct.isSetBlockSize()) { + oprot.writeFieldBegin(BLOCK_SIZE_FIELD_DESC); + oprot.writeI32(struct.blockSize); + oprot.writeFieldEnd(); + } + if (struct.bloomnFilterType != null) { + if (struct.isSetBloomnFilterType()) { + oprot.writeFieldBegin(BLOOMN_FILTER_TYPE_FIELD_DESC); + oprot.writeI32(struct.bloomnFilterType.getValue()); + oprot.writeFieldEnd(); + } + } + if (struct.compressionType != null) { + if (struct.isSetCompressionType()) { + oprot.writeFieldBegin(COMPRESSION_TYPE_FIELD_DESC); + oprot.writeI32(struct.compressionType.getValue()); + oprot.writeFieldEnd(); + } + } + if (struct.isSetDfsReplication()) { + oprot.writeFieldBegin(DFS_REPLICATION_FIELD_DESC); + oprot.writeI16(struct.dfsReplication); + oprot.writeFieldEnd(); + } + if (struct.dataBlockEncoding != null) { + if (struct.isSetDataBlockEncoding()) { + oprot.writeFieldBegin(DATA_BLOCK_ENCODING_FIELD_DESC); + oprot.writeI32(struct.dataBlockEncoding.getValue()); + oprot.writeFieldEnd(); + } + } + if (struct.keepDeletedCells != null) { + if (struct.isSetKeepDeletedCells()) { + oprot.writeFieldBegin(KEEP_DELETED_CELLS_FIELD_DESC); + oprot.writeI32(struct.keepDeletedCells.getValue()); + oprot.writeFieldEnd(); + } + } + if (struct.isSetMaxVersions()) { + oprot.writeFieldBegin(MAX_VERSIONS_FIELD_DESC); + oprot.writeI32(struct.maxVersions); + oprot.writeFieldEnd(); + } + if (struct.isSetMinVersions()) { + oprot.writeFieldBegin(MIN_VERSIONS_FIELD_DESC); + oprot.writeI32(struct.minVersions); + oprot.writeFieldEnd(); + } + if (struct.isSetScope()) { + oprot.writeFieldBegin(SCOPE_FIELD_DESC); + oprot.writeI32(struct.scope); + oprot.writeFieldEnd(); + } + if (struct.isSetTimeToLive()) { + oprot.writeFieldBegin(TIME_TO_LIVE_FIELD_DESC); + oprot.writeI32(struct.timeToLive); + oprot.writeFieldEnd(); + } + if (struct.isSetBlockCacheEnabled()) { + oprot.writeFieldBegin(BLOCK_CACHE_ENABLED_FIELD_DESC); + oprot.writeBool(struct.blockCacheEnabled); + oprot.writeFieldEnd(); + } + if (struct.isSetCacheBloomsOnWrite()) { + oprot.writeFieldBegin(CACHE_BLOOMS_ON_WRITE_FIELD_DESC); + oprot.writeBool(struct.cacheBloomsOnWrite); + oprot.writeFieldEnd(); + } + if (struct.isSetCacheDataOnWrite()) { + oprot.writeFieldBegin(CACHE_DATA_ON_WRITE_FIELD_DESC); + oprot.writeBool(struct.cacheDataOnWrite); + oprot.writeFieldEnd(); + } + if (struct.isSetCacheIndexesOnWrite()) { + oprot.writeFieldBegin(CACHE_INDEXES_ON_WRITE_FIELD_DESC); + oprot.writeBool(struct.cacheIndexesOnWrite); + oprot.writeFieldEnd(); + } + if (struct.isSetCompressTags()) { + oprot.writeFieldBegin(COMPRESS_TAGS_FIELD_DESC); + oprot.writeBool(struct.compressTags); + oprot.writeFieldEnd(); + } + if (struct.isSetEvictBlocksOnClose()) { + oprot.writeFieldBegin(EVICT_BLOCKS_ON_CLOSE_FIELD_DESC); + oprot.writeBool(struct.evictBlocksOnClose); + oprot.writeFieldEnd(); + } + if (struct.isSetInMemory()) { + oprot.writeFieldBegin(IN_MEMORY_FIELD_DESC); + oprot.writeBool(struct.inMemory); + oprot.writeFieldEnd(); + } + oprot.writeFieldStop(); + oprot.writeStructEnd(); + } + + } + + private static class TColumnFamilyDescriptorTupleSchemeFactory implements SchemeFactory { + public TColumnFamilyDescriptorTupleScheme getScheme() { + return new TColumnFamilyDescriptorTupleScheme(); + } + } + + private static class TColumnFamilyDescriptorTupleScheme extends TupleScheme<TColumnFamilyDescriptor> { + + @Override + public void write(org.apache.thrift.protocol.TProtocol prot, TColumnFamilyDescriptor struct) throws org.apache.thrift.TException { + TTupleProtocol oprot = (TTupleProtocol) prot; + oprot.writeBinary(struct.name); + BitSet optionals = new BitSet(); + if (struct.isSetAttributes()) { + optionals.set(0); + } + if (struct.isSetConfiguration()) { + optionals.set(1); + } + if (struct.isSetBlockSize()) { + optionals.set(2); + } + if (struct.isSetBloomnFilterType()) { + optionals.set(3); + } + if (struct.isSetCompressionType()) { + optionals.set(4); + } + if (struct.isSetDfsReplication()) { + optionals.set(5); + } + if (struct.isSetDataBlockEncoding()) { + optionals.set(6); + } + if (struct.isSetKeepDeletedCells()) { + optionals.set(7); + } + if (struct.isSetMaxVersions()) { + optionals.set(8); + } + if (struct.isSetMinVersions()) { + optionals.set(9); + } + if (struct.isSetScope()) { + optionals.set(10); + } + if (struct.isSetTimeToLive()) { + optionals.set(11); + } + if (struct.isSetBlockCacheEnabled()) { + optionals.set(12); + } + if (struct.isSetCacheBloomsOnWrite()) { + optionals.set(13); + } + if (struct.isSetCacheDataOnWrite()) { + optionals.set(14); + } + if (struct.isSetCacheIndexesOnWrite()) { + optionals.set(15); + } + if (struct.isSetCompressTags()) { + optionals.set(16); + } + if (struct.isSetEvictBlocksOnClose()) { + optionals.set(17); + } + if (struct.isSetInMemory()) { + optionals.set(18); + } + oprot.writeBitSet(optionals, 19); + if (struct.isSetAttributes()) { + { + oprot.writeI32(struct.attributes.size()); + for (Map.Entry<ByteBuffer, ByteBuffer> _iter152 : struct.attributes.entrySet()) + { + oprot.writeBinary(_iter152.getKey()); + oprot.writeBinary(_iter152.getValue()); + } + } + } + if (struct.isSetConfiguration()) { + { + oprot.writeI32(struct.configuration.size()); + for (Map.Entry<String, String> _iter153 : struct.configuration.entrySet()) + { + oprot.writeString(_iter153.getKey()); + oprot.writeString(_iter153.getValue()); + } + } + } + if (struct.isSetBlockSize()) { + oprot.writeI32(struct.blockSize); + } + if (struct.isSetBloomnFilterType()) { + oprot.writeI32(struct.bloomnFilterType.getValue()); + } + if (struct.isSetCompressionType()) { + oprot.writeI32(struct.compressionType.getValue()); + } + if (struct.isSetDfsReplication()) { + oprot.writeI16(struct.dfsReplication); + } + if (struct.isSetDataBlockEncoding()) { + oprot.writeI32(struct.dataBlockEncoding.getValue()); + } + if (struct.isSetKeepDeletedCells()) { + oprot.writeI32(struct.keepDeletedCells.getValue()); + } + if (struct.isSetMaxVersions()) { + oprot.writeI32(struct.maxVersions); + } + if (struct.isSetMinVersions()) { + oprot.writeI32(struct.minVersions); + } + if (struct.isSetScope()) { + oprot.writeI3
<TRUNCATED>