ColumnDescriptor.java

/**
 * Licensed to the Apache Software Foundation (ASF) under one
 * or more contributor license agreements.  See the NOTICE file
 * distributed with this work for additional information
 * regarding copyright ownership.  The ASF licenses this file
 * to you under the Apache License, Version 2.0 (the
 * "License"); you may not use this file except in compliance
 * with the License.  You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
package org.apache.hadoop.hbase.thrift.generated;

import org.apache.commons.lang.builder.HashCodeBuilder;
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.util.Arrays;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import org.apache.thrift.*;
import org.apache.thrift.meta_data.*;
import org.apache.thrift.protocol.*;

/**
 * An HColumnDescriptor contains information about a column family
 * such as the number of versions, compression settings, etc. It is
 * used as input when creating a table or adding a column.
 */
public class ColumnDescriptor implements TBase<ColumnDescriptor._Fields>, java.io.Serializable, Cloneable, Comparable<ColumnDescriptor> {
  private static final TStruct STRUCT_DESC = new TStruct("ColumnDescriptor");

  private static final TField NAME_FIELD_DESC = new TField("name", TType.STRING, (short)1);
  private static final TField MAX_VERSIONS_FIELD_DESC = new TField("maxVersions", TType.I32, (short)2);
  private static final TField COMPRESSION_FIELD_DESC = new TField("compression", TType.STRING, (short)3);
  private static final TField IN_MEMORY_FIELD_DESC = new TField("inMemory", TType.BOOL, (short)4);
  private static final TField BLOOM_FILTER_TYPE_FIELD_DESC = new TField("bloomFilterType", TType.STRING, (short)5);
  private static final TField BLOOM_FILTER_VECTOR_SIZE_FIELD_DESC = new TField("bloomFilterVectorSize", TType.I32, (short)6);
  private static final TField BLOOM_FILTER_NB_HASHES_FIELD_DESC = new TField("bloomFilterNbHashes", TType.I32, (short)7);
  private static final TField BLOCK_CACHE_ENABLED_FIELD_DESC = new TField("blockCacheEnabled", TType.BOOL, (short)8);
  private static final TField TIME_TO_LIVE_FIELD_DESC = new TField("timeToLive", TType.I32, (short)9);

  public byte[] name;
  public int maxVersions;
  public String compression;
  public boolean inMemory;
  public String bloomFilterType;
  public int bloomFilterVectorSize;
  public int bloomFilterNbHashes;
  public boolean blockCacheEnabled;
  public int timeToLive;

  /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
  public enum _Fields implements TFieldIdEnum {
    NAME((short)1, "name"),
    MAX_VERSIONS((short)2, "maxVersions"),
    COMPRESSION((short)3, "compression"),
    IN_MEMORY((short)4, "inMemory"),
    BLOOM_FILTER_TYPE((short)5, "bloomFilterType"),
    BLOOM_FILTER_VECTOR_SIZE((short)6, "bloomFilterVectorSize"),
    BLOOM_FILTER_NB_HASHES((short)7, "bloomFilterNbHashes"),
    BLOCK_CACHE_ENABLED((short)8, "blockCacheEnabled"),
    TIME_TO_LIVE((short)9, "timeToLive");

    private static final Map<Integer, _Fields> byId = new HashMap<Integer, _Fields>();
    private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();

    static {
      for (_Fields field : EnumSet.allOf(_Fields.class)) {
        byId.put((int)field._thriftId, field);
        byName.put(field.getFieldName(), field);
      }
    }

    /**
     * Find the _Fields constant that matches fieldId, or null if its not found.
     */
    public static _Fields findByThriftId(int fieldId) {
      return byId.get(fieldId);
    }

