/**
    * Autogenerated by Thrift Compiler (0.9.0)
    *
    * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
    *  @generated
    */
   package org.apache.hadoop.hbase.thrift.generated;
   
   import org.apache.commons.lang.builder.HashCodeBuilder;
  import org.apache.thrift.scheme.IScheme;
  import org.apache.thrift.scheme.SchemeFactory;
  import org.apache.thrift.scheme.StandardScheme;
  
  import org.apache.thrift.scheme.TupleScheme;
  import org.apache.thrift.protocol.TTupleProtocol;
  import org.apache.thrift.protocol.TProtocolException;
  import org.apache.thrift.EncodingUtils;
  import org.apache.thrift.TException;
  import java.util.List;
  import java.util.ArrayList;
  import java.util.Map;
  import java.util.HashMap;
  import java.util.EnumMap;
  import java.util.Set;
  import java.util.HashSet;
  import java.util.EnumSet;
  import java.util.Collections;
  import java.util.BitSet;
  import java.nio.ByteBuffer;
  import java.util.Arrays;
  import org.slf4j.Logger;
  import org.slf4j.LoggerFactory;
  
  /**
   * TCell - Used to transport a cell value (byte[]) and the timestamp it was
   * stored with together as a result for get and getRow methods. This promotes
   * the timestamp of a cell to a first-class value, making it easy to take
   * note of temporal data. Cell is used all the way from HStore up to HTable.
   */
  public class TCell implements org.apache.thrift.TBase<TCell, TCell._Fields>, java.io.Serializable, Cloneable {
    private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("TCell");
  
    private static final org.apache.thrift.protocol.TField VALUE_FIELD_DESC = new org.apache.thrift.protocol.TField("value", org.apache.thrift.protocol.TType.STRING, (short)1);
    private static final org.apache.thrift.protocol.TField TIMESTAMP_FIELD_DESC = new org.apache.thrift.protocol.TField("timestamp", org.apache.thrift.protocol.TType.I64, (short)2);
  
    private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>();
    static {
      schemes.put(StandardScheme.class, new TCellStandardSchemeFactory());
      schemes.put(TupleScheme.class, new TCellTupleSchemeFactory());
    }
  
    public ByteBuffer value; // required
    public long timestamp; // required
  
    /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
    public enum _Fields implements org.apache.thrift.TFieldIdEnum {
      VALUE((short)1, "value"),
      TIMESTAMP((short)2, "timestamp");
  
      private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();
  
      static {
        for (_Fields field : EnumSet.allOf(_Fields.class)) {
          byName.put(field.getFieldName(), field);
        }
      }
  
      /**
       * Find the _Fields constant that matches fieldId, or null if its not found.
       */
      public static _Fields findByThriftId(int fieldId) {
        switch(fieldId) {
          case 1: // VALUE
            return VALUE;
          case 2: // TIMESTAMP
            return TIMESTAMP;
          default:
            return null;
        }
      }
  
      /**
       * Find the _Fields constant that matches fieldId, throwing an exception
       * if it is not found.
       */
      public static _Fields findByThriftIdOrThrow(int fieldId) {
        _Fields fields = findByThriftId(fieldId);
        if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
        return fields;
      }
  
      /**
       * Find the _Fields constant that matches name, or null if its not found.
       */
      public static _Fields findByName(String name) {
        return byName.get(name);
      }
  
      private final short _thriftId;
     private final String _fieldName;
 
     _Fields(short thriftId, String fieldName) {
       _thriftId = thriftId;
       _fieldName = fieldName;
     }
 
     public short getThriftFieldId() {
       return _thriftId;
     }
 
     public String getFieldName() {
       return _fieldName;
     }
   }
 
   // isset id assignments
   private static final int __TIMESTAMP_ISSET_ID = 0;
   private byte __isset_bitfield = 0;
   public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap;
   static {
     Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class);
     tmpMap.put(_Fields.VALUE, new org.apache.thrift.meta_data.FieldMetaData("value", org.apache.thrift.TFieldRequirementType.DEFAULT, 
         new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING        , "Bytes")));
     tmpMap.put(_Fields.TIMESTAMP, new org.apache.thrift.meta_data.FieldMetaData("timestamp", org.apache.thrift.TFieldRequirementType.DEFAULT, 
         new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.I64)));
     metaDataMap = Collections.unmodifiableMap(tmpMap);
     org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(TCell.class, metaDataMap);
   }
 
   public TCell() {
   }
 
   public TCell(
     ByteBuffer value,
     long timestamp)
   {
     this();
     this.value = value;
     this.timestamp = timestamp;
     setTimestampIsSet(true);
   }
 
   /**
    * Performs a deep copy on <i>other</i>.
    */
   public TCell(TCell other) {
     __isset_bitfield = other.__isset_bitfield;
     if (other.isSetValue()) {
       this.value = other.value;
     }
     this.timestamp = other.timestamp;
   }
 
   public TCell deepCopy() {
     return new TCell(this);
   }
 
   @Override
   public void clear() {
     this.value = null;
     setTimestampIsSet(false);
     this.timestamp = 0;
   }
 
   public byte[] getValue() {
     setValue(org.apache.thrift.TBaseHelper.rightSize(value));
     return value == null ? null : value.array();
   }
 
   public ByteBuffer bufferForValue() {
     return value;
   }
 
   public TCell setValue(byte[] value) {
     setValue(value == null ? (ByteBuffer)null : ByteBuffer.wrap(value));
     return this;
   }
 
   public TCell setValue(ByteBuffer value) {
     this.value = value;
     return this;
   }
 
   public void unsetValue() {
     this.value = null;
   }
 
   /** Returns true if field value is set (has been assigned a value) and false otherwise */
   public boolean isSetValue() {
     return this.value != null;
   }
 
   public void setValueIsSet(boolean value) {
     if (!value) {
       this.value = null;
     }
   }
 
   public long getTimestamp() {
     return this.timestamp;
   }
 
   public TCell setTimestamp(long timestamp) {
     this.timestamp = timestamp;
     setTimestampIsSet(true);
     return this;
   }
 
   public void unsetTimestamp() {
     __isset_bitfield = EncodingUtils.clearBit(__isset_bitfield, __TIMESTAMP_ISSET_ID);
   }
 
   /** Returns true if field timestamp is set (has been assigned a value) and false otherwise */
   public boolean isSetTimestamp() {
     return EncodingUtils.testBit(__isset_bitfield, __TIMESTAMP_ISSET_ID);
   }
 
   public void setTimestampIsSet(boolean value) {
     __isset_bitfield = EncodingUtils.setBit(__isset_bitfield, __TIMESTAMP_ISSET_ID, value);
   }
 
   public void setFieldValue(_Fields field, Object value) {
     switch (field) {
     case VALUE:
       if (value == null) {
         unsetValue();
       } else {
         setValue((ByteBuffer)value);
       }
       break;
 
     case TIMESTAMP:
       if (value == null) {
         unsetTimestamp();
       } else {
         setTimestamp((Long)value);
       }
       break;
 
     }
   }
 
   public Object getFieldValue(_Fields field) {
     switch (field) {
     case VALUE:
       return getValue();
 
     case TIMESTAMP:
       return Long.valueOf(getTimestamp());
 
     }
     throw new IllegalStateException();
   }
 
   /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */
   public boolean isSet(_Fields field) {
     if (field == null) {
       throw new IllegalArgumentException();
     }
 
     switch (field) {
     case VALUE:
       return isSetValue();
     case TIMESTAMP:
       return isSetTimestamp();
     }
     throw new IllegalStateException();
   }
 
   @Override
   public boolean equals(Object that) {
     if (that == null)
       return false;
     if (that instanceof TCell)
       return this.equals((TCell)that);
     return false;
   }
 
   public boolean equals(TCell that) {
     if (that == null)
       return false;
 
     boolean this_present_value = true && this.isSetValue();
     boolean that_present_value = true && that.isSetValue();
     if (this_present_value || that_present_value) {
       if (!(this_present_value && that_present_value))
         return false;
       if (!this.value.equals(that.value))
         return false;
     }
 
     boolean this_present_timestamp = true;
     boolean that_present_timestamp = true;
     if (this_present_timestamp || that_present_timestamp) {
       if (!(this_present_timestamp && that_present_timestamp))
         return false;
       if (this.timestamp != that.timestamp)
         return false;
     }
 
     return true;
   }
 
   @Override
   public int hashCode() {
     HashCodeBuilder builder = new HashCodeBuilder();
 
     boolean present_value = true && (isSetValue());
     builder.append(present_value);
     if (present_value)
       builder.append(value);
 
     boolean present_timestamp = true;
     builder.append(present_timestamp);
     if (present_timestamp)
       builder.append(timestamp);
 
     return builder.toHashCode();
   }
 
   public int compareTo(TCell other) {
     if (!getClass().equals(other.getClass())) {
       return getClass().getName().compareTo(other.getClass().getName());
     }
 
     int lastComparison = 0;
     TCell typedOther = (TCell)other;
 
     lastComparison = Boolean.valueOf(isSetValue()).compareTo(typedOther.isSetValue());
     if (lastComparison != 0) {
       return lastComparison;
     }
     if (isSetValue()) {
       lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.value, typedOther.value);
       if (lastComparison != 0) {
         return lastComparison;
       }
     }
     lastComparison = Boolean.valueOf(isSetTimestamp()).compareTo(typedOther.isSetTimestamp());
     if (lastComparison != 0) {
       return lastComparison;
     }
     if (isSetTimestamp()) {
       lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.timestamp, typedOther.timestamp);
       if (lastComparison != 0) {
         return lastComparison;
       }
     }
     return 0;
   }
 
   public _Fields fieldForId(int fieldId) {
     return _Fields.findByThriftId(fieldId);
   }
 
   public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException {
     schemes.get(iprot.getScheme()).getScheme().read(iprot, this);
   }
 
   public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException {
     schemes.get(oprot.getScheme()).getScheme().write(oprot, this);
   }
 
   @Override
   public String toString() {
     StringBuilder sb = new StringBuilder("TCell(");
     boolean first = true;
 
     sb.append("value:");
     if (this.value == null) {
       sb.append("null");
     } else {
       sb.append(this.value);
     }
     first = false;
     if (!first) sb.append(", ");
     sb.append("timestamp:");
     sb.append(this.timestamp);
     first = false;
     sb.append(")");
     return sb.toString();
   }
 
   public void validate() throws org.apache.thrift.TException {
     // check for required fields
     // check for sub-struct validity
   }
 
   private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException {
     try {
       write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out)));
     } catch (org.apache.thrift.TException te) {
       throw new java.io.IOException(te);
     }
   }
 
   private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, ClassNotFoundException {
     try {
       // it doesn't seem like you should have to do this, but java serialization is wacky, and doesn't call the default constructor.
       __isset_bitfield = 0;
       read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
     } catch (org.apache.thrift.TException te) {
       throw new java.io.IOException(te);
     }
   }
 
   private static class TCellStandardSchemeFactory implements SchemeFactory {
     public TCellStandardScheme getScheme() {
       return new TCellStandardScheme();
     }
   }
 
   private static class TCellStandardScheme extends StandardScheme<TCell> {
 
     public void read(org.apache.thrift.protocol.TProtocol iprot, TCell 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: // VALUE
             if (schemeField.type == org.apache.thrift.protocol.TType.STRING) {
               struct.value = iprot.readBinary();
               struct.setValueIsSet(true);
             } else { 
               org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
             }
             break;
           case 2: // TIMESTAMP
             if (schemeField.type == org.apache.thrift.protocol.TType.I64) {
               struct.timestamp = iprot.readI64();
               struct.setTimestampIsSet(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, TCell struct) throws org.apache.thrift.TException {
       struct.validate();
 
       oprot.writeStructBegin(STRUCT_DESC);
       if (struct.value != null) {
         oprot.writeFieldBegin(VALUE_FIELD_DESC);
         oprot.writeBinary(struct.value);
         oprot.writeFieldEnd();
       }
       oprot.writeFieldBegin(TIMESTAMP_FIELD_DESC);
       oprot.writeI64(struct.timestamp);
       oprot.writeFieldEnd();
       oprot.writeFieldStop();
       oprot.writeStructEnd();
     }
 
   }
 
   private static class TCellTupleSchemeFactory implements SchemeFactory {
     public TCellTupleScheme getScheme() {
       return new TCellTupleScheme();
     }
   }
 
   private static class TCellTupleScheme extends TupleScheme<TCell> {
 
     @Override
     public void write(org.apache.thrift.protocol.TProtocol prot, TCell struct) throws org.apache.thrift.TException {
       TTupleProtocol oprot = (TTupleProtocol) prot;
       BitSet optionals = new BitSet();
       if (struct.isSetValue()) {
         optionals.set(0);
       }
       if (struct.isSetTimestamp()) {
         optionals.set(1);
       }
       oprot.writeBitSet(optionals, 2);
       if (struct.isSetValue()) {
         oprot.writeBinary(struct.value);
       }
       if (struct.isSetTimestamp()) {
         oprot.writeI64(struct.timestamp);
       }
     }
 
     @Override
     public void read(org.apache.thrift.protocol.TProtocol prot, TCell struct) throws org.apache.thrift.TException {
       TTupleProtocol iprot = (TTupleProtocol) prot;
       BitSet incoming = iprot.readBitSet(2);
       if (incoming.get(0)) {
         struct.value = iprot.readBinary();
         struct.setValueIsSet(true);
       }
       if (incoming.get(1)) {
         struct.timestamp = iprot.readI64();
         struct.setTimestampIsSet(true);
       }
     }
   }
 
 }