You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@hbase.apache.org by al...@apache.org on 2018/12/29 10:07:19 UTC
[5/9] hbase git commit: HBASE-21650 Add DDL operation and some other
miscellaneous to thrift2
http://git-wip-us.apache.org/repos/asf/hbase/blob/4e8a8467/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>