    /**
     * 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 __MAXVERSIONS_ISSET_ID = 0;
  private static final int __INMEMORY_ISSET_ID = 1;
  private static final int __BLOOMFILTERVECTORSIZE_ISSET_ID = 2;
  private static final int __BLOOMFILTERNBHASHES_ISSET_ID = 3;
  private static final int __BLOCKCACHEENABLED_ISSET_ID = 4;
  private static final int __TIMETOLIVE_ISSET_ID = 5;
  private BitSet __isset_bit_vector = new BitSet(6);

  public static final Map<_Fields, FieldMetaData> metaDataMap = Collections.unmodifiableMap(new EnumMap<_Fields, FieldMetaData>(_Fields.class) {{
    put(_Fields.NAME, new FieldMetaData("name", TFieldRequirementType.DEFAULT,
        new FieldValueMetaData(TType.STRING)));
    put(_Fields.MAX_VERSIONS, new FieldMetaData("maxVersions", TFieldRequirementType.DEFAULT,
        new FieldValueMetaData(TType.I32)));
    put(_Fields.COMPRESSION, new FieldMetaData("compression", TFieldRequirementType.DEFAULT,
        new FieldValueMetaData(TType.STRING)));
    put(_Fields.IN_MEMORY, new FieldMetaData("inMemory", TFieldRequirementType.DEFAULT,
        new FieldValueMetaData(TType.BOOL)));
    put(_Fields.BLOOM_FILTER_TYPE, new FieldMetaData("bloomFilterType", TFieldRequirementType.DEFAULT,
        new FieldValueMetaData(TType.STRING)));
    put(_Fields.BLOOM_FILTER_VECTOR_SIZE, new FieldMetaData("bloomFilterVectorSize", TFieldRequirementType.DEFAULT,
        new FieldValueMetaData(TType.I32)));
    put(_Fields.BLOOM_FILTER_NB_HASHES, new FieldMetaData("bloomFilterNbHashes", TFieldRequirementType.DEFAULT,
        new FieldValueMetaData(TType.I32)));
    put(_Fields.BLOCK_CACHE_ENABLED, new FieldMetaData("blockCacheEnabled", TFieldRequirementType.DEFAULT,
        new FieldValueMetaData(TType.BOOL)));
    put(_Fields.TIME_TO_LIVE, new FieldMetaData("timeToLive", TFieldRequirementType.DEFAULT,
        new FieldValueMetaData(TType.I32)));
  }});

  static {
    FieldMetaData.addStructMetaDataMap(ColumnDescriptor.class, metaDataMap);
  }

  public ColumnDescriptor() {
    this.maxVersions = 3;

    this.compression = "NONE";

    this.inMemory = false;

    this.bloomFilterType = "NONE";

    this.bloomFilterVectorSize = 0;

    this.bloomFilterNbHashes = 0;

    this.blockCacheEnabled = false;

    this.timeToLive = -1;

  }

  public ColumnDescriptor(
    byte[] name,
    int maxVersions,
    String compression,
    boolean inMemory,
    String bloomFilterType,
    int bloomFilterVectorSize,
    int bloomFilterNbHashes,
    boolean blockCacheEnabled,
    int timeToLive)
  {
    this();
    this.name = name;
    this.maxVersions = maxVersions;
    setMaxVersionsIsSet(true);
    this.compression = compression;
    this.inMemory = inMemory;
    setInMemoryIsSet(true);
    this.bloomFilterType = bloomFilterType;
    this.bloomFilterVectorSize = bloomFilterVectorSize;
    setBloomFilterVectorSizeIsSet(true);
    this.bloomFilterNbHashes = bloomFilterNbHashes;
    setBloomFilterNbHashesIsSet(true);
    this.blockCacheEnabled = blockCacheEnabled;
    setBlockCacheEnabledIsSet(true);
    this.timeToLive = timeToLive;
    setTimeToLiveIsSet(true);
  }

  /**
   * Performs a deep copy on <i>other</i>.
   */
  public ColumnDescriptor(ColumnDescriptor other) {
    __isset_bit_vector.clear();
    __isset_bit_vector.or(other.__isset_bit_vector);
    if (other.isSetName()) {
      this.name = other.name;
    }
    this.maxVersions = other.maxVersions;
    if (other.isSetCompression()) {
      this.compression = other.compression;
    }
    this.inMemory = other.inMemory;
    if (other.isSetBloomFilterType()) {
      this.bloomFilterType = other.bloomFilterType;
    }
    this.bloomFilterVectorSize = other.bloomFilterVectorSize;
    this.bloomFilterNbHashes = other.bloomFilterNbHashes;
    this.blockCacheEnabled = other.blockCacheEnabled;
    this.timeToLive = other.timeToLive;
  }

