/**
 * Autogenerated by Thrift Compiler (0.13.0)
 *
 * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
 *  @generated
 */
package org.apache.hadoop.hbase.thrift2.generated;

@SuppressWarnings({"cast", "rawtypes", "serial", "unchecked", "unused"})
/**
 * Any timestamps in the columns are ignored but the colFamTimeRangeMap included, use timeRange to select by timestamp.
 * Max versions defaults to 1.
 */
@javax.annotation.Generated(value = "Autogenerated by Thrift Compiler (0.13.0)", date = "2020-04-16")
public class TScan implements org.apache.thrift.TBase<TScan, TScan._Fields>, java.io.Serializable, Cloneable, Comparable<TScan> {
  private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("TScan");

  private static final org.apache.thrift.protocol.TField START_ROW_FIELD_DESC = new org.apache.thrift.protocol.TField("startRow", org.apache.thrift.protocol.TType.STRING, (short)1);
  private static final org.apache.thrift.protocol.TField STOP_ROW_FIELD_DESC = new org.apache.thrift.protocol.TField("stopRow", org.apache.thrift.protocol.TType.STRING, (short)2);
  private static final org.apache.thrift.protocol.TField COLUMNS_FIELD_DESC = new org.apache.thrift.protocol.TField("columns", org.apache.thrift.protocol.TType.LIST, (short)3);
  private static final org.apache.thrift.protocol.TField CACHING_FIELD_DESC = new org.apache.thrift.protocol.TField("caching", org.apache.thrift.protocol.TType.I32, (short)4);
  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)5);
  private static final org.apache.thrift.protocol.TField TIME_RANGE_FIELD_DESC = new org.apache.thrift.protocol.TField("timeRange", org.apache.thrift.protocol.TType.STRUCT, (short)6);
  private static final org.apache.thrift.protocol.TField FILTER_STRING_FIELD_DESC = new org.apache.thrift.protocol.TField("filterString", org.apache.thrift.protocol.TType.STRING, (short)7);
  private static final org.apache.thrift.protocol.TField BATCH_SIZE_FIELD_DESC = new org.apache.thrift.protocol.TField("batchSize", org.apache.thrift.protocol.TType.I32, (short)8);
  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)9);
  private static final org.apache.thrift.protocol.TField AUTHORIZATIONS_FIELD_DESC = new org.apache.thrift.protocol.TField("authorizations", org.apache.thrift.protocol.TType.STRUCT, (short)10);
  private static final org.apache.thrift.protocol.TField REVERSED_FIELD_DESC = new org.apache.thrift.protocol.TField("reversed", org.apache.thrift.protocol.TType.BOOL, (short)11);
  private static final org.apache.thrift.protocol.TField CACHE_BLOCKS_FIELD_DESC = new org.apache.thrift.protocol.TField("cacheBlocks", org.apache.thrift.protocol.TType.BOOL, (short)12);
  private static final org.apache.thrift.protocol.TField COL_FAM_TIME_RANGE_MAP_FIELD_DESC = new org.apache.thrift.protocol.TField("colFamTimeRangeMap", org.apache.thrift.protocol.TType.MAP, (short)13);
  private static final org.apache.thrift.protocol.TField READ_TYPE_FIELD_DESC = new org.apache.thrift.protocol.TField("readType", org.apache.thrift.protocol.TType.I32, (short)14);
  private static final org.apache.thrift.protocol.TField LIMIT_FIELD_DESC = new org.apache.thrift.protocol.TField("limit", org.apache.thrift.protocol.TType.I32, (short)15);
  private static final org.apache.thrift.protocol.TField CONSISTENCY_FIELD_DESC = new org.apache.thrift.protocol.TField("consistency", org.apache.thrift.protocol.TType.I32, (short)16);
  private static final org.apache.thrift.protocol.TField TARGET_REPLICA_ID_FIELD_DESC = new org.apache.thrift.protocol.TField("targetReplicaId", org.apache.thrift.protocol.TType.I32, (short)17);
  private static final org.apache.thrift.protocol.TField FILTER_BYTES_FIELD_DESC = new org.apache.thrift.protocol.TField("filterBytes", org.apache.thrift.protocol.TType.STRING, (short)18);

  private static final org.apache.thrift.scheme.SchemeFactory STANDARD_SCHEME_FACTORY = new TScanStandardSchemeFactory();
  private static final org.apache.thrift.scheme.SchemeFactory TUPLE_SCHEME_FACTORY = new TScanTupleSchemeFactory();

  public @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer startRow; // optional
  public @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer stopRow; // optional
  public @org.apache.thrift.annotation.Nullable java.util.List<TColumn> columns; // optional
  public int caching; // optional
  public int maxVersions; // optional
  public @org.apache.thrift.annotation.Nullable TTimeRange timeRange; // optional
  public @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer filterString; // optional
  public int batchSize; // optional
  public @org.apache.thrift.annotation.Nullable java.util.Map<java.nio.ByteBuffer,java.nio.ByteBuffer> attributes; // optional
  public @org.apache.thrift.annotation.Nullable TAuthorization authorizations; // optional
  public boolean reversed; // optional
  public boolean cacheBlocks; // optional
  public @org.apache.thrift.annotation.Nullable java.util.Map<java.nio.ByteBuffer,TTimeRange> colFamTimeRangeMap; // optional
  /**
   * 
   * @see TReadType
   */
  public @org.apache.thrift.annotation.Nullable TReadType readType; // optional
  public int limit; // optional
  /**
   * 
   * @see TConsistency
   */
  public @org.apache.thrift.annotation.Nullable TConsistency consistency; // optional
  public int targetReplicaId; // optional
  public @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer filterBytes; // 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 {
    START_ROW((short)1, "startRow"),
    STOP_ROW((short)2, "stopRow"),
    COLUMNS((short)3, "columns"),
    CACHING((short)4, "caching"),
    MAX_VERSIONS((short)5, "maxVersions"),
    TIME_RANGE((short)6, "timeRange"),
    FILTER_STRING((short)7, "filterString"),
    BATCH_SIZE((short)8, "batchSize"),
    ATTRIBUTES((short)9, "attributes"),
    AUTHORIZATIONS((short)10, "authorizations"),
    REVERSED((short)11, "reversed"),
    CACHE_BLOCKS((short)12, "cacheBlocks"),
    COL_FAM_TIME_RANGE_MAP((short)13, "colFamTimeRangeMap"),
    /**
     * 
     * @see TReadType
     */
    READ_TYPE((short)14, "readType"),
    LIMIT((short)15, "limit"),
    /**
     * 
     * @see TConsistency
     */
    CONSISTENCY((short)16, "consistency"),
    TARGET_REPLICA_ID((short)17, "targetReplicaId"),
    FILTER_BYTES((short)18, "filterBytes");

    private static final java.util.Map<java.lang.String, _Fields> byName = new java.util.HashMap<java.lang.String, _Fields>();

    static {
      for (_Fields field : java.util.EnumSet.allOf(_Fields.class)) {
        byName.put(field.getFieldName(), field);
      }
    }

    /**
     * Find the _Fields constant that matches fieldId, or null if its not found.
     */
    @org.apache.thrift.annotation.Nullable
    public static _Fields findByThriftId(int fieldId) {
      switch(fieldId) {
        case 1: // START_ROW
          return START_ROW;
        case 2: // STOP_ROW
          return STOP_ROW;
        case 3: // COLUMNS
          return COLUMNS;
        case 4: // CACHING
          return CACHING;
        case 5: // MAX_VERSIONS
          return MAX_VERSIONS;
        case 6: // TIME_RANGE
          return TIME_RANGE;
        case 7: // FILTER_STRING
          return FILTER_STRING;
        case 8: // BATCH_SIZE
          return BATCH_SIZE;
        case 9: // ATTRIBUTES
          return ATTRIBUTES;
        case 10: // AUTHORIZATIONS
          return AUTHORIZATIONS;
        case 11: // REVERSED
          return REVERSED;
        case 12: // CACHE_BLOCKS
          return CACHE_BLOCKS;
        case 13: // COL_FAM_TIME_RANGE_MAP
          return COL_FAM_TIME_RANGE_MAP;
        case 14: // READ_TYPE
          return READ_TYPE;
        case 15: // LIMIT
          return LIMIT;
        case 16: // CONSISTENCY
          return CONSISTENCY;
        case 17: // TARGET_REPLICA_ID
          return TARGET_REPLICA_ID;
        case 18: // FILTER_BYTES
          return FILTER_BYTES;
        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 java.lang.IllegalArgumentException("Field " + fieldId + " doesn't exist!");
      return fields;
    }

    /**
     * Find the _Fields constant that matches name, or null if its not found.
     */
    @org.apache.thrift.annotation.Nullable
    public static _Fields findByName(java.lang.String name) {
      return byName.get(name);
    }

    private final short _thriftId;
    private final java.lang.String _fieldName;

    _Fields(short thriftId, java.lang.String fieldName) {
      _thriftId = thriftId;
      _fieldName = fieldName;
    }

    public short getThriftFieldId() {
      return _thriftId;
    }

    public java.lang.String getFieldName() {
      return _fieldName;
    }
  }

  // isset id assignments
  private static final int __CACHING_ISSET_ID = 0;
  private static final int __MAXVERSIONS_ISSET_ID = 1;
  private static final int __BATCHSIZE_ISSET_ID = 2;
  private static final int __REVERSED_ISSET_ID = 3;
  private static final int __CACHEBLOCKS_ISSET_ID = 4;
  private static final int __LIMIT_ISSET_ID = 5;
  private static final int __TARGETREPLICAID_ISSET_ID = 6;
  private byte __isset_bitfield = 0;
  private static final _Fields optionals[] = {_Fields.START_ROW,_Fields.STOP_ROW,_Fields.COLUMNS,_Fields.CACHING,_Fields.MAX_VERSIONS,_Fields.TIME_RANGE,_Fields.FILTER_STRING,_Fields.BATCH_SIZE,_Fields.ATTRIBUTES,_Fields.AUTHORIZATIONS,_Fields.REVERSED,_Fields.CACHE_BLOCKS,_Fields.COL_FAM_TIME_RANGE_MAP,_Fields.READ_TYPE,_Fields.LIMIT,_Fields.CONSISTENCY,_Fields.TARGET_REPLICA_ID,_Fields.FILTER_BYTES};
  public static final java.util.Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap;
  static {
    java.util.Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new java.util.EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class);
    tmpMap.put(_Fields.START_ROW, new org.apache.thrift.meta_data.FieldMetaData("startRow", org.apache.thrift.TFieldRequirementType.OPTIONAL, 
        new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING        , true)));
    tmpMap.put(_Fields.STOP_ROW, new org.apache.thrift.meta_data.FieldMetaData("stopRow", org.apache.thrift.TFieldRequirementType.OPTIONAL, 
        new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING        , true)));
    tmpMap.put(_Fields.COLUMNS, new org.apache.thrift.meta_data.FieldMetaData("columns", org.apache.thrift.TFieldRequirementType.OPTIONAL, 
        new org.apache.thrift.meta_data.ListMetaData(org.apache.thrift.protocol.TType.LIST, 
            new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, TColumn.class))));
    tmpMap.put(_Fields.CACHING, new org.apache.thrift.meta_data.FieldMetaData("caching", org.apache.thrift.TFieldRequirementType.OPTIONAL, 
        new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.I32)));
    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.TIME_RANGE, new org.apache.thrift.meta_data.FieldMetaData("timeRange", org.apache.thrift.TFieldRequirementType.OPTIONAL, 
        new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, TTimeRange.class)));
    tmpMap.put(_Fields.FILTER_STRING, new org.apache.thrift.meta_data.FieldMetaData("filterString", org.apache.thrift.TFieldRequirementType.OPTIONAL, 
        new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING        , true)));
    tmpMap.put(_Fields.BATCH_SIZE, new org.apache.thrift.meta_data.FieldMetaData("batchSize", org.apache.thrift.TFieldRequirementType.OPTIONAL, 
        new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.I32)));
    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.AUTHORIZATIONS, new org.apache.thrift.meta_data.FieldMetaData("authorizations", org.apache.thrift.TFieldRequirementType.OPTIONAL, 
        new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, TAuthorization.class)));
    tmpMap.put(_Fields.REVERSED, new org.apache.thrift.meta_data.FieldMetaData("reversed", org.apache.thrift.TFieldRequirementType.OPTIONAL, 
        new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.BOOL)));
    tmpMap.put(_Fields.CACHE_BLOCKS, new org.apache.thrift.meta_data.FieldMetaData("cacheBlocks", org.apache.thrift.TFieldRequirementType.OPTIONAL, 
        new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.BOOL)));
    tmpMap.put(_Fields.COL_FAM_TIME_RANGE_MAP, new org.apache.thrift.meta_data.FieldMetaData("colFamTimeRangeMap", 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.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, TTimeRange.class))));
    tmpMap.put(_Fields.READ_TYPE, new org.apache.thrift.meta_data.FieldMetaData("readType", org.apache.thrift.TFieldRequirementType.OPTIONAL, 
        new org.apache.thrift.meta_data.EnumMetaData(org.apache.thrift.protocol.TType.ENUM, TReadType.class)));
    tmpMap.put(_Fields.LIMIT, new org.apache.thrift.meta_data.FieldMetaData("limit", org.apache.thrift.TFieldRequirementType.OPTIONAL, 
        new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.I32)));
    tmpMap.put(_Fields.CONSISTENCY, new org.apache.thrift.meta_data.FieldMetaData("consistency", org.apache.thrift.TFieldRequirementType.OPTIONAL, 
        new org.apache.thrift.meta_data.EnumMetaData(org.apache.thrift.protocol.TType.ENUM, TConsistency.class)));
    tmpMap.put(_Fields.TARGET_REPLICA_ID, new org.apache.thrift.meta_data.FieldMetaData("targetReplicaId", org.apache.thrift.TFieldRequirementType.OPTIONAL, 
        new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.I32)));
    tmpMap.put(_Fields.FILTER_BYTES, new org.apache.thrift.meta_data.FieldMetaData("filterBytes", org.apache.thrift.TFieldRequirementType.OPTIONAL, 
        new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING        , true)));
    metaDataMap = java.util.Collections.unmodifiableMap(tmpMap);
    org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(TScan.class, metaDataMap);
  }

  public TScan() {
    this.maxVersions = 1;

  }

  /**
   * Performs a deep copy on <i>other</i>.
   */
  public TScan(TScan other) {
    __isset_bitfield = other.__isset_bitfield;
    if (other.isSetStartRow()) {
      this.startRow = org.apache.thrift.TBaseHelper.copyBinary(other.startRow);
    }
    if (other.isSetStopRow()) {
      this.stopRow = org.apache.thrift.TBaseHelper.copyBinary(other.stopRow);
    }
    if (other.isSetColumns()) {
      java.util.List<TColumn> __this__columns = new java.util.ArrayList<TColumn>(other.columns.size());
      for (TColumn other_element : other.columns) {
        __this__columns.add(new TColumn(other_element));
      }
      this.columns = __this__columns;
    }
    this.caching = other.caching;
    this.maxVersions = other.maxVersions;
    if (other.isSetTimeRange()) {
      this.timeRange = new TTimeRange(other.timeRange);
    }
    if (other.isSetFilterString()) {
      this.filterString = org.apache.thrift.TBaseHelper.copyBinary(other.filterString);
    }
    this.batchSize = other.batchSize;
    if (other.isSetAttributes()) {
      java.util.Map<java.nio.ByteBuffer,java.nio.ByteBuffer> __this__attributes = new java.util.HashMap<java.nio.ByteBuffer,java.nio.ByteBuffer>(other.attributes);
      this.attributes = __this__attributes;
    }
    if (other.isSetAuthorizations()) {
      this.authorizations = new TAuthorization(other.authorizations);
    }
    this.reversed = other.reversed;
    this.cacheBlocks = other.cacheBlocks;
    if (other.isSetColFamTimeRangeMap()) {
      java.util.Map<java.nio.ByteBuffer,TTimeRange> __this__colFamTimeRangeMap = new java.util.HashMap<java.nio.ByteBuffer,TTimeRange>(other.colFamTimeRangeMap.size());
      for (java.util.Map.Entry<java.nio.ByteBuffer, TTimeRange> other_element : other.colFamTimeRangeMap.entrySet()) {

        java.nio.ByteBuffer other_element_key = other_element.getKey();
        TTimeRange other_element_value = other_element.getValue();

        java.nio.ByteBuffer __this__colFamTimeRangeMap_copy_key = org.apache.thrift.TBaseHelper.copyBinary(other_element_key);

        TTimeRange __this__colFamTimeRangeMap_copy_value = new TTimeRange(other_element_value);

        __this__colFamTimeRangeMap.put(__this__colFamTimeRangeMap_copy_key, __this__colFamTimeRangeMap_copy_value);
      }
      this.colFamTimeRangeMap = __this__colFamTimeRangeMap;
    }
    if (other.isSetReadType()) {
      this.readType = other.readType;
    }
    this.limit = other.limit;
    if (other.isSetConsistency()) {
      this.consistency = other.consistency;
    }
    this.targetReplicaId = other.targetReplicaId;
    if (other.isSetFilterBytes()) {
      this.filterBytes = org.apache.thrift.TBaseHelper.copyBinary(other.filterBytes);
    }
  }

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

  @Override
  public void clear() {
    this.startRow = null;
    this.stopRow = null;
    this.columns = null;
    setCachingIsSet(false);
    this.caching = 0;
    this.maxVersions = 1;

    this.timeRange = null;
    this.filterString = null;
    setBatchSizeIsSet(false);
    this.batchSize = 0;
    this.attributes = null;
    this.authorizations = null;
    setReversedIsSet(false);
    this.reversed = false;
    setCacheBlocksIsSet(false);
    this.cacheBlocks = false;
    this.colFamTimeRangeMap = null;
    this.readType = null;
    setLimitIsSet(false);
    this.limit = 0;
    this.consistency = null;
    setTargetReplicaIdIsSet(false);
    this.targetReplicaId = 0;
    this.filterBytes = null;
  }

  public byte[] getStartRow() {
    setStartRow(org.apache.thrift.TBaseHelper.rightSize(startRow));
    return startRow == null ? null : startRow.array();
  }

  public java.nio.ByteBuffer bufferForStartRow() {
    return org.apache.thrift.TBaseHelper.copyBinary(startRow);
  }

  public TScan setStartRow(byte[] startRow) {
    this.startRow = startRow == null ? (java.nio.ByteBuffer)null   : java.nio.ByteBuffer.wrap(startRow.clone());
    return this;
  }

  public TScan setStartRow(@org.apache.thrift.annotation.Nullable java.nio.ByteBuffer startRow) {
    this.startRow = org.apache.thrift.TBaseHelper.copyBinary(startRow);
    return this;
  }

  public void unsetStartRow() {
    this.startRow = null;
  }

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

  public void setStartRowIsSet(boolean value) {
    if (!value) {
      this.startRow = null;
    }
  }

  public byte[] getStopRow() {
    setStopRow(org.apache.thrift.TBaseHelper.rightSize(stopRow));
    return stopRow == null ? null : stopRow.array();
  }

  public java.nio.ByteBuffer bufferForStopRow() {
    return org.apache.thrift.TBaseHelper.copyBinary(stopRow);
  }

  public TScan setStopRow(byte[] stopRow) {
    this.stopRow = stopRow == null ? (java.nio.ByteBuffer)null   : java.nio.ByteBuffer.wrap(stopRow.clone());
    return this;
  }

  public TScan setStopRow(@org.apache.thrift.annotation.Nullable java.nio.ByteBuffer stopRow) {
    this.stopRow = org.apache.thrift.TBaseHelper.copyBinary(stopRow);
    return this;
  }

  public void unsetStopRow() {
    this.stopRow = null;
  }

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

  public void setStopRowIsSet(boolean value) {
    if (!value) {
      this.stopRow = null;
    }
  }

  public int getColumnsSize() {
    return (this.columns == null) ? 0 : this.columns.size();
  }

  @org.apache.thrift.annotation.Nullable
  public java.util.Iterator<TColumn> getColumnsIterator() {
    return (this.columns == null) ? null : this.columns.iterator();
  }

  public void addToColumns(TColumn elem) {
    if (this.columns == null) {
      this.columns = new java.util.ArrayList<TColumn>();
    }
    this.columns.add(elem);
  }

  @org.apache.thrift.annotation.Nullable
  public java.util.List<TColumn> getColumns() {
    return this.columns;
  }

  public TScan setColumns(@org.apache.thrift.annotation.Nullable java.util.List<TColumn> columns) {
    this.columns = columns;
    return this;
  }

  public void unsetColumns() {
    this.columns = null;
  }

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

  public void setColumnsIsSet(boolean value) {
    if (!value) {
      this.columns = null;
    }
  }

  public int getCaching() {
    return this.caching;
  }

  public TScan setCaching(int caching) {
    this.caching = caching;
    setCachingIsSet(true);
    return this;
  }

  public void unsetCaching() {
    __isset_bitfield = org.apache.thrift.EncodingUtils.clearBit(__isset_bitfield, __CACHING_ISSET_ID);
  }

  /** Returns true if field caching is set (has been assigned a value) and false otherwise */
  public boolean isSetCaching() {
    return org.apache.thrift.EncodingUtils.testBit(__isset_bitfield, __CACHING_ISSET_ID);
  }

  public void setCachingIsSet(boolean value) {
    __isset_bitfield = org.apache.thrift.EncodingUtils.setBit(__isset_bitfield, __CACHING_ISSET_ID, value);
  }

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

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

  public void unsetMaxVersions() {
    __isset_bitfield = org.apache.thrift.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 org.apache.thrift.EncodingUtils.testBit(__isset_bitfield, __MAXVERSIONS_ISSET_ID);
  }

  public void setMaxVersionsIsSet(boolean value) {
    __isset_bitfield = org.apache.thrift.EncodingUtils.setBit(__isset_bitfield, __MAXVERSIONS_ISSET_ID, value);
  }

  @org.apache.thrift.annotation.Nullable
  public TTimeRange getTimeRange() {
    return this.timeRange;
  }

  public TScan setTimeRange(@org.apache.thrift.annotation.Nullable TTimeRange timeRange) {
    this.timeRange = timeRange;
    return this;
  }

  public void unsetTimeRange() {
    this.timeRange = null;
  }

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

  public void setTimeRangeIsSet(boolean value) {
    if (!value) {
      this.timeRange = null;
    }
  }

  public byte[] getFilterString() {
    setFilterString(org.apache.thrift.TBaseHelper.rightSize(filterString));
    return filterString == null ? null : filterString.array();
  }

  public java.nio.ByteBuffer bufferForFilterString() {
    return org.apache.thrift.TBaseHelper.copyBinary(filterString);
  }

  public TScan setFilterString(byte[] filterString) {
    this.filterString = filterString == null ? (java.nio.ByteBuffer)null   : java.nio.ByteBuffer.wrap(filterString.clone());
    return this;
  }

  public TScan setFilterString(@org.apache.thrift.annotation.Nullable java.nio.ByteBuffer filterString) {
    this.filterString = org.apache.thrift.TBaseHelper.copyBinary(filterString);
    return this;
  }

  public void unsetFilterString() {
    this.filterString = null;
  }

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

  public void setFilterStringIsSet(boolean value) {
    if (!value) {
      this.filterString = null;
    }
  }

  public int getBatchSize() {
    return this.batchSize;
  }

  public TScan setBatchSize(int batchSize) {
    this.batchSize = batchSize;
    setBatchSizeIsSet(true);
    return this;
  }

  public void unsetBatchSize() {
    __isset_bitfield = org.apache.thrift.EncodingUtils.clearBit(__isset_bitfield, __BATCHSIZE_ISSET_ID);
  }

  /** Returns true if field batchSize is set (has been assigned a value) and false otherwise */
  public boolean isSetBatchSize() {
    return org.apache.thrift.EncodingUtils.testBit(__isset_bitfield, __BATCHSIZE_ISSET_ID);
  }

  public void setBatchSizeIsSet(boolean value) {
    __isset_bitfield = org.apache.thrift.EncodingUtils.setBit(__isset_bitfield, __BATCHSIZE_ISSET_ID, value);
  }

  public int getAttributesSize() {
    return (this.attributes == null) ? 0 : this.attributes.size();
  }

  public void putToAttributes(java.nio.ByteBuffer key, java.nio.ByteBuffer val) {
    if (this.attributes == null) {
      this.attributes = new java.util.HashMap<java.nio.ByteBuffer,java.nio.ByteBuffer>();
    }
    this.attributes.put(key, val);
  }

  @org.apache.thrift.annotation.Nullable
  public java.util.Map<java.nio.ByteBuffer,java.nio.ByteBuffer> getAttributes() {
    return this.attributes;
  }

  public TScan setAttributes(@org.apache.thrift.annotation.Nullable java.util.Map<java.nio.ByteBuffer,java.nio.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;
    }
  }

  @org.apache.thrift.annotation.Nullable
  public TAuthorization getAuthorizations() {
    return this.authorizations;
  }

  public TScan setAuthorizations(@org.apache.thrift.annotation.Nullable TAuthorization authorizations) {
    this.authorizations = authorizations;
    return this;
  }

  public void unsetAuthorizations() {
    this.authorizations = null;
  }

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

  public void setAuthorizationsIsSet(boolean value) {
    if (!value) {
      this.authorizations = null;
    }
  }

  public boolean isReversed() {
    return this.reversed;
  }

  public TScan setReversed(boolean reversed) {
    this.reversed = reversed;
    setReversedIsSet(true);
    return this;
  }

  public void unsetReversed() {
    __isset_bitfield = org.apache.thrift.EncodingUtils.clearBit(__isset_bitfield, __REVERSED_ISSET_ID);
  }

  /** Returns true if field reversed is set (has been assigned a value) and false otherwise */
  public boolean isSetReversed() {
    return org.apache.thrift.EncodingUtils.testBit(__isset_bitfield, __REVERSED_ISSET_ID);
  }

  public void setReversedIsSet(boolean value) {
    __isset_bitfield = org.apache.thrift.EncodingUtils.setBit(__isset_bitfield, __REVERSED_ISSET_ID, value);
  }

  public boolean isCacheBlocks() {
    return this.cacheBlocks;
  }

  public TScan setCacheBlocks(boolean cacheBlocks) {
    this.cacheBlocks = cacheBlocks;
    setCacheBlocksIsSet(true);
    return this;
  }

  public void unsetCacheBlocks() {
    __isset_bitfield = org.apache.thrift.EncodingUtils.clearBit(__isset_bitfield, __CACHEBLOCKS_ISSET_ID);
  }

  /** Returns true if field cacheBlocks is set (has been assigned a value) and false otherwise */
  public boolean isSetCacheBlocks() {
    return org.apache.thrift.EncodingUtils.testBit(__isset_bitfield, __CACHEBLOCKS_ISSET_ID);
  }

  public void setCacheBlocksIsSet(boolean value) {
    __isset_bitfield = org.apache.thrift.EncodingUtils.setBit(__isset_bitfield, __CACHEBLOCKS_ISSET_ID, value);
  }

  public int getColFamTimeRangeMapSize() {
    return (this.colFamTimeRangeMap == null) ? 0 : this.colFamTimeRangeMap.size();
  }

  public void putToColFamTimeRangeMap(java.nio.ByteBuffer key, TTimeRange val) {
    if (this.colFamTimeRangeMap == null) {
      this.colFamTimeRangeMap = new java.util.HashMap<java.nio.ByteBuffer,TTimeRange>();
    }
    this.colFamTimeRangeMap.put(key, val);
  }

  @org.apache.thrift.annotation.Nullable
  public java.util.Map<java.nio.ByteBuffer,TTimeRange> getColFamTimeRangeMap() {
    return this.colFamTimeRangeMap;
  }

  public TScan setColFamTimeRangeMap(@org.apache.thrift.annotation.Nullable java.util.Map<java.nio.ByteBuffer,TTimeRange> colFamTimeRangeMap) {
    this.colFamTimeRangeMap = colFamTimeRangeMap;
    return this;
  }

  public void unsetColFamTimeRangeMap() {
    this.colFamTimeRangeMap = null;
  }

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

  public void setColFamTimeRangeMapIsSet(boolean value) {
    if (!value) {
      this.colFamTimeRangeMap = null;
    }
  }

  /**
   * 
   * @see TReadType
   */
  @org.apache.thrift.annotation.Nullable
  public TReadType getReadType() {
    return this.readType;
  }

  /**
   * 
   * @see TReadType
   */
  public TScan setReadType(@org.apache.thrift.annotation.Nullable TReadType readType) {
    this.readType = readType;
    return this;
  }

  public void unsetReadType() {
    this.readType = null;
  }

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

  public void setReadTypeIsSet(boolean value) {
    if (!value) {
      this.readType = null;
    }
  }

  public int getLimit() {
    return this.limit;
  }

  public TScan setLimit(int limit) {
    this.limit = limit;
    setLimitIsSet(true);
    return this;
  }

  public void unsetLimit() {
    __isset_bitfield = org.apache.thrift.EncodingUtils.clearBit(__isset_bitfield, __LIMIT_ISSET_ID);
  }

  /** Returns true if field limit is set (has been assigned a value) and false otherwise */
  public boolean isSetLimit() {
    return org.apache.thrift.EncodingUtils.testBit(__isset_bitfield, __LIMIT_ISSET_ID);
  }

  public void setLimitIsSet(boolean value) {
    __isset_bitfield = org.apache.thrift.EncodingUtils.setBit(__isset_bitfield, __LIMIT_ISSET_ID, value);
  }

  /**
   * 
   * @see TConsistency
   */
  @org.apache.thrift.annotation.Nullable
  public TConsistency getConsistency() {
    return this.consistency;
  }

  /**
   * 
   * @see TConsistency
   */
  public TScan setConsistency(@org.apache.thrift.annotation.Nullable TConsistency consistency) {
    this.consistency = consistency;
    return this;
  }

  public void unsetConsistency() {
    this.consistency = null;
  }

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

  public void setConsistencyIsSet(boolean value) {
    if (!value) {
      this.consistency = null;
    }
  }

  public int getTargetReplicaId() {
    return this.targetReplicaId;
  }

  public TScan setTargetReplicaId(int targetReplicaId) {
    this.targetReplicaId = targetReplicaId;
    setTargetReplicaIdIsSet(true);
    return this;
  }

  public void unsetTargetReplicaId() {
    __isset_bitfield = org.apache.thrift.EncodingUtils.clearBit(__isset_bitfield, __TARGETREPLICAID_ISSET_ID);
  }

  /** Returns true if field targetReplicaId is set (has been assigned a value) and false otherwise */
  public boolean isSetTargetReplicaId() {
    return org.apache.thrift.EncodingUtils.testBit(__isset_bitfield, __TARGETREPLICAID_ISSET_ID);
  }

  public void setTargetReplicaIdIsSet(boolean value) {
    __isset_bitfield = org.apache.thrift.EncodingUtils.setBit(__isset_bitfield, __TARGETREPLICAID_ISSET_ID, value);
  }

  public byte[] getFilterBytes() {
    setFilterBytes(org.apache.thrift.TBaseHelper.rightSize(filterBytes));
    return filterBytes == null ? null : filterBytes.array();
  }

  public java.nio.ByteBuffer bufferForFilterBytes() {
    return org.apache.thrift.TBaseHelper.copyBinary(filterBytes);
  }

  public TScan setFilterBytes(byte[] filterBytes) {
    this.filterBytes = filterBytes == null ? (java.nio.ByteBuffer)null   : java.nio.ByteBuffer.wrap(filterBytes.clone());
    return this;
  }

  public TScan setFilterBytes(@org.apache.thrift.annotation.Nullable java.nio.ByteBuffer filterBytes) {
    this.filterBytes = org.apache.thrift.TBaseHelper.copyBinary(filterBytes);
    return this;
  }

  public void unsetFilterBytes() {
    this.filterBytes = null;
  }

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

  public void setFilterBytesIsSet(boolean value) {
    if (!value) {
      this.filterBytes = null;
    }
  }

  public void setFieldValue(_Fields field, @org.apache.thrift.annotation.Nullable java.lang.Object value) {
    switch (field) {
    case START_ROW:
      if (value == null) {
        unsetStartRow();
      } else {
        if (value instanceof byte[]) {
          setStartRow((byte[])value);
        } else {
          setStartRow((java.nio.ByteBuffer)value);
        }
      }
      break;

    case STOP_ROW:
      if (value == null) {
        unsetStopRow();
      } else {
        if (value instanceof byte[]) {
          setStopRow((byte[])value);
        } else {
          setStopRow((java.nio.ByteBuffer)value);
        }
      }
      break;

    case COLUMNS:
      if (value == null) {
        unsetColumns();
      } else {
        setColumns((java.util.List<TColumn>)value);
      }
      break;

    case CACHING:
      if (value == null) {
        unsetCaching();
      } else {
        setCaching((java.lang.Integer)value);
      }
      break;

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

    case TIME_RANGE:
      if (value == null) {
        unsetTimeRange();
      } else {
        setTimeRange((TTimeRange)value);
      }
      break;

    case FILTER_STRING:
      if (value == null) {
        unsetFilterString();
      } else {
        if (value instanceof byte[]) {
          setFilterString((byte[])value);
        } else {
          setFilterString((java.nio.ByteBuffer)value);
        }
      }
      break;

    case BATCH_SIZE:
      if (value == null) {
        unsetBatchSize();
      } else {
        setBatchSize((java.lang.Integer)value);
      }
      break;

    case ATTRIBUTES:
      if (value == null) {
        unsetAttributes();
      } else {
        setAttributes((java.util.Map<java.nio.ByteBuffer,java.nio.ByteBuffer>)value);
      }
      break;

    case AUTHORIZATIONS:
      if (value == null) {
        unsetAuthorizations();
      } else {
        setAuthorizations((TAuthorization)value);
      }
      break;

    case REVERSED:
      if (value == null) {
        unsetReversed();
      } else {
        setReversed((java.lang.Boolean)value);
      }
      break;

    case CACHE_BLOCKS:
      if (value == null) {
        unsetCacheBlocks();
      } else {
        setCacheBlocks((java.lang.Boolean)value);
      }
      break;

    case COL_FAM_TIME_RANGE_MAP:
      if (value == null) {
        unsetColFamTimeRangeMap();
      } else {
        setColFamTimeRangeMap((java.util.Map<java.nio.ByteBuffer,TTimeRange>)value);
      }
      break;

    case READ_TYPE:
      if (value == null) {
        unsetReadType();
      } else {
        setReadType((TReadType)value);
      }
      break;

    case LIMIT:
      if (value == null) {
        unsetLimit();
      } else {
        setLimit((java.lang.Integer)value);
      }
      break;

    case CONSISTENCY:
      if (value == null) {
        unsetConsistency();
      } else {
        setConsistency((TConsistency)value);
      }
      break;

    case TARGET_REPLICA_ID:
      if (value == null) {
        unsetTargetReplicaId();
      } else {
        setTargetReplicaId((java.lang.Integer)value);
      }
      break;

    case FILTER_BYTES:
      if (value == null) {
        unsetFilterBytes();
      } else {
        if (value instanceof byte[]) {
          setFilterBytes((byte[])value);
        } else {
          setFilterBytes((java.nio.ByteBuffer)value);
        }
      }
      break;

    }
  }

  @org.apache.thrift.annotation.Nullable
  public java.lang.Object getFieldValue(_Fields field) {
    switch (field) {
    case START_ROW:
      return getStartRow();

    case STOP_ROW:
      return getStopRow();

    case COLUMNS:
      return getColumns();

    case CACHING:
      return getCaching();

    case MAX_VERSIONS:
      return getMaxVersions();

    case TIME_RANGE:
      return getTimeRange();

    case FILTER_STRING:
      return getFilterString();

    case BATCH_SIZE:
      return getBatchSize();

    case ATTRIBUTES:
      return getAttributes();

    case AUTHORIZATIONS:
      return getAuthorizations();

    case REVERSED:
      return isReversed();

    case CACHE_BLOCKS:
      return isCacheBlocks();

    case COL_FAM_TIME_RANGE_MAP:
      return getColFamTimeRangeMap();

    case READ_TYPE:
      return getReadType();

    case LIMIT:
      return getLimit();

    case CONSISTENCY:
      return getConsistency();

    case TARGET_REPLICA_ID:
      return getTargetReplicaId();

    case FILTER_BYTES:
      return getFilterBytes();

    }
    throw new java.lang.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 java.lang.IllegalArgumentException();
    }

    switch (field) {
    case START_ROW:
      return isSetStartRow();
    case STOP_ROW:
      return isSetStopRow();
    case COLUMNS:
      return isSetColumns();
    case CACHING:
      return isSetCaching();
    case MAX_VERSIONS:
      return isSetMaxVersions();
    case TIME_RANGE:
      return isSetTimeRange();
    case FILTER_STRING:
      return isSetFilterString();
    case BATCH_SIZE:
      return isSetBatchSize();
    case ATTRIBUTES:
      return isSetAttributes();
    case AUTHORIZATIONS:
      return isSetAuthorizations();
    case REVERSED:
      return isSetReversed();
    case CACHE_BLOCKS:
      return isSetCacheBlocks();
    case COL_FAM_TIME_RANGE_MAP:
      return isSetColFamTimeRangeMap();
    case READ_TYPE:
      return isSetReadType();
    case LIMIT:
      return isSetLimit();
    case CONSISTENCY:
      return isSetConsistency();
    case TARGET_REPLICA_ID:
      return isSetTargetReplicaId();
    case FILTER_BYTES:
      return isSetFilterBytes();
    }
    throw new java.lang.IllegalStateException();
  }

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

  public boolean equals(TScan that) {
    if (that == null)
      return false;
    if (this == that)
      return true;

    boolean this_present_startRow = true && this.isSetStartRow();
    boolean that_present_startRow = true && that.isSetStartRow();
    if (this_present_startRow || that_present_startRow) {
      if (!(this_present_startRow && that_present_startRow))
        return false;
      if (!this.startRow.equals(that.startRow))
        return false;
    }

    boolean this_present_stopRow = true && this.isSetStopRow();
    boolean that_present_stopRow = true && that.isSetStopRow();
    if (this_present_stopRow || that_present_stopRow) {
      if (!(this_present_stopRow && that_present_stopRow))
        return false;
      if (!this.stopRow.equals(that.stopRow))
        return false;
    }

    boolean this_present_columns = true && this.isSetColumns();
    boolean that_present_columns = true && that.isSetColumns();
    if (this_present_columns || that_present_columns) {
      if (!(this_present_columns && that_present_columns))
        return false;
      if (!this.columns.equals(that.columns))
        return false;
    }

    boolean this_present_caching = true && this.isSetCaching();
    boolean that_present_caching = true && that.isSetCaching();
    if (this_present_caching || that_present_caching) {
      if (!(this_present_caching && that_present_caching))
        return false;
      if (this.caching != that.caching)
        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_timeRange = true && this.isSetTimeRange();
    boolean that_present_timeRange = true && that.isSetTimeRange();
    if (this_present_timeRange || that_present_timeRange) {
      if (!(this_present_timeRange && that_present_timeRange))
        return false;
      if (!this.timeRange.equals(that.timeRange))
        return false;
    }

    boolean this_present_filterString = true && this.isSetFilterString();
    boolean that_present_filterString = true && that.isSetFilterString();
    if (this_present_filterString || that_present_filterString) {
      if (!(this_present_filterString && that_present_filterString))
        return false;
      if (!this.filterString.equals(that.filterString))
        return false;
    }

    boolean this_present_batchSize = true && this.isSetBatchSize();
    boolean that_present_batchSize = true && that.isSetBatchSize();
    if (this_present_batchSize || that_present_batchSize) {
      if (!(this_present_batchSize && that_present_batchSize))
        return false;
      if (this.batchSize != that.batchSize)
        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_authorizations = true && this.isSetAuthorizations();
    boolean that_present_authorizations = true && that.isSetAuthorizations();
    if (this_present_authorizations || that_present_authorizations) {
      if (!(this_present_authorizations && that_present_authorizations))
        return false;
      if (!this.authorizations.equals(that.authorizations))
        return false;
    }

    boolean this_present_reversed = true && this.isSetReversed();
    boolean that_present_reversed = true && that.isSetReversed();
    if (this_present_reversed || that_present_reversed) {
      if (!(this_present_reversed && that_present_reversed))
        return false;
      if (this.reversed != that.reversed)
        return false;
    }

    boolean this_present_cacheBlocks = true && this.isSetCacheBlocks();
    boolean that_present_cacheBlocks = true && that.isSetCacheBlocks();
    if (this_present_cacheBlocks || that_present_cacheBlocks) {
      if (!(this_present_cacheBlocks && that_present_cacheBlocks))
        return false;
      if (this.cacheBlocks != that.cacheBlocks)
        return false;
    }

    boolean this_present_colFamTimeRangeMap = true && this.isSetColFamTimeRangeMap();
    boolean that_present_colFamTimeRangeMap = true && that.isSetColFamTimeRangeMap();
    if (this_present_colFamTimeRangeMap || that_present_colFamTimeRangeMap) {
      if (!(this_present_colFamTimeRangeMap && that_present_colFamTimeRangeMap))
        return false;
      if (!this.colFamTimeRangeMap.equals(that.colFamTimeRangeMap))
        return false;
    }

    boolean this_present_readType = true && this.isSetReadType();
    boolean that_present_readType = true && that.isSetReadType();
    if (this_present_readType || that_present_readType) {
      if (!(this_present_readType && that_present_readType))
        return false;
      if (!this.readType.equals(that.readType))
        return false;
    }

    boolean this_present_limit = true && this.isSetLimit();
    boolean that_present_limit = true && that.isSetLimit();
    if (this_present_limit || that_present_limit) {
      if (!(this_present_limit && that_present_limit))
        return false;
      if (this.limit != that.limit)
        return false;
    }

    boolean this_present_consistency = true && this.isSetConsistency();
    boolean that_present_consistency = true && that.isSetConsistency();
    if (this_present_consistency || that_present_consistency) {
      if (!(this_present_consistency && that_present_consistency))
        return false;
      if (!this.consistency.equals(that.consistency))
        return false;
    }

    boolean this_present_targetReplicaId = true && this.isSetTargetReplicaId();
    boolean that_present_targetReplicaId = true && that.isSetTargetReplicaId();
    if (this_present_targetReplicaId || that_present_targetReplicaId) {
      if (!(this_present_targetReplicaId && that_present_targetReplicaId))
        return false;
      if (this.targetReplicaId != that.targetReplicaId)
        return false;
    }

    boolean this_present_filterBytes = true && this.isSetFilterBytes();
    boolean that_present_filterBytes = true && that.isSetFilterBytes();
    if (this_present_filterBytes || that_present_filterBytes) {
      if (!(this_present_filterBytes && that_present_filterBytes))
        return false;
      if (!this.filterBytes.equals(that.filterBytes))
        return false;
    }

    return true;
  }

  @Override
  public int hashCode() {
    int hashCode = 1;

    hashCode = hashCode * 8191 + ((isSetStartRow()) ? 131071 : 524287);
    if (isSetStartRow())
      hashCode = hashCode * 8191 + startRow.hashCode();

    hashCode = hashCode * 8191 + ((isSetStopRow()) ? 131071 : 524287);
    if (isSetStopRow())
      hashCode = hashCode * 8191 + stopRow.hashCode();

    hashCode = hashCode * 8191 + ((isSetColumns()) ? 131071 : 524287);
    if (isSetColumns())
      hashCode = hashCode * 8191 + columns.hashCode();

    hashCode = hashCode * 8191 + ((isSetCaching()) ? 131071 : 524287);
    if (isSetCaching())
      hashCode = hashCode * 8191 + caching;

    hashCode = hashCode * 8191 + ((isSetMaxVersions()) ? 131071 : 524287);
    if (isSetMaxVersions())
      hashCode = hashCode * 8191 + maxVersions;

    hashCode = hashCode * 8191 + ((isSetTimeRange()) ? 131071 : 524287);
    if (isSetTimeRange())
      hashCode = hashCode * 8191 + timeRange.hashCode();

    hashCode = hashCode * 8191 + ((isSetFilterString()) ? 131071 : 524287);
    if (isSetFilterString())
      hashCode = hashCode * 8191 + filterString.hashCode();

    hashCode = hashCode * 8191 + ((isSetBatchSize()) ? 131071 : 524287);
    if (isSetBatchSize())
      hashCode = hashCode * 8191 + batchSize;

    hashCode = hashCode * 8191 + ((isSetAttributes()) ? 131071 : 524287);
    if (isSetAttributes())
      hashCode = hashCode * 8191 + attributes.hashCode();

    hashCode = hashCode * 8191 + ((isSetAuthorizations()) ? 131071 : 524287);
    if (isSetAuthorizations())
      hashCode = hashCode * 8191 + authorizations.hashCode();

    hashCode = hashCode * 8191 + ((isSetReversed()) ? 131071 : 524287);
    if (isSetReversed())
      hashCode = hashCode * 8191 + ((reversed) ? 131071 : 524287);

    hashCode = hashCode * 8191 + ((isSetCacheBlocks()) ? 131071 : 524287);
    if (isSetCacheBlocks())
      hashCode = hashCode * 8191 + ((cacheBlocks) ? 131071 : 524287);

    hashCode = hashCode * 8191 + ((isSetColFamTimeRangeMap()) ? 131071 : 524287);
    if (isSetColFamTimeRangeMap())
      hashCode = hashCode * 8191 + colFamTimeRangeMap.hashCode();

    hashCode = hashCode * 8191 + ((isSetReadType()) ? 131071 : 524287);
    if (isSetReadType())
      hashCode = hashCode * 8191 + readType.getValue();

    hashCode = hashCode * 8191 + ((isSetLimit()) ? 131071 : 524287);
    if (isSetLimit())
      hashCode = hashCode * 8191 + limit;

    hashCode = hashCode * 8191 + ((isSetConsistency()) ? 131071 : 524287);
    if (isSetConsistency())
      hashCode = hashCode * 8191 + consistency.getValue();

    hashCode = hashCode * 8191 + ((isSetTargetReplicaId()) ? 131071 : 524287);
    if (isSetTargetReplicaId())
      hashCode = hashCode * 8191 + targetReplicaId;

    hashCode = hashCode * 8191 + ((isSetFilterBytes()) ? 131071 : 524287);
    if (isSetFilterBytes())
      hashCode = hashCode * 8191 + filterBytes.hashCode();

    return hashCode;
  }

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

    int lastComparison = 0;

    lastComparison = java.lang.Boolean.valueOf(isSetStartRow()).compareTo(other.isSetStartRow());
    if (lastComparison != 0) {
      return lastComparison;
    }
    if (isSetStartRow()) {
      lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.startRow, other.startRow);
      if (lastComparison != 0) {
        return lastComparison;
      }
    }
    lastComparison = java.lang.Boolean.valueOf(isSetStopRow()).compareTo(other.isSetStopRow());
    if (lastComparison != 0) {
      return lastComparison;
    }
    if (isSetStopRow()) {
      lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.stopRow, other.stopRow);
      if (lastComparison != 0) {
        return lastComparison;
      }
    }
    lastComparison = java.lang.Boolean.valueOf(isSetColumns()).compareTo(other.isSetColumns());
    if (lastComparison != 0) {
      return lastComparison;
    }
    if (isSetColumns()) {
      lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.columns, other.columns);
      if (lastComparison != 0) {
        return lastComparison;
      }
    }
    lastComparison = java.lang.Boolean.valueOf(isSetCaching()).compareTo(other.isSetCaching());
    if (lastComparison != 0) {
      return lastComparison;
    }
    if (isSetCaching()) {
      lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.caching, other.caching);
      if (lastComparison != 0) {
        return lastComparison;
      }
    }
    lastComparison = java.lang.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 = java.lang.Boolean.valueOf(isSetTimeRange()).compareTo(other.isSetTimeRange());
    if (lastComparison != 0) {
      return lastComparison;
    }
    if (isSetTimeRange()) {
      lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.timeRange, other.timeRange);
      if (lastComparison != 0) {
        return lastComparison;
      }
    }
    lastComparison = java.lang.Boolean.valueOf(isSetFilterString()).compareTo(other.isSetFilterString());
    if (lastComparison != 0) {
      return lastComparison;
    }
    if (isSetFilterString()) {
      lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.filterString, other.filterString);
      if (lastComparison != 0) {
        return lastComparison;
      }
    }
    lastComparison = java.lang.Boolean.valueOf(isSetBatchSize()).compareTo(other.isSetBatchSize());
    if (lastComparison != 0) {
      return lastComparison;
    }
    if (isSetBatchSize()) {
      lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.batchSize, other.batchSize);
      if (lastComparison != 0) {
        return lastComparison;
      }
    }
    lastComparison = java.lang.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 = java.lang.Boolean.valueOf(isSetAuthorizations()).compareTo(other.isSetAuthorizations());
    if (lastComparison != 0) {
      return lastComparison;
    }
    if (isSetAuthorizations()) {
      lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.authorizations, other.authorizations);
      if (lastComparison != 0) {
        return lastComparison;
      }
    }
    lastComparison = java.lang.Boolean.valueOf(isSetReversed()).compareTo(other.isSetReversed());
    if (lastComparison != 0) {
      return lastComparison;
    }
    if (isSetReversed()) {
      lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.reversed, other.reversed);
      if (lastComparison != 0) {
        return lastComparison;
      }
    }
    lastComparison = java.lang.Boolean.valueOf(isSetCacheBlocks()).compareTo(other.isSetCacheBlocks());
    if (lastComparison != 0) {
      return lastComparison;
    }
    if (isSetCacheBlocks()) {
      lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.cacheBlocks, other.cacheBlocks);
      if (lastComparison != 0) {
        return lastComparison;
      }
    }
    lastComparison = java.lang.Boolean.valueOf(isSetColFamTimeRangeMap()).compareTo(other.isSetColFamTimeRangeMap());
    if (lastComparison != 0) {
      return lastComparison;
    }
    if (isSetColFamTimeRangeMap()) {
      lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.colFamTimeRangeMap, other.colFamTimeRangeMap);
      if (lastComparison != 0) {
        return lastComparison;
      }
    }
    lastComparison = java.lang.Boolean.valueOf(isSetReadType()).compareTo(other.isSetReadType());
    if (lastComparison != 0) {
      return lastComparison;
    }
    if (isSetReadType()) {
      lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.readType, other.readType);
      if (lastComparison != 0) {
        return lastComparison;
      }
    }
    lastComparison = java.lang.Boolean.valueOf(isSetLimit()).compareTo(other.isSetLimit());
    if (lastComparison != 0) {
      return lastComparison;
    }
    if (isSetLimit()) {
      lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.limit, other.limit);
      if (lastComparison != 0) {
        return lastComparison;
      }
    }
    lastComparison = java.lang.Boolean.valueOf(isSetConsistency()).compareTo(other.isSetConsistency());
    if (lastComparison != 0) {
      return lastComparison;
    }
    if (isSetConsistency()) {
      lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.consistency, other.consistency);
      if (lastComparison != 0) {
        return lastComparison;
      }
    }
    lastComparison = java.lang.Boolean.valueOf(isSetTargetReplicaId()).compareTo(other.isSetTargetReplicaId());
    if (lastComparison != 0) {
      return lastComparison;
    }
    if (isSetTargetReplicaId()) {
      lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.targetReplicaId, other.targetReplicaId);
      if (lastComparison != 0) {
        return lastComparison;
      }
    }
    lastComparison = java.lang.Boolean.valueOf(isSetFilterBytes()).compareTo(other.isSetFilterBytes());
    if (lastComparison != 0) {
      return lastComparison;
    }
    if (isSetFilterBytes()) {
      lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.filterBytes, other.filterBytes);
      if (lastComparison != 0) {
        return lastComparison;
      }
    }
    return 0;
  }

  @org.apache.thrift.annotation.Nullable
  public _Fields fieldForId(int fieldId) {
    return _Fields.findByThriftId(fieldId);
  }

  public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException {
    scheme(iprot).read(iprot, this);
  }

  public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException {
    scheme(oprot).write(oprot, this);
  }

  @Override
  public java.lang.String toString() {
    java.lang.StringBuilder sb = new java.lang.StringBuilder("TScan(");
    boolean first = true;

    if (isSetStartRow()) {
      sb.append("startRow:");
      if (this.startRow == null) {
        sb.append("null");
      } else {
        org.apache.thrift.TBaseHelper.toString(this.startRow, sb);
      }
      first = false;
    }
    if (isSetStopRow()) {
      if (!first) sb.append(", ");
      sb.append("stopRow:");
      if (this.stopRow == null) {
        sb.append("null");
      } else {
        org.apache.thrift.TBaseHelper.toString(this.stopRow, sb);
      }
      first = false;
    }
    if (isSetColumns()) {
      if (!first) sb.append(", ");
      sb.append("columns:");
      if (this.columns == null) {
        sb.append("null");
      } else {
        sb.append(this.columns);
      }
      first = false;
    }
    if (isSetCaching()) {
      if (!first) sb.append(", ");
      sb.append("caching:");
      sb.append(this.caching);
      first = false;
    }
    if (isSetMaxVersions()) {
      if (!first) sb.append(", ");
      sb.append("maxVersions:");
      sb.append(this.maxVersions);
      first = false;
    }
    if (isSetTimeRange()) {
      if (!first) sb.append(", ");
      sb.append("timeRange:");
      if (this.timeRange == null) {
        sb.append("null");
      } else {
        sb.append(this.timeRange);
      }
      first = false;
    }
    if (isSetFilterString()) {
      if (!first) sb.append(", ");
      sb.append("filterString:");
      if (this.filterString == null) {
        sb.append("null");
      } else {
        org.apache.thrift.TBaseHelper.toString(this.filterString, sb);
      }
      first = false;
    }
    if (isSetBatchSize()) {
      if (!first) sb.append(", ");
      sb.append("batchSize:");
      sb.append(this.batchSize);
      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 (isSetAuthorizations()) {
      if (!first) sb.append(", ");
      sb.append("authorizations:");
      if (this.authorizations == null) {
        sb.append("null");
      } else {
        sb.append(this.authorizations);
      }
      first = false;
    }
    if (isSetReversed()) {
      if (!first) sb.append(", ");
      sb.append("reversed:");
      sb.append(this.reversed);
      first = false;
    }
    if (isSetCacheBlocks()) {
      if (!first) sb.append(", ");
      sb.append("cacheBlocks:");
      sb.append(this.cacheBlocks);
      first = false;
    }
    if (isSetColFamTimeRangeMap()) {
      if (!first) sb.append(", ");
      sb.append("colFamTimeRangeMap:");
      if (this.colFamTimeRangeMap == null) {
        sb.append("null");
      } else {
        sb.append(this.colFamTimeRangeMap);
      }
      first = false;
    }
    if (isSetReadType()) {
      if (!first) sb.append(", ");
      sb.append("readType:");
      if (this.readType == null) {
        sb.append("null");
      } else {
        sb.append(this.readType);
      }
      first = false;
    }
    if (isSetLimit()) {
      if (!first) sb.append(", ");
      sb.append("limit:");
      sb.append(this.limit);
      first = false;
    }
    if (isSetConsistency()) {
      if (!first) sb.append(", ");
      sb.append("consistency:");
      if (this.consistency == null) {
        sb.append("null");
      } else {
        sb.append(this.consistency);
      }
      first = false;
    }
    if (isSetTargetReplicaId()) {
      if (!first) sb.append(", ");
      sb.append("targetReplicaId:");
      sb.append(this.targetReplicaId);
      first = false;
    }
    if (isSetFilterBytes()) {
      if (!first) sb.append(", ");
      sb.append("filterBytes:");
      if (this.filterBytes == null) {
        sb.append("null");
      } else {
        org.apache.thrift.TBaseHelper.toString(this.filterBytes, sb);
      }
      first = false;
    }
    sb.append(")");
    return sb.toString();
  }

  public void validate() throws org.apache.thrift.TException {
    // check for required fields
    // check for sub-struct validity
    if (timeRange != null) {
      timeRange.validate();
    }
    if (authorizations != null) {
      authorizations.validate();
    }
  }

  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, java.lang.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 TScanStandardSchemeFactory implements org.apache.thrift.scheme.SchemeFactory {
    public TScanStandardScheme getScheme() {
      return new TScanStandardScheme();
    }
  }

  private static class TScanStandardScheme extends org.apache.thrift.scheme.StandardScheme<TScan> {

    public void read(org.apache.thrift.protocol.TProtocol iprot, TScan 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: // START_ROW
            if (schemeField.type == org.apache.thrift.protocol.TType.STRING) {
              struct.startRow = iprot.readBinary();
              struct.setStartRowIsSet(true);
            } else { 
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
            }
            break;
          case 2: // STOP_ROW
            if (schemeField.type == org.apache.thrift.protocol.TType.STRING) {
              struct.stopRow = iprot.readBinary();
              struct.setStopRowIsSet(true);
            } else { 
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
            }
            break;
          case 3: // COLUMNS
            if (schemeField.type == org.apache.thrift.protocol.TType.LIST) {
              {
                org.apache.thrift.protocol.TList _list106 = iprot.readListBegin();
                struct.columns = new java.util.ArrayList<TColumn>(_list106.size);
                @org.apache.thrift.annotation.Nullable TColumn _elem107;
                for (int _i108 = 0; _i108 < _list106.size; ++_i108)
                {
                  _elem107 = new TColumn();
                  _elem107.read(iprot);
                  struct.columns.add(_elem107);
                }
                iprot.readListEnd();
              }
              struct.setColumnsIsSet(true);
            } else { 
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
            }
            break;
          case 4: // CACHING
            if (schemeField.type == org.apache.thrift.protocol.TType.I32) {
              struct.caching = iprot.readI32();
              struct.setCachingIsSet(true);
            } else { 
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
            }
            break;
          case 5: // 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 6: // TIME_RANGE
            if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) {
              struct.timeRange = new TTimeRange();
              struct.timeRange.read(iprot);
              struct.setTimeRangeIsSet(true);
            } else { 
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
            }
            break;
          case 7: // FILTER_STRING
            if (schemeField.type == org.apache.thrift.protocol.TType.STRING) {
              struct.filterString = iprot.readBinary();
              struct.setFilterStringIsSet(true);
            } else { 
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
            }
            break;
          case 8: // BATCH_SIZE
            if (schemeField.type == org.apache.thrift.protocol.TType.I32) {
              struct.batchSize = iprot.readI32();
              struct.setBatchSizeIsSet(true);
            } else { 
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
            }
            break;
          case 9: // ATTRIBUTES
            if (schemeField.type == org.apache.thrift.protocol.TType.MAP) {
              {
                org.apache.thrift.protocol.TMap _map109 = iprot.readMapBegin();
                struct.attributes = new java.util.HashMap<java.nio.ByteBuffer,java.nio.ByteBuffer>(2*_map109.size);
                @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer _key110;
                @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer _val111;
                for (int _i112 = 0; _i112 < _map109.size; ++_i112)
                {
                  _key110 = iprot.readBinary();
                  _val111 = iprot.readBinary();
                  struct.attributes.put(_key110, _val111);
                }
                iprot.readMapEnd();
              }
              struct.setAttributesIsSet(true);
            } else { 
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
            }
            break;
          case 10: // AUTHORIZATIONS
            if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) {
              struct.authorizations = new TAuthorization();
              struct.authorizations.read(iprot);
              struct.setAuthorizationsIsSet(true);
            } else { 
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
            }
            break;
          case 11: // REVERSED
            if (schemeField.type == org.apache.thrift.protocol.TType.BOOL) {
              struct.reversed = iprot.readBool();
              struct.setReversedIsSet(true);
            } else { 
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
            }
            break;
          case 12: // CACHE_BLOCKS
            if (schemeField.type == org.apache.thrift.protocol.TType.BOOL) {
              struct.cacheBlocks = iprot.readBool();
              struct.setCacheBlocksIsSet(true);
            } else { 
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
            }
            break;
          case 13: // COL_FAM_TIME_RANGE_MAP
            if (schemeField.type == org.apache.thrift.protocol.TType.MAP) {
              {
                org.apache.thrift.protocol.TMap _map113 = iprot.readMapBegin();
                struct.colFamTimeRangeMap = new java.util.HashMap<java.nio.ByteBuffer,TTimeRange>(2*_map113.size);
                @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer _key114;
                @org.apache.thrift.annotation.Nullable TTimeRange _val115;
                for (int _i116 = 0; _i116 < _map113.size; ++_i116)
                {
                  _key114 = iprot.readBinary();
                  _val115 = new TTimeRange();
                  _val115.read(iprot);
                  struct.colFamTimeRangeMap.put(_key114, _val115);
                }
                iprot.readMapEnd();
              }
              struct.setColFamTimeRangeMapIsSet(true);
            } else { 
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
            }
            break;
          case 14: // READ_TYPE
            if (schemeField.type == org.apache.thrift.protocol.TType.I32) {
              struct.readType = org.apache.hadoop.hbase.thrift2.generated.TReadType.findByValue(iprot.readI32());
              struct.setReadTypeIsSet(true);
            } else { 
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
            }
            break;
          case 15: // LIMIT
            if (schemeField.type == org.apache.thrift.protocol.TType.I32) {
              struct.limit = iprot.readI32();
              struct.setLimitIsSet(true);
            } else { 
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
            }
            break;
          case 16: // CONSISTENCY
            if (schemeField.type == org.apache.thrift.protocol.TType.I32) {
              struct.consistency = org.apache.hadoop.hbase.thrift2.generated.TConsistency.findByValue(iprot.readI32());
              struct.setConsistencyIsSet(true);
            } else { 
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
            }
            break;
          case 17: // TARGET_REPLICA_ID
            if (schemeField.type == org.apache.thrift.protocol.TType.I32) {
              struct.targetReplicaId = iprot.readI32();
              struct.setTargetReplicaIdIsSet(true);
            } else { 
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
            }
            break;
          case 18: // FILTER_BYTES
            if (schemeField.type == org.apache.thrift.protocol.TType.STRING) {
              struct.filterBytes = iprot.readBinary();
              struct.setFilterBytesIsSet(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, TScan struct) throws org.apache.thrift.TException {
      struct.validate();

      oprot.writeStructBegin(STRUCT_DESC);
      if (struct.startRow != null) {
        if (struct.isSetStartRow()) {
          oprot.writeFieldBegin(START_ROW_FIELD_DESC);
          oprot.writeBinary(struct.startRow);
          oprot.writeFieldEnd();
        }
      }
      if (struct.stopRow != null) {
        if (struct.isSetStopRow()) {
          oprot.writeFieldBegin(STOP_ROW_FIELD_DESC);
          oprot.writeBinary(struct.stopRow);
          oprot.writeFieldEnd();
        }
      }
      if (struct.columns != null) {
        if (struct.isSetColumns()) {
          oprot.writeFieldBegin(COLUMNS_FIELD_DESC);
          {
            oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, struct.columns.size()));
            for (TColumn _iter117 : struct.columns)
            {
              _iter117.write(oprot);
            }
            oprot.writeListEnd();
          }
          oprot.writeFieldEnd();
        }
      }
      if (struct.isSetCaching()) {
        oprot.writeFieldBegin(CACHING_FIELD_DESC);
        oprot.writeI32(struct.caching);
        oprot.writeFieldEnd();
      }
      if (struct.isSetMaxVersions()) {
        oprot.writeFieldBegin(MAX_VERSIONS_FIELD_DESC);
        oprot.writeI32(struct.maxVersions);
        oprot.writeFieldEnd();
      }
      if (struct.timeRange != null) {
        if (struct.isSetTimeRange()) {
          oprot.writeFieldBegin(TIME_RANGE_FIELD_DESC);
          struct.timeRange.write(oprot);
          oprot.writeFieldEnd();
        }
      }
      if (struct.filterString != null) {
        if (struct.isSetFilterString()) {
          oprot.writeFieldBegin(FILTER_STRING_FIELD_DESC);
          oprot.writeBinary(struct.filterString);
          oprot.writeFieldEnd();
        }
      }
      if (struct.isSetBatchSize()) {
        oprot.writeFieldBegin(BATCH_SIZE_FIELD_DESC);
        oprot.writeI32(struct.batchSize);
        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 (java.util.Map.Entry<java.nio.ByteBuffer, java.nio.ByteBuffer> _iter118 : struct.attributes.entrySet())
            {
              oprot.writeBinary(_iter118.getKey());
              oprot.writeBinary(_iter118.getValue());
            }
            oprot.writeMapEnd();
          }
          oprot.writeFieldEnd();
        }
      }
      if (struct.authorizations != null) {
        if (struct.isSetAuthorizations()) {
          oprot.writeFieldBegin(AUTHORIZATIONS_FIELD_DESC);
          struct.authorizations.write(oprot);
          oprot.writeFieldEnd();
        }
      }
      if (struct.isSetReversed()) {
        oprot.writeFieldBegin(REVERSED_FIELD_DESC);
        oprot.writeBool(struct.reversed);
        oprot.writeFieldEnd();
      }
      if (struct.isSetCacheBlocks()) {
        oprot.writeFieldBegin(CACHE_BLOCKS_FIELD_DESC);
        oprot.writeBool(struct.cacheBlocks);
        oprot.writeFieldEnd();
      }
      if (struct.colFamTimeRangeMap != null) {
        if (struct.isSetColFamTimeRangeMap()) {
          oprot.writeFieldBegin(COL_FAM_TIME_RANGE_MAP_FIELD_DESC);
          {
            oprot.writeMapBegin(new org.apache.thrift.protocol.TMap(org.apache.thrift.protocol.TType.STRING, org.apache.thrift.protocol.TType.STRUCT, struct.colFamTimeRangeMap.size()));
            for (java.util.Map.Entry<java.nio.ByteBuffer, TTimeRange> _iter119 : struct.colFamTimeRangeMap.entrySet())
            {
              oprot.writeBinary(_iter119.getKey());
              _iter119.getValue().write(oprot);
            }
            oprot.writeMapEnd();
          }
          oprot.writeFieldEnd();
        }
      }
      if (struct.readType != null) {
        if (struct.isSetReadType()) {
          oprot.writeFieldBegin(READ_TYPE_FIELD_DESC);
          oprot.writeI32(struct.readType.getValue());
          oprot.writeFieldEnd();
        }
      }
      if (struct.isSetLimit()) {
        oprot.writeFieldBegin(LIMIT_FIELD_DESC);
        oprot.writeI32(struct.limit);
        oprot.writeFieldEnd();
      }
      if (struct.consistency != null) {
        if (struct.isSetConsistency()) {
          oprot.writeFieldBegin(CONSISTENCY_FIELD_DESC);
          oprot.writeI32(struct.consistency.getValue());
          oprot.writeFieldEnd();
        }
      }
      if (struct.isSetTargetReplicaId()) {
        oprot.writeFieldBegin(TARGET_REPLICA_ID_FIELD_DESC);
        oprot.writeI32(struct.targetReplicaId);
        oprot.writeFieldEnd();
      }
      if (struct.filterBytes != null) {
        if (struct.isSetFilterBytes()) {
          oprot.writeFieldBegin(FILTER_BYTES_FIELD_DESC);
          oprot.writeBinary(struct.filterBytes);
          oprot.writeFieldEnd();
        }
      }
      oprot.writeFieldStop();
      oprot.writeStructEnd();
    }

  }

  private static class TScanTupleSchemeFactory implements org.apache.thrift.scheme.SchemeFactory {
    public TScanTupleScheme getScheme() {
      return new TScanTupleScheme();
    }
  }

  private static class TScanTupleScheme extends org.apache.thrift.scheme.TupleScheme<TScan> {

    @Override
    public void write(org.apache.thrift.protocol.TProtocol prot, TScan struct) throws org.apache.thrift.TException {
      org.apache.thrift.protocol.TTupleProtocol oprot = (org.apache.thrift.protocol.TTupleProtocol) prot;
      java.util.BitSet optionals = new java.util.BitSet();
      if (struct.isSetStartRow()) {
        optionals.set(0);
      }
      if (struct.isSetStopRow()) {
        optionals.set(1);
      }
      if (struct.isSetColumns()) {
        optionals.set(2);
      }
      if (struct.isSetCaching()) {
        optionals.set(3);
      }
      if (struct.isSetMaxVersions()) {
        optionals.set(4);
      }
      if (struct.isSetTimeRange()) {
        optionals.set(5);
      }
      if (struct.isSetFilterString()) {
        optionals.set(6);
      }
      if (struct.isSetBatchSize()) {
        optionals.set(7);
      }
      if (struct.isSetAttributes()) {
        optionals.set(8);
      }
      if (struct.isSetAuthorizations()) {
        optionals.set(9);
      }
      if (struct.isSetReversed()) {
        optionals.set(10);
      }
      if (struct.isSetCacheBlocks()) {
        optionals.set(11);
      }
      if (struct.isSetColFamTimeRangeMap()) {
        optionals.set(12);
      }
      if (struct.isSetReadType()) {
        optionals.set(13);
      }
      if (struct.isSetLimit()) {
        optionals.set(14);
      }
      if (struct.isSetConsistency()) {
        optionals.set(15);
      }
      if (struct.isSetTargetReplicaId()) {
        optionals.set(16);
      }
      if (struct.isSetFilterBytes()) {
        optionals.set(17);
      }
      oprot.writeBitSet(optionals, 18);
      if (struct.isSetStartRow()) {
        oprot.writeBinary(struct.startRow);
      }
      if (struct.isSetStopRow()) {
        oprot.writeBinary(struct.stopRow);
      }
      if (struct.isSetColumns()) {
        {
          oprot.writeI32(struct.columns.size());
          for (TColumn _iter120 : struct.columns)
          {
            _iter120.write(oprot);
          }
        }
      }
      if (struct.isSetCaching()) {
        oprot.writeI32(struct.caching);
      }
      if (struct.isSetMaxVersions()) {
        oprot.writeI32(struct.maxVersions);
      }
      if (struct.isSetTimeRange()) {
        struct.timeRange.write(oprot);
      }
      if (struct.isSetFilterString()) {
        oprot.writeBinary(struct.filterString);
      }
      if (struct.isSetBatchSize()) {
        oprot.writeI32(struct.batchSize);
      }
      if (struct.isSetAttributes()) {
        {
          oprot.writeI32(struct.attributes.size());
          for (java.util.Map.Entry<java.nio.ByteBuffer, java.nio.ByteBuffer> _iter121 : struct.attributes.entrySet())
          {
            oprot.writeBinary(_iter121.getKey());
            oprot.writeBinary(_iter121.getValue());
          }
        }
      }
      if (struct.isSetAuthorizations()) {
        struct.authorizations.write(oprot);
      }
      if (struct.isSetReversed()) {
        oprot.writeBool(struct.reversed);
      }
      if (struct.isSetCacheBlocks()) {
        oprot.writeBool(struct.cacheBlocks);
      }
      if (struct.isSetColFamTimeRangeMap()) {
        {
          oprot.writeI32(struct.colFamTimeRangeMap.size());
          for (java.util.Map.Entry<java.nio.ByteBuffer, TTimeRange> _iter122 : struct.colFamTimeRangeMap.entrySet())
          {
            oprot.writeBinary(_iter122.getKey());
            _iter122.getValue().write(oprot);
          }
        }
      }
      if (struct.isSetReadType()) {
        oprot.writeI32(struct.readType.getValue());
      }
      if (struct.isSetLimit()) {
        oprot.writeI32(struct.limit);
      }
      if (struct.isSetConsistency()) {
        oprot.writeI32(struct.consistency.getValue());
      }
      if (struct.isSetTargetReplicaId()) {
        oprot.writeI32(struct.targetReplicaId);
      }
      if (struct.isSetFilterBytes()) {
        oprot.writeBinary(struct.filterBytes);
      }
    }

    @Override
    public void read(org.apache.thrift.protocol.TProtocol prot, TScan struct) throws org.apache.thrift.TException {
      org.apache.thrift.protocol.TTupleProtocol iprot = (org.apache.thrift.protocol.TTupleProtocol) prot;
      java.util.BitSet incoming = iprot.readBitSet(18);
      if (incoming.get(0)) {
        struct.startRow = iprot.readBinary();
        struct.setStartRowIsSet(true);
      }
      if (incoming.get(1)) {
        struct.stopRow = iprot.readBinary();
        struct.setStopRowIsSet(true);
      }
      if (incoming.get(2)) {
        {
          org.apache.thrift.protocol.TList _list123 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, iprot.readI32());
          struct.columns = new java.util.ArrayList<TColumn>(_list123.size);
          @org.apache.thrift.annotation.Nullable TColumn _elem124;
          for (int _i125 = 0; _i125 < _list123.size; ++_i125)
          {
            _elem124 = new TColumn();
            _elem124.read(iprot);
            struct.columns.add(_elem124);
          }
        }
        struct.setColumnsIsSet(true);
      }
      if (incoming.get(3)) {
        struct.caching = iprot.readI32();
        struct.setCachingIsSet(true);
      }
      if (incoming.get(4)) {
        struct.maxVersions = iprot.readI32();
        struct.setMaxVersionsIsSet(true);
      }
      if (incoming.get(5)) {
        struct.timeRange = new TTimeRange();
        struct.timeRange.read(iprot);
        struct.setTimeRangeIsSet(true);
      }
      if (incoming.get(6)) {
        struct.filterString = iprot.readBinary();
        struct.setFilterStringIsSet(true);
      }
      if (incoming.get(7)) {
        struct.batchSize = iprot.readI32();
        struct.setBatchSizeIsSet(true);
      }
      if (incoming.get(8)) {
        {
          org.apache.thrift.protocol.TMap _map126 = new org.apache.thrift.protocol.TMap(org.apache.thrift.protocol.TType.STRING, org.apache.thrift.protocol.TType.STRING, iprot.readI32());
          struct.attributes = new java.util.HashMap<java.nio.ByteBuffer,java.nio.ByteBuffer>(2*_map126.size);
          @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer _key127;
          @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer _val128;
          for (int _i129 = 0; _i129 < _map126.size; ++_i129)
          {
            _key127 = iprot.readBinary();
            _val128 = iprot.readBinary();
            struct.attributes.put(_key127, _val128);
          }
        }
        struct.setAttributesIsSet(true);
      }
      if (incoming.get(9)) {
        struct.authorizations = new TAuthorization();
        struct.authorizations.read(iprot);
        struct.setAuthorizationsIsSet(true);
      }
      if (incoming.get(10)) {
        struct.reversed = iprot.readBool();
        struct.setReversedIsSet(true);
      }
      if (incoming.get(11)) {
        struct.cacheBlocks = iprot.readBool();
        struct.setCacheBlocksIsSet(true);
      }
      if (incoming.get(12)) {
        {
          org.apache.thrift.protocol.TMap _map130 = new org.apache.thrift.protocol.TMap(org.apache.thrift.protocol.TType.STRING, org.apache.thrift.protocol.TType.STRUCT, iprot.readI32());
          struct.colFamTimeRangeMap = new java.util.HashMap<java.nio.ByteBuffer,TTimeRange>(2*_map130.size);
          @org.apache.thrift.annotation.Nullable java.nio.ByteBuffer _key131;
          @org.apache.thrift.annotation.Nullable TTimeRange _val132;
          for (int _i133 = 0; _i133 < _map130.size; ++_i133)
          {
            _key131 = iprot.readBinary();
            _val132 = new TTimeRange();
            _val132.read(iprot);
            struct.colFamTimeRangeMap.put(_key131, _val132);
          }
        }
        struct.setColFamTimeRangeMapIsSet(true);
      }
      if (incoming.get(13)) {
        struct.readType = org.apache.hadoop.hbase.thrift2.generated.TReadType.findByValue(iprot.readI32());
        struct.setReadTypeIsSet(true);
      }
      if (incoming.get(14)) {
        struct.limit = iprot.readI32();
        struct.setLimitIsSet(true);
      }
      if (incoming.get(15)) {
        struct.consistency = org.apache.hadoop.hbase.thrift2.generated.TConsistency.findByValue(iprot.readI32());
        struct.setConsistencyIsSet(true);
      }
      if (incoming.get(16)) {
        struct.targetReplicaId = iprot.readI32();
        struct.setTargetReplicaIdIsSet(true);
      }
      if (incoming.get(17)) {
        struct.filterBytes = iprot.readBinary();
        struct.setFilterBytesIsSet(true);
      }
    }
  }

  private static <S extends org.apache.thrift.scheme.IScheme> S scheme(org.apache.thrift.protocol.TProtocol proto) {
    return (org.apache.thrift.scheme.StandardScheme.class.equals(proto.getScheme()) ? STANDARD_SCHEME_FACTORY : TUPLE_SCHEME_FACTORY).getScheme();
  }
}