  public ColumnDescriptor deepCopy() {
    return new ColumnDescriptor(this);
  }

  @Deprecated
  public ColumnDescriptor clone() {
    return new ColumnDescriptor(this);
  }

  public byte[] getName() {
    return this.name;
  }

  public ColumnDescriptor setName(byte[] name) {
    this.name = name;
    return this;
  }

  public void unsetName() {
    this.name = null;
  }

  /** Returns true if field name is set (has been asigned a value) and false otherwise */
  public boolean isSetName() {
    return this.name != null;
  }

  public void setNameIsSet(boolean value) {
    if (!value) {
      this.name = null;
    }
  }

  public int getMaxVersions() {
    return this.maxVersions;
  }

  public ColumnDescriptor setMaxVersions(int maxVersions) {
    this.maxVersions = maxVersions;
    setMaxVersionsIsSet(true);
    return this;
  }

  public void unsetMaxVersions() {
    __isset_bit_vector.clear(__MAXVERSIONS_ISSET_ID);
  }

  /** Returns true if field maxVersions is set (has been asigned a value) and false otherwise */
  public boolean isSetMaxVersions() {
    return __isset_bit_vector.get(__MAXVERSIONS_ISSET_ID);
  }

  public void setMaxVersionsIsSet(boolean value) {
    __isset_bit_vector.set(__MAXVERSIONS_ISSET_ID, value);
  }

  public String getCompression() {
    return this.compression;
  }

  public ColumnDescriptor setCompression(String compression) {
    this.compression = compression;
    return this;
  }

  public void unsetCompression() {
    this.compression = null;
  }

  /** Returns true if field compression is set (has been asigned a value) and false otherwise */
  public boolean isSetCompression() {
    return this.compression != null;
  }

  public void setCompressionIsSet(boolean value) {
    if (!value) {
      this.compression = null;
    }
  }

  public boolean isInMemory() {
    return this.inMemory;
  }

  public ColumnDescriptor setInMemory(boolean inMemory) {
    this.inMemory = inMemory;
    setInMemoryIsSet(true);
    return this;
  }

  public void unsetInMemory() {
    __isset_bit_vector.clear(__INMEMORY_ISSET_ID);
  }

  /** Returns true if field inMemory is set (has been asigned a value) and false otherwise */
  public boolean isSetInMemory() {
    return __isset_bit_vector.get(__INMEMORY_ISSET_ID);
  }

  public void setInMemoryIsSet(boolean value) {
    __isset_bit_vector.set(__INMEMORY_ISSET_ID, value);
  }

  public String getBloomFilterType() {
    return this.bloomFilterType;
  }

  public ColumnDescriptor setBloomFilterType(String bloomFilterType) {
    this.bloomFilterType = bloomFilterType;
    return this;
  }

  public void unsetBloomFilterType() {
    this.bloomFilterType = null;
  }

  /** Returns true if field bloomFilterType is set (has been asigned a value) and false otherwise */
  public boolean isSetBloomFilterType() {
    return this.bloomFilterType != null;
  }

  public void setBloomFilterTypeIsSet(boolean value) {
    if (!value) {
      this.bloomFilterType = null;
    }
  }

  public int getBloomFilterVectorSize() {
    return this.bloomFilterVectorSize;
  }

  public ColumnDescriptor setBloomFilterVectorSize(int bloomFilterVectorSize) {
    this.bloomFilterVectorSize = bloomFilterVectorSize;
    setBloomFilterVectorSizeIsSet(true);
    return this;
  }

  public void unsetBloomFilterVectorSize() {
    __isset_bit_vector.clear(__BLOOMFILTERVECTORSIZE_ISSET_ID);
  }

  /** Returns true if field bloomFilterVectorSize is set (has been asigned a value) and false otherwise */
  public boolean isSetBloomFilterVectorSize() {
    return __isset_bit_vector.get(__BLOOMFILTERVECTORSIZE_ISSET_ID);
  }

  public void setBloomFilterVectorSizeIsSet(boolean value) {
    __isset_bit_vector.set(__BLOOMFILTERVECTORSIZE_ISSET_ID, value);
  }

  public int getBloomFilterNbHashes() {
    return this.bloomFilterNbHashes;
  }

  public ColumnDescriptor setBloomFilterNbHashes(int bloomFilterNbHashes) {
    this.bloomFilterNbHashes = bloomFilterNbHashes;
    setBloomFilterNbHashesIsSet(true);
    return this;
  }

  public void unsetBloomFilterNbHashes() {
    __isset_bit_vector.clear(__BLOOMFILTERNBHASHES_ISSET_ID);
  }

  /** Returns true if field bloomFilterNbHashes is set (has been asigned a value) and false otherwise */
  public boolean isSetBloomFilterNbHashes() {
    return __isset_bit_vector.get(__BLOOMFILTERNBHASHES_ISSET_ID);
  }

  public void setBloomFilterNbHashesIsSet(boolean value) {
    __isset_bit_vector.set(__BLOOMFILTERNBHASHES_ISSET_ID, value);
  }

  public boolean isBlockCacheEnabled() {
    return this.blockCacheEnabled;
  }

  public ColumnDescriptor setBlockCacheEnabled(boolean blockCacheEnabled) {
    this.blockCacheEnabled = blockCacheEnabled;
    setBlockCacheEnabledIsSet(true);
    return this;
  }

  public void unsetBlockCacheEnabled() {
    __isset_bit_vector.clear(__BLOCKCACHEENABLED_ISSET_ID);
  }

  /** Returns true if field blockCacheEnabled is set (has been asigned a value) and false otherwise */
  public boolean isSetBlockCacheEnabled() {
    return __isset_bit_vector.get(__BLOCKCACHEENABLED_ISSET_ID);
  }

  public void setBlockCacheEnabledIsSet(boolean value) {
    __isset_bit_vector.set(__BLOCKCACHEENABLED_ISSET_ID, value);
  }

  public int getTimeToLive() {
    return this.timeToLive;
  }

  public ColumnDescriptor setTimeToLive(int timeToLive) {
    this.timeToLive = timeToLive;
    setTimeToLiveIsSet(true);
    return this;
  }

  public void unsetTimeToLive() {
    __isset_bit_vector.clear(__TIMETOLIVE_ISSET_ID);
  }

  /** Returns true if field timeToLive is set (has been asigned a value) and false otherwise */
  public boolean isSetTimeToLive() {
    return __isset_bit_vector.get(__TIMETOLIVE_ISSET_ID);
  }

  public void setTimeToLiveIsSet(boolean value) {
    __isset_bit_vector.set(__TIMETOLIVE_ISSET_ID, value);
  }

  public void setFieldValue(_Fields field, Object value) {
    switch (field) {
    case NAME:
      if (value == null) {
        unsetName();
      } else {
        setName((byte[])value);
      }
      break;

    case MAX_VERSIONS:
      if (value == null) {
        unsetMaxVersions();
      } else {
        setMaxVersions((Integer)value);
      }
      break;

    case COMPRESSION:
      if (value == null) {
        unsetCompression();
      } else {
        setCompression((String)value);
      }
      break;

    case IN_MEMORY:
      if (value == null) {
        unsetInMemory();
      } else {
        setInMemory((Boolean)value);
      }
      break;

    case BLOOM_FILTER_TYPE:
      if (value == null) {
        unsetBloomFilterType();
      } else {
        setBloomFilterType((String)value);
      }
      break;

    case BLOOM_FILTER_VECTOR_SIZE:
      if (value == null) {
        unsetBloomFilterVectorSize();
      } else {
        setBloomFilterVectorSize((Integer)value);
      }
      break;

    case BLOOM_FILTER_NB_HASHES:
      if (value == null) {
        unsetBloomFilterNbHashes();
      } else {
        setBloomFilterNbHashes((Integer)value);
      }
      break;

    case BLOCK_CACHE_ENABLED:
      if (value == null) {
        unsetBlockCacheEnabled();
      } else {
        setBlockCacheEnabled((Boolean)value);
      }
      break;

    case TIME_TO_LIVE:
      if (value == null) {
        unsetTimeToLive();
      } else {
        setTimeToLive((Integer)value);
      }
      break;

    }
  }

  public void setFieldValue(int fieldID, Object value) {
    setFieldValue(_Fields.findByThriftIdOrThrow(fieldID), value);
  }

  public Object getFieldValue(_Fields field) {
    switch (field) {
    case NAME:
      return getName();

    case MAX_VERSIONS:
      return new Integer(getMaxVersions());

    case COMPRESSION:
      return getCompression();

    case IN_MEMORY:
      return new Boolean(isInMemory());

    case BLOOM_FILTER_TYPE:
      return getBloomFilterType();

    case BLOOM_FILTER_VECTOR_SIZE:
      return new Integer(getBloomFilterVectorSize());

    case BLOOM_FILTER_NB_HASHES:
      return new Integer(getBloomFilterNbHashes());

    case BLOCK_CACHE_ENABLED:
      return new Boolean(isBlockCacheEnabled());

    case TIME_TO_LIVE:
      return new Integer(getTimeToLive());

    }
    throw new IllegalStateException();
  }

  public Object getFieldValue(int fieldId) {
    return getFieldValue(_Fields.findByThriftIdOrThrow(fieldId));
  }

  /** Returns true if field corresponding to fieldID is set (has been asigned a value) and false otherwise */
  public boolean isSet(_Fields field) {
    switch (field) {
    case NAME:
      return isSetName();
    case MAX_VERSIONS:
      return isSetMaxVersions();
    case COMPRESSION:
      return isSetCompression();
    case IN_MEMORY:
      return isSetInMemory();
    case BLOOM_FILTER_TYPE:
      return isSetBloomFilterType();
    case BLOOM_FILTER_VECTOR_SIZE:
      return isSetBloomFilterVectorSize();
    case BLOOM_FILTER_NB_HASHES:
      return isSetBloomFilterNbHashes();
    case BLOCK_CACHE_ENABLED:
      return isSetBlockCacheEnabled();
    case TIME_TO_LIVE:
      return isSetTimeToLive();
    }
    throw new IllegalStateException();
  }

  public boolean isSet(int fieldID) {
    return isSet(_Fields.findByThriftIdOrThrow(fieldID));
  }

  @Override
  public boolean equals(Object that) {
    if (that == null)
      return false;
    if (that instanceof ColumnDescriptor)
      return this.equals((ColumnDescriptor)that);
    return false;
  }

  public boolean equals(ColumnDescriptor 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 (!java.util.Arrays.equals(this.name, that.name))
        return false;
    }

    boolean this_present_maxVersions = true;
    boolean that_present_maxVersions = true;
    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_compression = true && this.isSetCompression();
    boolean that_present_compression = true && that.isSetCompression();
    if (this_present_compression || that_present_compression) {
      if (!(this_present_compression && that_present_compression))
        return false;
      if (!this.compression.equals(that.compression))
        return false;
    }

    boolean this_present_inMemory = true;
    boolean that_present_inMemory = true;
    if (this_present_inMemory || that_present_inMemory) {
      if (!(this_present_inMemory && that_present_inMemory))
        return false;
      if (this.inMemory != that.inMemory)
        return false;
    }

    boolean this_present_bloomFilterType = true && this.isSetBloomFilterType();
    boolean that_present_bloomFilterType = true && that.isSetBloomFilterType();
    if (this_present_bloomFilterType || that_present_bloomFilterType) {
      if (!(this_present_bloomFilterType && that_present_bloomFilterType))
        return false;
      if (!this.bloomFilterType.equals(that.bloomFilterType))
        return false;
    }

    boolean this_present_bloomFilterVectorSize = true;
    boolean that_present_bloomFilterVectorSize = true;
    if (this_present_bloomFilterVectorSize || that_present_bloomFilterVectorSize) {
      if (!(this_present_bloomFilterVectorSize && that_present_bloomFilterVectorSize))
        return false;
      if (this.bloomFilterVectorSize != that.bloomFilterVectorSize)
        return false;
    }

    boolean this_present_bloomFilterNbHashes = true;
    boolean that_present_bloomFilterNbHashes = true;
    if (this_present_bloomFilterNbHashes || that_present_bloomFilterNbHashes) {
      if (!(this_present_bloomFilterNbHashes && that_present_bloomFilterNbHashes))
        return false;
      if (this.bloomFilterNbHashes != that.bloomFilterNbHashes)
        return false;
    }

    boolean this_present_blockCacheEnabled = true;
    boolean that_present_blockCacheEnabled = true;
    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_timeToLive = true;
    boolean that_present_timeToLive = true;
    if (this_present_timeToLive || that_present_timeToLive) {
      if (!(this_present_timeToLive && that_present_timeToLive))
        return false;
      if (this.timeToLive != that.timeToLive)
        return false;
    }

    return true;
  }

  @Override
  public int hashCode() {
    HashCodeBuilder builder = new HashCodeBuilder();

    boolean present_name = true && (isSetName());
    builder.append(present_name);
    if (present_name)
      builder.append(name);

    boolean present_maxVersions = true;
    builder.append(present_maxVersions);
    if (present_maxVersions)
      builder.append(maxVersions);

    boolean present_compression = true && (isSetCompression());
    builder.append(present_compression);
    if (present_compression)
      builder.append(compression);

    boolean present_inMemory = true;
    builder.append(present_inMemory);
    if (present_inMemory)
      builder.append(inMemory);

    boolean present_bloomFilterType = true && (isSetBloomFilterType());
    builder.append(present_bloomFilterType);
    if (present_bloomFilterType)
      builder.append(bloomFilterType);

    boolean present_bloomFilterVectorSize = true;
    builder.append(present_bloomFilterVectorSize);
    if (present_bloomFilterVectorSize)
      builder.append(bloomFilterVectorSize);

    boolean present_bloomFilterNbHashes = true;
    builder.append(present_bloomFilterNbHashes);
    if (present_bloomFilterNbHashes)
      builder.append(bloomFilterNbHashes);

    boolean present_blockCacheEnabled = true;
    builder.append(present_blockCacheEnabled);
    if (present_blockCacheEnabled)
      builder.append(blockCacheEnabled);

    boolean present_timeToLive = true;
    builder.append(present_timeToLive);
    if (present_timeToLive)
      builder.append(timeToLive);

    return builder.toHashCode();
  }

  public int compareTo(ColumnDescriptor other) {
    if (!getClass().equals(other.getClass())) {
      return getClass().getName().compareTo(other.getClass().getName());
    }

    int lastComparison = 0;
    ColumnDescriptor typedOther = (ColumnDescriptor)other;

    lastComparison = Boolean.valueOf(isSetName()).compareTo(isSetName());
    if (lastComparison != 0) {
      return lastComparison;
    }
    lastComparison = TBaseHelper.compareTo(name, typedOther.name);
    if (lastComparison != 0) {
      return lastComparison;
    }
    lastComparison = Boolean.valueOf(isSetMaxVersions()).compareTo(isSetMaxVersions());
    if (lastComparison != 0) {
      return lastComparison;
    }
    lastComparison = TBaseHelper.compareTo(maxVersions, typedOther.maxVersions);
    if (lastComparison != 0) {
      return lastComparison;
    }
    lastComparison = Boolean.valueOf(isSetCompression()).compareTo(isSetCompression());
    if (lastComparison != 0) {
      return lastComparison;
    }
    lastComparison = TBaseHelper.compareTo(compression, typedOther.compression);
    if (lastComparison != 0) {
      return lastComparison;
    }
    lastComparison = Boolean.valueOf(isSetInMemory()).compareTo(isSetInMemory());
    if (lastComparison != 0) {
      return lastComparison;
    }
    lastComparison = TBaseHelper.compareTo(inMemory, typedOther.inMemory);
    if (lastComparison != 0) {
      return lastComparison;
    }
    lastComparison = Boolean.valueOf(isSetBloomFilterType()).compareTo(isSetBloomFilterType());
    if (lastComparison != 0) {
      return lastComparison;
    }
    lastComparison = TBaseHelper.compareTo(bloomFilterType, typedOther.bloomFilterType);
    if (lastComparison != 0) {
      return lastComparison;
    }
    lastComparison = Boolean.valueOf(isSetBloomFilterVectorSize()).compareTo(isSetBloomFilterVectorSize());
    if (lastComparison != 0) {
      return lastComparison;
    }
    lastComparison = TBaseHelper.compareTo(bloomFilterVectorSize, typedOther.bloomFilterVectorSize);
    if (lastComparison != 0) {
      return lastComparison;
    }
    lastComparison = Boolean.valueOf(isSetBloomFilterNbHashes()).compareTo(isSetBloomFilterNbHashes());
    if (lastComparison != 0) {
      return lastComparison;
    }
    lastComparison = TBaseHelper.compareTo(bloomFilterNbHashes, typedOther.bloomFilterNbHashes);
    if (lastComparison != 0) {
      return lastComparison;
    }
    lastComparison = Boolean.valueOf(isSetBlockCacheEnabled()).compareTo(isSetBlockCacheEnabled());
    if (lastComparison != 0) {
      return lastComparison;
    }
    lastComparison = TBaseHelper.compareTo(blockCacheEnabled, typedOther.blockCacheEnabled);
    if (lastComparison != 0) {
      return lastComparison;
    }
    lastComparison = Boolean.valueOf(isSetTimeToLive()).compareTo(isSetTimeToLive());
    if (lastComparison != 0) {
      return lastComparison;
    }
    lastComparison = TBaseHelper.compareTo(timeToLive, typedOther.timeToLive);
    if (lastComparison != 0) {
      return lastComparison;
    }
    return 0;
  }

  public void read(TProtocol iprot) throws TException {
    TField field;
    iprot.readStructBegin();
    while (true)
    {
      field = iprot.readFieldBegin();
      if (field.type == TType.STOP) {
        break;
      }
      _Fields fieldId = _Fields.findByThriftId(field.id);
      if (fieldId == null) {
        TProtocolUtil.skip(iprot, field.type);
      } else {
        switch (fieldId) {
          case NAME:
            if (field.type == TType.STRING) {
              this.name = iprot.readBinary();
            } else {
              TProtocolUtil.skip(iprot, field.type);
            }
            break;
          case MAX_VERSIONS:
            if (field.type == TType.I32) {
              this.maxVersions = iprot.readI32();
              setMaxVersionsIsSet(true);
            } else {
              TProtocolUtil.skip(iprot, field.type);
            }
            break;
          case COMPRESSION:
            if (field.type == TType.STRING) {
              this.compression = iprot.readString();
            } else {
              TProtocolUtil.skip(iprot, field.type);
            }
            break;
          case IN_MEMORY:
            if (field.type == TType.BOOL) {
              this.inMemory = iprot.readBool();
              setInMemoryIsSet(true);
            } else {
              TProtocolUtil.skip(iprot, field.type);
            }
            break;
          case BLOOM_FILTER_TYPE:
            if (field.type == TType.STRING) {
              this.bloomFilterType = iprot.readString();
            } else {
              TProtocolUtil.skip(iprot, field.type);
            }
            break;
          case BLOOM_FILTER_VECTOR_SIZE:
            if (field.type == TType.I32) {
              this.bloomFilterVectorSize = iprot.readI32();
              setBloomFilterVectorSizeIsSet(true);
            } else {
              TProtocolUtil.skip(iprot, field.type);
            }
            break;
          case BLOOM_FILTER_NB_HASHES:
            if (field.type == TType.I32) {
              this.bloomFilterNbHashes = iprot.readI32();
              setBloomFilterNbHashesIsSet(true);
            } else {
              TProtocolUtil.skip(iprot, field.type);
            }
            break;
          case BLOCK_CACHE_ENABLED:
            if (field.type == TType.BOOL) {
              this.blockCacheEnabled = iprot.readBool();
              setBlockCacheEnabledIsSet(true);
            } else {
              TProtocolUtil.skip(iprot, field.type);
            }
            break;
          case TIME_TO_LIVE:
            if (field.type == TType.I32) {
              this.timeToLive = iprot.readI32();
              setTimeToLiveIsSet(true);
            } else {
              TProtocolUtil.skip(iprot, field.type);
            }
            break;
        }
        iprot.readFieldEnd();
      }
    }
    iprot.readStructEnd();

    // check for required fields of primitive type, which can't be checked in the validate method
    validate();
  }

  public void write(TProtocol oprot) throws TException {
    validate();

    oprot.writeStructBegin(STRUCT_DESC);
    if (this.name != null) {
      oprot.writeFieldBegin(NAME_FIELD_DESC);
      oprot.writeBinary(this.name);
      oprot.writeFieldEnd();
    }
    oprot.writeFieldBegin(MAX_VERSIONS_FIELD_DESC);
    oprot.writeI32(this.maxVersions);
    oprot.writeFieldEnd();
    if (this.compression != null) {
      oprot.writeFieldBegin(COMPRESSION_FIELD_DESC);
      oprot.writeString(this.compression);
      oprot.writeFieldEnd();
    }
    oprot.writeFieldBegin(IN_MEMORY_FIELD_DESC);
    oprot.writeBool(this.inMemory);
    oprot.writeFieldEnd();
    if (this.bloomFilterType != null) {
      oprot.writeFieldBegin(BLOOM_FILTER_TYPE_FIELD_DESC);
      oprot.writeString(this.bloomFilterType);
      oprot.writeFieldEnd();
    }
    oprot.writeFieldBegin(BLOOM_FILTER_VECTOR_SIZE_FIELD_DESC);
    oprot.writeI32(this.bloomFilterVectorSize);
    oprot.writeFieldEnd();
    oprot.writeFieldBegin(BLOOM_FILTER_NB_HASHES_FIELD_DESC);
    oprot.writeI32(this.bloomFilterNbHashes);
    oprot.writeFieldEnd();
    oprot.writeFieldBegin(BLOCK_CACHE_ENABLED_FIELD_DESC);
    oprot.writeBool(this.blockCacheEnabled);
    oprot.writeFieldEnd();
    oprot.writeFieldBegin(TIME_TO_LIVE_FIELD_DESC);
    oprot.writeI32(this.timeToLive);
    oprot.writeFieldEnd();
    oprot.writeFieldStop();
    oprot.writeStructEnd();
  }

  @Override
  public String toString() {
    StringBuilder sb = new StringBuilder("ColumnDescriptor(");
    boolean first = true;

    sb.append("name:");
    if (this.name == null) {
      sb.append("null");
    } else {
      sb.append(this.name);
    }
    first = false;
    if (!first) sb.append(", ");
    sb.append("maxVersions:");
    sb.append(this.maxVersions);
    first = false;
    if (!first) sb.append(", ");
    sb.append("compression:");
    if (this.compression == null) {
      sb.append("null");
    } else {
      sb.append(this.compression);
    }
    first = false;
    if (!first) sb.append(", ");
    sb.append("inMemory:");
    sb.append(this.inMemory);
    first = false;
    if (!first) sb.append(", ");
    sb.append("bloomFilterType:");
    if (this.bloomFilterType == null) {
      sb.append("null");
    } else {
      sb.append(this.bloomFilterType);
    }
    first = false;
    if (!first) sb.append(", ");
    sb.append("bloomFilterVectorSize:");
    sb.append(this.bloomFilterVectorSize);
    first = false;
    if (!first) sb.append(", ");
    sb.append("bloomFilterNbHashes:");
    sb.append(this.bloomFilterNbHashes);
    first = false;
    if (!first) sb.append(", ");
    sb.append("blockCacheEnabled:");
    sb.append(this.blockCacheEnabled);
    first = false;
    if (!first) sb.append(", ");
    sb.append("timeToLive:");
    sb.append(this.timeToLive);
    first = false;
    sb.append(")");
    return sb.toString();
  }

  public void validate() throws TException {
    // check for required fields
  }

}