accumulo-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From ctubb...@apache.org
Subject [14/61] [abbrv] [partial] accumulo git commit: ACCUMULO-722 put trunk in my sandbox
Date Thu, 03 Mar 2016 21:59:39 GMT
http://git-wip-us.apache.org/repos/asf/accumulo/blob/7bdbfccb/1.5/core/src/main/java/org/apache/accumulo/core/master/thrift/TableInfo.java
----------------------------------------------------------------------
diff --git a/1.5/core/src/main/java/org/apache/accumulo/core/master/thrift/TableInfo.java b/1.5/core/src/main/java/org/apache/accumulo/core/master/thrift/TableInfo.java
new file mode 100644
index 0000000..90427a6
--- /dev/null
+++ b/1.5/core/src/main/java/org/apache/accumulo/core/master/thrift/TableInfo.java
@@ -0,0 +1,1439 @@
+/**
+ * Autogenerated by Thrift Compiler (0.8.0)
+ *
+ * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
+ *  @generated
+ */
+package org.apache.accumulo.core.master.thrift;
+
+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 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;
+
+@SuppressWarnings("all") public class TableInfo implements org.apache.thrift.TBase<TableInfo, TableInfo._Fields>, java.io.Serializable, Cloneable {
+  private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("TableInfo");
+
+  private static final org.apache.thrift.protocol.TField RECS_FIELD_DESC = new org.apache.thrift.protocol.TField("recs", org.apache.thrift.protocol.TType.I64, (short)1);
+  private static final org.apache.thrift.protocol.TField RECS_IN_MEMORY_FIELD_DESC = new org.apache.thrift.protocol.TField("recsInMemory", org.apache.thrift.protocol.TType.I64, (short)2);
+  private static final org.apache.thrift.protocol.TField TABLETS_FIELD_DESC = new org.apache.thrift.protocol.TField("tablets", org.apache.thrift.protocol.TType.I32, (short)3);
+  private static final org.apache.thrift.protocol.TField ONLINE_TABLETS_FIELD_DESC = new org.apache.thrift.protocol.TField("onlineTablets", org.apache.thrift.protocol.TType.I32, (short)4);
+  private static final org.apache.thrift.protocol.TField INGEST_RATE_FIELD_DESC = new org.apache.thrift.protocol.TField("ingestRate", org.apache.thrift.protocol.TType.DOUBLE, (short)5);
+  private static final org.apache.thrift.protocol.TField INGEST_BYTE_RATE_FIELD_DESC = new org.apache.thrift.protocol.TField("ingestByteRate", org.apache.thrift.protocol.TType.DOUBLE, (short)6);
+  private static final org.apache.thrift.protocol.TField QUERY_RATE_FIELD_DESC = new org.apache.thrift.protocol.TField("queryRate", org.apache.thrift.protocol.TType.DOUBLE, (short)7);
+  private static final org.apache.thrift.protocol.TField QUERY_BYTE_RATE_FIELD_DESC = new org.apache.thrift.protocol.TField("queryByteRate", org.apache.thrift.protocol.TType.DOUBLE, (short)8);
+  private static final org.apache.thrift.protocol.TField MINOR_FIELD_DESC = new org.apache.thrift.protocol.TField("minor", org.apache.thrift.protocol.TType.STRUCT, (short)9);
+  private static final org.apache.thrift.protocol.TField MAJOR_FIELD_DESC = new org.apache.thrift.protocol.TField("major", org.apache.thrift.protocol.TType.STRUCT, (short)10);
+  private static final org.apache.thrift.protocol.TField SCANS_FIELD_DESC = new org.apache.thrift.protocol.TField("scans", org.apache.thrift.protocol.TType.STRUCT, (short)11);
+  private static final org.apache.thrift.protocol.TField SCAN_RATE_FIELD_DESC = new org.apache.thrift.protocol.TField("scanRate", org.apache.thrift.protocol.TType.DOUBLE, (short)12);
+
+  private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>();
+  static {
+    schemes.put(StandardScheme.class, new TableInfoStandardSchemeFactory());
+    schemes.put(TupleScheme.class, new TableInfoTupleSchemeFactory());
+  }
+
+  public long recs; // required
+  public long recsInMemory; // required
+  public int tablets; // required
+  public int onlineTablets; // required
+  public double ingestRate; // required
+  public double ingestByteRate; // required
+  public double queryRate; // required
+  public double queryByteRate; // required
+  public Compacting minor; // required
+  public Compacting major; // required
+  public Compacting scans; // required
+  public double scanRate; // 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 {
+    RECS((short)1, "recs"),
+    RECS_IN_MEMORY((short)2, "recsInMemory"),
+    TABLETS((short)3, "tablets"),
+    ONLINE_TABLETS((short)4, "onlineTablets"),
+    INGEST_RATE((short)5, "ingestRate"),
+    INGEST_BYTE_RATE((short)6, "ingestByteRate"),
+    QUERY_RATE((short)7, "queryRate"),
+    QUERY_BYTE_RATE((short)8, "queryByteRate"),
+    MINOR((short)9, "minor"),
+    MAJOR((short)10, "major"),
+    SCANS((short)11, "scans"),
+    SCAN_RATE((short)12, "scanRate");
+
+    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: // RECS
+          return RECS;
+        case 2: // RECS_IN_MEMORY
+          return RECS_IN_MEMORY;
+        case 3: // TABLETS
+          return TABLETS;
+        case 4: // ONLINE_TABLETS
+          return ONLINE_TABLETS;
+        case 5: // INGEST_RATE
+          return INGEST_RATE;
+        case 6: // INGEST_BYTE_RATE
+          return INGEST_BYTE_RATE;
+        case 7: // QUERY_RATE
+          return QUERY_RATE;
+        case 8: // QUERY_BYTE_RATE
+          return QUERY_BYTE_RATE;
+        case 9: // MINOR
+          return MINOR;
+        case 10: // MAJOR
+          return MAJOR;
+        case 11: // SCANS
+          return SCANS;
+        case 12: // SCAN_RATE
+          return SCAN_RATE;
+        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 __RECS_ISSET_ID = 0;
+  private static final int __RECSINMEMORY_ISSET_ID = 1;
+  private static final int __TABLETS_ISSET_ID = 2;
+  private static final int __ONLINETABLETS_ISSET_ID = 3;
+  private static final int __INGESTRATE_ISSET_ID = 4;
+  private static final int __INGESTBYTERATE_ISSET_ID = 5;
+  private static final int __QUERYRATE_ISSET_ID = 6;
+  private static final int __QUERYBYTERATE_ISSET_ID = 7;
+  private static final int __SCANRATE_ISSET_ID = 8;
+  private BitSet __isset_bit_vector = new BitSet(9);
+  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.RECS, new org.apache.thrift.meta_data.FieldMetaData("recs", org.apache.thrift.TFieldRequirementType.DEFAULT, 
+        new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.I64)));
+    tmpMap.put(_Fields.RECS_IN_MEMORY, new org.apache.thrift.meta_data.FieldMetaData("recsInMemory", org.apache.thrift.TFieldRequirementType.DEFAULT, 
+        new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.I64)));
+    tmpMap.put(_Fields.TABLETS, new org.apache.thrift.meta_data.FieldMetaData("tablets", org.apache.thrift.TFieldRequirementType.DEFAULT, 
+        new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.I32)));
+    tmpMap.put(_Fields.ONLINE_TABLETS, new org.apache.thrift.meta_data.FieldMetaData("onlineTablets", org.apache.thrift.TFieldRequirementType.DEFAULT, 
+        new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.I32)));
+    tmpMap.put(_Fields.INGEST_RATE, new org.apache.thrift.meta_data.FieldMetaData("ingestRate", org.apache.thrift.TFieldRequirementType.DEFAULT, 
+        new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.DOUBLE)));
+    tmpMap.put(_Fields.INGEST_BYTE_RATE, new org.apache.thrift.meta_data.FieldMetaData("ingestByteRate", org.apache.thrift.TFieldRequirementType.DEFAULT, 
+        new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.DOUBLE)));
+    tmpMap.put(_Fields.QUERY_RATE, new org.apache.thrift.meta_data.FieldMetaData("queryRate", org.apache.thrift.TFieldRequirementType.DEFAULT, 
+        new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.DOUBLE)));
+    tmpMap.put(_Fields.QUERY_BYTE_RATE, new org.apache.thrift.meta_data.FieldMetaData("queryByteRate", org.apache.thrift.TFieldRequirementType.DEFAULT, 
+        new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.DOUBLE)));
+    tmpMap.put(_Fields.MINOR, new org.apache.thrift.meta_data.FieldMetaData("minor", org.apache.thrift.TFieldRequirementType.DEFAULT, 
+        new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, Compacting.class)));
+    tmpMap.put(_Fields.MAJOR, new org.apache.thrift.meta_data.FieldMetaData("major", org.apache.thrift.TFieldRequirementType.DEFAULT, 
+        new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, Compacting.class)));
+    tmpMap.put(_Fields.SCANS, new org.apache.thrift.meta_data.FieldMetaData("scans", org.apache.thrift.TFieldRequirementType.DEFAULT, 
+        new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, Compacting.class)));
+    tmpMap.put(_Fields.SCAN_RATE, new org.apache.thrift.meta_data.FieldMetaData("scanRate", org.apache.thrift.TFieldRequirementType.DEFAULT, 
+        new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.DOUBLE)));
+    metaDataMap = Collections.unmodifiableMap(tmpMap);
+    org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(TableInfo.class, metaDataMap);
+  }
+
+  public TableInfo() {
+  }
+
+  public TableInfo(
+    long recs,
+    long recsInMemory,
+    int tablets,
+    int onlineTablets,
+    double ingestRate,
+    double ingestByteRate,
+    double queryRate,
+    double queryByteRate,
+    Compacting minor,
+    Compacting major,
+    Compacting scans,
+    double scanRate)
+  {
+    this();
+    this.recs = recs;
+    setRecsIsSet(true);
+    this.recsInMemory = recsInMemory;
+    setRecsInMemoryIsSet(true);
+    this.tablets = tablets;
+    setTabletsIsSet(true);
+    this.onlineTablets = onlineTablets;
+    setOnlineTabletsIsSet(true);
+    this.ingestRate = ingestRate;
+    setIngestRateIsSet(true);
+    this.ingestByteRate = ingestByteRate;
+    setIngestByteRateIsSet(true);
+    this.queryRate = queryRate;
+    setQueryRateIsSet(true);
+    this.queryByteRate = queryByteRate;
+    setQueryByteRateIsSet(true);
+    this.minor = minor;
+    this.major = major;
+    this.scans = scans;
+    this.scanRate = scanRate;
+    setScanRateIsSet(true);
+  }
+
+  /**
+   * Performs a deep copy on <i>other</i>.
+   */
+  public TableInfo(TableInfo other) {
+    __isset_bit_vector.clear();
+    __isset_bit_vector.or(other.__isset_bit_vector);
+    this.recs = other.recs;
+    this.recsInMemory = other.recsInMemory;
+    this.tablets = other.tablets;
+    this.onlineTablets = other.onlineTablets;
+    this.ingestRate = other.ingestRate;
+    this.ingestByteRate = other.ingestByteRate;
+    this.queryRate = other.queryRate;
+    this.queryByteRate = other.queryByteRate;
+    if (other.isSetMinor()) {
+      this.minor = new Compacting(other.minor);
+    }
+    if (other.isSetMajor()) {
+      this.major = new Compacting(other.major);
+    }
+    if (other.isSetScans()) {
+      this.scans = new Compacting(other.scans);
+    }
+    this.scanRate = other.scanRate;
+  }
+
+  public TableInfo deepCopy() {
+    return new TableInfo(this);
+  }
+
+  @Override
+  public void clear() {
+    setRecsIsSet(false);
+    this.recs = 0;
+    setRecsInMemoryIsSet(false);
+    this.recsInMemory = 0;
+    setTabletsIsSet(false);
+    this.tablets = 0;
+    setOnlineTabletsIsSet(false);
+    this.onlineTablets = 0;
+    setIngestRateIsSet(false);
+    this.ingestRate = 0.0;
+    setIngestByteRateIsSet(false);
+    this.ingestByteRate = 0.0;
+    setQueryRateIsSet(false);
+    this.queryRate = 0.0;
+    setQueryByteRateIsSet(false);
+    this.queryByteRate = 0.0;
+    this.minor = null;
+    this.major = null;
+    this.scans = null;
+    setScanRateIsSet(false);
+    this.scanRate = 0.0;
+  }
+
+  public long getRecs() {
+    return this.recs;
+  }
+
+  public TableInfo setRecs(long recs) {
+    this.recs = recs;
+    setRecsIsSet(true);
+    return this;
+  }
+
+  public void unsetRecs() {
+    __isset_bit_vector.clear(__RECS_ISSET_ID);
+  }
+
+  /** Returns true if field recs is set (has been assigned a value) and false otherwise */
+  public boolean isSetRecs() {
+    return __isset_bit_vector.get(__RECS_ISSET_ID);
+  }
+
+  public void setRecsIsSet(boolean value) {
+    __isset_bit_vector.set(__RECS_ISSET_ID, value);
+  }
+
+  public long getRecsInMemory() {
+    return this.recsInMemory;
+  }
+
+  public TableInfo setRecsInMemory(long recsInMemory) {
+    this.recsInMemory = recsInMemory;
+    setRecsInMemoryIsSet(true);
+    return this;
+  }
+
+  public void unsetRecsInMemory() {
+    __isset_bit_vector.clear(__RECSINMEMORY_ISSET_ID);
+  }
+
+  /** Returns true if field recsInMemory is set (has been assigned a value) and false otherwise */
+  public boolean isSetRecsInMemory() {
+    return __isset_bit_vector.get(__RECSINMEMORY_ISSET_ID);
+  }
+
+  public void setRecsInMemoryIsSet(boolean value) {
+    __isset_bit_vector.set(__RECSINMEMORY_ISSET_ID, value);
+  }
+
+  public int getTablets() {
+    return this.tablets;
+  }
+
+  public TableInfo setTablets(int tablets) {
+    this.tablets = tablets;
+    setTabletsIsSet(true);
+    return this;
+  }
+
+  public void unsetTablets() {
+    __isset_bit_vector.clear(__TABLETS_ISSET_ID);
+  }
+
+  /** Returns true if field tablets is set (has been assigned a value) and false otherwise */
+  public boolean isSetTablets() {
+    return __isset_bit_vector.get(__TABLETS_ISSET_ID);
+  }
+
+  public void setTabletsIsSet(boolean value) {
+    __isset_bit_vector.set(__TABLETS_ISSET_ID, value);
+  }
+
+  public int getOnlineTablets() {
+    return this.onlineTablets;
+  }
+
+  public TableInfo setOnlineTablets(int onlineTablets) {
+    this.onlineTablets = onlineTablets;
+    setOnlineTabletsIsSet(true);
+    return this;
+  }
+
+  public void unsetOnlineTablets() {
+    __isset_bit_vector.clear(__ONLINETABLETS_ISSET_ID);
+  }
+
+  /** Returns true if field onlineTablets is set (has been assigned a value) and false otherwise */
+  public boolean isSetOnlineTablets() {
+    return __isset_bit_vector.get(__ONLINETABLETS_ISSET_ID);
+  }
+
+  public void setOnlineTabletsIsSet(boolean value) {
+    __isset_bit_vector.set(__ONLINETABLETS_ISSET_ID, value);
+  }
+
+  public double getIngestRate() {
+    return this.ingestRate;
+  }
+
+  public TableInfo setIngestRate(double ingestRate) {
+    this.ingestRate = ingestRate;
+    setIngestRateIsSet(true);
+    return this;
+  }
+
+  public void unsetIngestRate() {
+    __isset_bit_vector.clear(__INGESTRATE_ISSET_ID);
+  }
+
+  /** Returns true if field ingestRate is set (has been assigned a value) and false otherwise */
+  public boolean isSetIngestRate() {
+    return __isset_bit_vector.get(__INGESTRATE_ISSET_ID);
+  }
+
+  public void setIngestRateIsSet(boolean value) {
+    __isset_bit_vector.set(__INGESTRATE_ISSET_ID, value);
+  }
+
+  public double getIngestByteRate() {
+    return this.ingestByteRate;
+  }
+
+  public TableInfo setIngestByteRate(double ingestByteRate) {
+    this.ingestByteRate = ingestByteRate;
+    setIngestByteRateIsSet(true);
+    return this;
+  }
+
+  public void unsetIngestByteRate() {
+    __isset_bit_vector.clear(__INGESTBYTERATE_ISSET_ID);
+  }
+
+  /** Returns true if field ingestByteRate is set (has been assigned a value) and false otherwise */
+  public boolean isSetIngestByteRate() {
+    return __isset_bit_vector.get(__INGESTBYTERATE_ISSET_ID);
+  }
+
+  public void setIngestByteRateIsSet(boolean value) {
+    __isset_bit_vector.set(__INGESTBYTERATE_ISSET_ID, value);
+  }
+
+  public double getQueryRate() {
+    return this.queryRate;
+  }
+
+  public TableInfo setQueryRate(double queryRate) {
+    this.queryRate = queryRate;
+    setQueryRateIsSet(true);
+    return this;
+  }
+
+  public void unsetQueryRate() {
+    __isset_bit_vector.clear(__QUERYRATE_ISSET_ID);
+  }
+
+  /** Returns true if field queryRate is set (has been assigned a value) and false otherwise */
+  public boolean isSetQueryRate() {
+    return __isset_bit_vector.get(__QUERYRATE_ISSET_ID);
+  }
+
+  public void setQueryRateIsSet(boolean value) {
+    __isset_bit_vector.set(__QUERYRATE_ISSET_ID, value);
+  }
+
+  public double getQueryByteRate() {
+    return this.queryByteRate;
+  }
+
+  public TableInfo setQueryByteRate(double queryByteRate) {
+    this.queryByteRate = queryByteRate;
+    setQueryByteRateIsSet(true);
+    return this;
+  }
+
+  public void unsetQueryByteRate() {
+    __isset_bit_vector.clear(__QUERYBYTERATE_ISSET_ID);
+  }
+
+  /** Returns true if field queryByteRate is set (has been assigned a value) and false otherwise */
+  public boolean isSetQueryByteRate() {
+    return __isset_bit_vector.get(__QUERYBYTERATE_ISSET_ID);
+  }
+
+  public void setQueryByteRateIsSet(boolean value) {
+    __isset_bit_vector.set(__QUERYBYTERATE_ISSET_ID, value);
+  }
+
+  public Compacting getMinor() {
+    return this.minor;
+  }
+
+  public TableInfo setMinor(Compacting minor) {
+    this.minor = minor;
+    return this;
+  }
+
+  public void unsetMinor() {
+    this.minor = null;
+  }
+
+  /** Returns true if field minor is set (has been assigned a value) and false otherwise */
+  public boolean isSetMinor() {
+    return this.minor != null;
+  }
+
+  public void setMinorIsSet(boolean value) {
+    if (!value) {
+      this.minor = null;
+    }
+  }
+
+  public Compacting getMajor() {
+    return this.major;
+  }
+
+  public TableInfo setMajor(Compacting major) {
+    this.major = major;
+    return this;
+  }
+
+  public void unsetMajor() {
+    this.major = null;
+  }
+
+  /** Returns true if field major is set (has been assigned a value) and false otherwise */
+  public boolean isSetMajor() {
+    return this.major != null;
+  }
+
+  public void setMajorIsSet(boolean value) {
+    if (!value) {
+      this.major = null;
+    }
+  }
+
+  public Compacting getScans() {
+    return this.scans;
+  }
+
+  public TableInfo setScans(Compacting scans) {
+    this.scans = scans;
+    return this;
+  }
+
+  public void unsetScans() {
+    this.scans = null;
+  }
+
+  /** Returns true if field scans is set (has been assigned a value) and false otherwise */
+  public boolean isSetScans() {
+    return this.scans != null;
+  }
+
+  public void setScansIsSet(boolean value) {
+    if (!value) {
+      this.scans = null;
+    }
+  }
+
+  public double getScanRate() {
+    return this.scanRate;
+  }
+
+  public TableInfo setScanRate(double scanRate) {
+    this.scanRate = scanRate;
+    setScanRateIsSet(true);
+    return this;
+  }
+
+  public void unsetScanRate() {
+    __isset_bit_vector.clear(__SCANRATE_ISSET_ID);
+  }
+
+  /** Returns true if field scanRate is set (has been assigned a value) and false otherwise */
+  public boolean isSetScanRate() {
+    return __isset_bit_vector.get(__SCANRATE_ISSET_ID);
+  }
+
+  public void setScanRateIsSet(boolean value) {
+    __isset_bit_vector.set(__SCANRATE_ISSET_ID, value);
+  }
+
+  public void setFieldValue(_Fields field, Object value) {
+    switch (field) {
+    case RECS:
+      if (value == null) {
+        unsetRecs();
+      } else {
+        setRecs((Long)value);
+      }
+      break;
+
+    case RECS_IN_MEMORY:
+      if (value == null) {
+        unsetRecsInMemory();
+      } else {
+        setRecsInMemory((Long)value);
+      }
+      break;
+
+    case TABLETS:
+      if (value == null) {
+        unsetTablets();
+      } else {
+        setTablets((Integer)value);
+      }
+      break;
+
+    case ONLINE_TABLETS:
+      if (value == null) {
+        unsetOnlineTablets();
+      } else {
+        setOnlineTablets((Integer)value);
+      }
+      break;
+
+    case INGEST_RATE:
+      if (value == null) {
+        unsetIngestRate();
+      } else {
+        setIngestRate((Double)value);
+      }
+      break;
+
+    case INGEST_BYTE_RATE:
+      if (value == null) {
+        unsetIngestByteRate();
+      } else {
+        setIngestByteRate((Double)value);
+      }
+      break;
+
+    case QUERY_RATE:
+      if (value == null) {
+        unsetQueryRate();
+      } else {
+        setQueryRate((Double)value);
+      }
+      break;
+
+    case QUERY_BYTE_RATE:
+      if (value == null) {
+        unsetQueryByteRate();
+      } else {
+        setQueryByteRate((Double)value);
+      }
+      break;
+
+    case MINOR:
+      if (value == null) {
+        unsetMinor();
+      } else {
+        setMinor((Compacting)value);
+      }
+      break;
+
+    case MAJOR:
+      if (value == null) {
+        unsetMajor();
+      } else {
+        setMajor((Compacting)value);
+      }
+      break;
+
+    case SCANS:
+      if (value == null) {
+        unsetScans();
+      } else {
+        setScans((Compacting)value);
+      }
+      break;
+
+    case SCAN_RATE:
+      if (value == null) {
+        unsetScanRate();
+      } else {
+        setScanRate((Double)value);
+      }
+      break;
+
+    }
+  }
+
+  public Object getFieldValue(_Fields field) {
+    switch (field) {
+    case RECS:
+      return Long.valueOf(getRecs());
+
+    case RECS_IN_MEMORY:
+      return Long.valueOf(getRecsInMemory());
+
+    case TABLETS:
+      return Integer.valueOf(getTablets());
+
+    case ONLINE_TABLETS:
+      return Integer.valueOf(getOnlineTablets());
+
+    case INGEST_RATE:
+      return Double.valueOf(getIngestRate());
+
+    case INGEST_BYTE_RATE:
+      return Double.valueOf(getIngestByteRate());
+
+    case QUERY_RATE:
+      return Double.valueOf(getQueryRate());
+
+    case QUERY_BYTE_RATE:
+      return Double.valueOf(getQueryByteRate());
+
+    case MINOR:
+      return getMinor();
+
+    case MAJOR:
+      return getMajor();
+
+    case SCANS:
+      return getScans();
+
+    case SCAN_RATE:
+      return Double.valueOf(getScanRate());
+
+    }
+    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 RECS:
+      return isSetRecs();
+    case RECS_IN_MEMORY:
+      return isSetRecsInMemory();
+    case TABLETS:
+      return isSetTablets();
+    case ONLINE_TABLETS:
+      return isSetOnlineTablets();
+    case INGEST_RATE:
+      return isSetIngestRate();
+    case INGEST_BYTE_RATE:
+      return isSetIngestByteRate();
+    case QUERY_RATE:
+      return isSetQueryRate();
+    case QUERY_BYTE_RATE:
+      return isSetQueryByteRate();
+    case MINOR:
+      return isSetMinor();
+    case MAJOR:
+      return isSetMajor();
+    case SCANS:
+      return isSetScans();
+    case SCAN_RATE:
+      return isSetScanRate();
+    }
+    throw new IllegalStateException();
+  }
+
+  @Override
+  public boolean equals(Object that) {
+    if (that == null)
+      return false;
+    if (that instanceof TableInfo)
+      return this.equals((TableInfo)that);
+    return false;
+  }
+
+  public boolean equals(TableInfo that) {
+    if (that == null)
+      return false;
+
+    boolean this_present_recs = true;
+    boolean that_present_recs = true;
+    if (this_present_recs || that_present_recs) {
+      if (!(this_present_recs && that_present_recs))
+        return false;
+      if (this.recs != that.recs)
+        return false;
+    }
+
+    boolean this_present_recsInMemory = true;
+    boolean that_present_recsInMemory = true;
+    if (this_present_recsInMemory || that_present_recsInMemory) {
+      if (!(this_present_recsInMemory && that_present_recsInMemory))
+        return false;
+      if (this.recsInMemory != that.recsInMemory)
+        return false;
+    }
+
+    boolean this_present_tablets = true;
+    boolean that_present_tablets = true;
+    if (this_present_tablets || that_present_tablets) {
+      if (!(this_present_tablets && that_present_tablets))
+        return false;
+      if (this.tablets != that.tablets)
+        return false;
+    }
+
+    boolean this_present_onlineTablets = true;
+    boolean that_present_onlineTablets = true;
+    if (this_present_onlineTablets || that_present_onlineTablets) {
+      if (!(this_present_onlineTablets && that_present_onlineTablets))
+        return false;
+      if (this.onlineTablets != that.onlineTablets)
+        return false;
+    }
+
+    boolean this_present_ingestRate = true;
+    boolean that_present_ingestRate = true;
+    if (this_present_ingestRate || that_present_ingestRate) {
+      if (!(this_present_ingestRate && that_present_ingestRate))
+        return false;
+      if (this.ingestRate != that.ingestRate)
+        return false;
+    }
+
+    boolean this_present_ingestByteRate = true;
+    boolean that_present_ingestByteRate = true;
+    if (this_present_ingestByteRate || that_present_ingestByteRate) {
+      if (!(this_present_ingestByteRate && that_present_ingestByteRate))
+        return false;
+      if (this.ingestByteRate != that.ingestByteRate)
+        return false;
+    }
+
+    boolean this_present_queryRate = true;
+    boolean that_present_queryRate = true;
+    if (this_present_queryRate || that_present_queryRate) {
+      if (!(this_present_queryRate && that_present_queryRate))
+        return false;
+      if (this.queryRate != that.queryRate)
+        return false;
+    }
+
+    boolean this_present_queryByteRate = true;
+    boolean that_present_queryByteRate = true;
+    if (this_present_queryByteRate || that_present_queryByteRate) {
+      if (!(this_present_queryByteRate && that_present_queryByteRate))
+        return false;
+      if (this.queryByteRate != that.queryByteRate)
+        return false;
+    }
+
+    boolean this_present_minor = true && this.isSetMinor();
+    boolean that_present_minor = true && that.isSetMinor();
+    if (this_present_minor || that_present_minor) {
+      if (!(this_present_minor && that_present_minor))
+        return false;
+      if (!this.minor.equals(that.minor))
+        return false;
+    }
+
+    boolean this_present_major = true && this.isSetMajor();
+    boolean that_present_major = true && that.isSetMajor();
+    if (this_present_major || that_present_major) {
+      if (!(this_present_major && that_present_major))
+        return false;
+      if (!this.major.equals(that.major))
+        return false;
+    }
+
+    boolean this_present_scans = true && this.isSetScans();
+    boolean that_present_scans = true && that.isSetScans();
+    if (this_present_scans || that_present_scans) {
+      if (!(this_present_scans && that_present_scans))
+        return false;
+      if (!this.scans.equals(that.scans))
+        return false;
+    }
+
+    boolean this_present_scanRate = true;
+    boolean that_present_scanRate = true;
+    if (this_present_scanRate || that_present_scanRate) {
+      if (!(this_present_scanRate && that_present_scanRate))
+        return false;
+      if (this.scanRate != that.scanRate)
+        return false;
+    }
+
+    return true;
+  }
+
+  @Override
+  public int hashCode() {
+    return 0;
+  }
+
+  public int compareTo(TableInfo other) {
+    if (!getClass().equals(other.getClass())) {
+      return getClass().getName().compareTo(other.getClass().getName());
+    }
+
+    int lastComparison = 0;
+    TableInfo typedOther = (TableInfo)other;
+
+    lastComparison = Boolean.valueOf(isSetRecs()).compareTo(typedOther.isSetRecs());
+    if (lastComparison != 0) {
+      return lastComparison;
+    }
+    if (isSetRecs()) {
+      lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.recs, typedOther.recs);
+      if (lastComparison != 0) {
+        return lastComparison;
+      }
+    }
+    lastComparison = Boolean.valueOf(isSetRecsInMemory()).compareTo(typedOther.isSetRecsInMemory());
+    if (lastComparison != 0) {
+      return lastComparison;
+    }
+    if (isSetRecsInMemory()) {
+      lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.recsInMemory, typedOther.recsInMemory);
+      if (lastComparison != 0) {
+        return lastComparison;
+      }
+    }
+    lastComparison = Boolean.valueOf(isSetTablets()).compareTo(typedOther.isSetTablets());
+    if (lastComparison != 0) {
+      return lastComparison;
+    }
+    if (isSetTablets()) {
+      lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.tablets, typedOther.tablets);
+      if (lastComparison != 0) {
+        return lastComparison;
+      }
+    }
+    lastComparison = Boolean.valueOf(isSetOnlineTablets()).compareTo(typedOther.isSetOnlineTablets());
+    if (lastComparison != 0) {
+      return lastComparison;
+    }
+    if (isSetOnlineTablets()) {
+      lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.onlineTablets, typedOther.onlineTablets);
+      if (lastComparison != 0) {
+        return lastComparison;
+      }
+    }
+    lastComparison = Boolean.valueOf(isSetIngestRate()).compareTo(typedOther.isSetIngestRate());
+    if (lastComparison != 0) {
+      return lastComparison;
+    }
+    if (isSetIngestRate()) {
+      lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.ingestRate, typedOther.ingestRate);
+      if (lastComparison != 0) {
+        return lastComparison;
+      }
+    }
+    lastComparison = Boolean.valueOf(isSetIngestByteRate()).compareTo(typedOther.isSetIngestByteRate());
+    if (lastComparison != 0) {
+      return lastComparison;
+    }
+    if (isSetIngestByteRate()) {
+      lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.ingestByteRate, typedOther.ingestByteRate);
+      if (lastComparison != 0) {
+        return lastComparison;
+      }
+    }
+    lastComparison = Boolean.valueOf(isSetQueryRate()).compareTo(typedOther.isSetQueryRate());
+    if (lastComparison != 0) {
+      return lastComparison;
+    }
+    if (isSetQueryRate()) {
+      lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.queryRate, typedOther.queryRate);
+      if (lastComparison != 0) {
+        return lastComparison;
+      }
+    }
+    lastComparison = Boolean.valueOf(isSetQueryByteRate()).compareTo(typedOther.isSetQueryByteRate());
+    if (lastComparison != 0) {
+      return lastComparison;
+    }
+    if (isSetQueryByteRate()) {
+      lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.queryByteRate, typedOther.queryByteRate);
+      if (lastComparison != 0) {
+        return lastComparison;
+      }
+    }
+    lastComparison = Boolean.valueOf(isSetMinor()).compareTo(typedOther.isSetMinor());
+    if (lastComparison != 0) {
+      return lastComparison;
+    }
+    if (isSetMinor()) {
+      lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.minor, typedOther.minor);
+      if (lastComparison != 0) {
+        return lastComparison;
+      }
+    }
+    lastComparison = Boolean.valueOf(isSetMajor()).compareTo(typedOther.isSetMajor());
+    if (lastComparison != 0) {
+      return lastComparison;
+    }
+    if (isSetMajor()) {
+      lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.major, typedOther.major);
+      if (lastComparison != 0) {
+        return lastComparison;
+      }
+    }
+    lastComparison = Boolean.valueOf(isSetScans()).compareTo(typedOther.isSetScans());
+    if (lastComparison != 0) {
+      return lastComparison;
+    }
+    if (isSetScans()) {
+      lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.scans, typedOther.scans);
+      if (lastComparison != 0) {
+        return lastComparison;
+      }
+    }
+    lastComparison = Boolean.valueOf(isSetScanRate()).compareTo(typedOther.isSetScanRate());
+    if (lastComparison != 0) {
+      return lastComparison;
+    }
+    if (isSetScanRate()) {
+      lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.scanRate, typedOther.scanRate);
+      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("TableInfo(");
+    boolean first = true;
+
+    sb.append("recs:");
+    sb.append(this.recs);
+    first = false;
+    if (!first) sb.append(", ");
+    sb.append("recsInMemory:");
+    sb.append(this.recsInMemory);
+    first = false;
+    if (!first) sb.append(", ");
+    sb.append("tablets:");
+    sb.append(this.tablets);
+    first = false;
+    if (!first) sb.append(", ");
+    sb.append("onlineTablets:");
+    sb.append(this.onlineTablets);
+    first = false;
+    if (!first) sb.append(", ");
+    sb.append("ingestRate:");
+    sb.append(this.ingestRate);
+    first = false;
+    if (!first) sb.append(", ");
+    sb.append("ingestByteRate:");
+    sb.append(this.ingestByteRate);
+    first = false;
+    if (!first) sb.append(", ");
+    sb.append("queryRate:");
+    sb.append(this.queryRate);
+    first = false;
+    if (!first) sb.append(", ");
+    sb.append("queryByteRate:");
+    sb.append(this.queryByteRate);
+    first = false;
+    if (!first) sb.append(", ");
+    sb.append("minor:");
+    if (this.minor == null) {
+      sb.append("null");
+    } else {
+      sb.append(this.minor);
+    }
+    first = false;
+    if (!first) sb.append(", ");
+    sb.append("major:");
+    if (this.major == null) {
+      sb.append("null");
+    } else {
+      sb.append(this.major);
+    }
+    first = false;
+    if (!first) sb.append(", ");
+    sb.append("scans:");
+    if (this.scans == null) {
+      sb.append("null");
+    } else {
+      sb.append(this.scans);
+    }
+    first = false;
+    if (!first) sb.append(", ");
+    sb.append("scanRate:");
+    sb.append(this.scanRate);
+    first = false;
+    sb.append(")");
+    return sb.toString();
+  }
+
+  public void validate() throws org.apache.thrift.TException {
+    // check for required fields
+  }
+
+  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_bit_vector = new BitSet(1);
+      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 TableInfoStandardSchemeFactory implements SchemeFactory {
+    public TableInfoStandardScheme getScheme() {
+      return new TableInfoStandardScheme();
+    }
+  }
+
+  private static class TableInfoStandardScheme extends StandardScheme<TableInfo> {
+
+    public void read(org.apache.thrift.protocol.TProtocol iprot, TableInfo 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: // RECS
+            if (schemeField.type == org.apache.thrift.protocol.TType.I64) {
+              struct.recs = iprot.readI64();
+              struct.setRecsIsSet(true);
+            } else { 
+              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+            }
+            break;
+          case 2: // RECS_IN_MEMORY
+            if (schemeField.type == org.apache.thrift.protocol.TType.I64) {
+              struct.recsInMemory = iprot.readI64();
+              struct.setRecsInMemoryIsSet(true);
+            } else { 
+              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+            }
+            break;
+          case 3: // TABLETS
+            if (schemeField.type == org.apache.thrift.protocol.TType.I32) {
+              struct.tablets = iprot.readI32();
+              struct.setTabletsIsSet(true);
+            } else { 
+              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+            }
+            break;
+          case 4: // ONLINE_TABLETS
+            if (schemeField.type == org.apache.thrift.protocol.TType.I32) {
+              struct.onlineTablets = iprot.readI32();
+              struct.setOnlineTabletsIsSet(true);
+            } else { 
+              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+            }
+            break;
+          case 5: // INGEST_RATE
+            if (schemeField.type == org.apache.thrift.protocol.TType.DOUBLE) {
+              struct.ingestRate = iprot.readDouble();
+              struct.setIngestRateIsSet(true);
+            } else { 
+              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+            }
+            break;
+          case 6: // INGEST_BYTE_RATE
+            if (schemeField.type == org.apache.thrift.protocol.TType.DOUBLE) {
+              struct.ingestByteRate = iprot.readDouble();
+              struct.setIngestByteRateIsSet(true);
+            } else { 
+              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+            }
+            break;
+          case 7: // QUERY_RATE
+            if (schemeField.type == org.apache.thrift.protocol.TType.DOUBLE) {
+              struct.queryRate = iprot.readDouble();
+              struct.setQueryRateIsSet(true);
+            } else { 
+              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+            }
+            break;
+          case 8: // QUERY_BYTE_RATE
+            if (schemeField.type == org.apache.thrift.protocol.TType.DOUBLE) {
+              struct.queryByteRate = iprot.readDouble();
+              struct.setQueryByteRateIsSet(true);
+            } else { 
+              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+            }
+            break;
+          case 9: // MINOR
+            if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) {
+              struct.minor = new Compacting();
+              struct.minor.read(iprot);
+              struct.setMinorIsSet(true);
+            } else { 
+              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+            }
+            break;
+          case 10: // MAJOR
+            if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) {
+              struct.major = new Compacting();
+              struct.major.read(iprot);
+              struct.setMajorIsSet(true);
+            } else { 
+              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+            }
+            break;
+          case 11: // SCANS
+            if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) {
+              struct.scans = new Compacting();
+              struct.scans.read(iprot);
+              struct.setScansIsSet(true);
+            } else { 
+              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+            }
+            break;
+          case 12: // SCAN_RATE
+            if (schemeField.type == org.apache.thrift.protocol.TType.DOUBLE) {
+              struct.scanRate = iprot.readDouble();
+              struct.setScanRateIsSet(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, TableInfo struct) throws org.apache.thrift.TException {
+      struct.validate();
+
+      oprot.writeStructBegin(STRUCT_DESC);
+      oprot.writeFieldBegin(RECS_FIELD_DESC);
+      oprot.writeI64(struct.recs);
+      oprot.writeFieldEnd();
+      oprot.writeFieldBegin(RECS_IN_MEMORY_FIELD_DESC);
+      oprot.writeI64(struct.recsInMemory);
+      oprot.writeFieldEnd();
+      oprot.writeFieldBegin(TABLETS_FIELD_DESC);
+      oprot.writeI32(struct.tablets);
+      oprot.writeFieldEnd();
+      oprot.writeFieldBegin(ONLINE_TABLETS_FIELD_DESC);
+      oprot.writeI32(struct.onlineTablets);
+      oprot.writeFieldEnd();
+      oprot.writeFieldBegin(INGEST_RATE_FIELD_DESC);
+      oprot.writeDouble(struct.ingestRate);
+      oprot.writeFieldEnd();
+      oprot.writeFieldBegin(INGEST_BYTE_RATE_FIELD_DESC);
+      oprot.writeDouble(struct.ingestByteRate);
+      oprot.writeFieldEnd();
+      oprot.writeFieldBegin(QUERY_RATE_FIELD_DESC);
+      oprot.writeDouble(struct.queryRate);
+      oprot.writeFieldEnd();
+      oprot.writeFieldBegin(QUERY_BYTE_RATE_FIELD_DESC);
+      oprot.writeDouble(struct.queryByteRate);
+      oprot.writeFieldEnd();
+      if (struct.minor != null) {
+        oprot.writeFieldBegin(MINOR_FIELD_DESC);
+        struct.minor.write(oprot);
+        oprot.writeFieldEnd();
+      }
+      if (struct.major != null) {
+        oprot.writeFieldBegin(MAJOR_FIELD_DESC);
+        struct.major.write(oprot);
+        oprot.writeFieldEnd();
+      }
+      if (struct.scans != null) {
+        oprot.writeFieldBegin(SCANS_FIELD_DESC);
+        struct.scans.write(oprot);
+        oprot.writeFieldEnd();
+      }
+      oprot.writeFieldBegin(SCAN_RATE_FIELD_DESC);
+      oprot.writeDouble(struct.scanRate);
+      oprot.writeFieldEnd();
+      oprot.writeFieldStop();
+      oprot.writeStructEnd();
+    }
+
+  }
+
+  private static class TableInfoTupleSchemeFactory implements SchemeFactory {
+    public TableInfoTupleScheme getScheme() {
+      return new TableInfoTupleScheme();
+    }
+  }
+
+  private static class TableInfoTupleScheme extends TupleScheme<TableInfo> {
+
+    @Override
+    public void write(org.apache.thrift.protocol.TProtocol prot, TableInfo struct) throws org.apache.thrift.TException {
+      TTupleProtocol oprot = (TTupleProtocol) prot;
+      BitSet optionals = new BitSet();
+      if (struct.isSetRecs()) {
+        optionals.set(0);
+      }
+      if (struct.isSetRecsInMemory()) {
+        optionals.set(1);
+      }
+      if (struct.isSetTablets()) {
+        optionals.set(2);
+      }
+      if (struct.isSetOnlineTablets()) {
+        optionals.set(3);
+      }
+      if (struct.isSetIngestRate()) {
+        optionals.set(4);
+      }
+      if (struct.isSetIngestByteRate()) {
+        optionals.set(5);
+      }
+      if (struct.isSetQueryRate()) {
+        optionals.set(6);
+      }
+      if (struct.isSetQueryByteRate()) {
+        optionals.set(7);
+      }
+      if (struct.isSetMinor()) {
+        optionals.set(8);
+      }
+      if (struct.isSetMajor()) {
+        optionals.set(9);
+      }
+      if (struct.isSetScans()) {
+        optionals.set(10);
+      }
+      if (struct.isSetScanRate()) {
+        optionals.set(11);
+      }
+      oprot.writeBitSet(optionals, 12);
+      if (struct.isSetRecs()) {
+        oprot.writeI64(struct.recs);
+      }
+      if (struct.isSetRecsInMemory()) {
+        oprot.writeI64(struct.recsInMemory);
+      }
+      if (struct.isSetTablets()) {
+        oprot.writeI32(struct.tablets);
+      }
+      if (struct.isSetOnlineTablets()) {
+        oprot.writeI32(struct.onlineTablets);
+      }
+      if (struct.isSetIngestRate()) {
+        oprot.writeDouble(struct.ingestRate);
+      }
+      if (struct.isSetIngestByteRate()) {
+        oprot.writeDouble(struct.ingestByteRate);
+      }
+      if (struct.isSetQueryRate()) {
+        oprot.writeDouble(struct.queryRate);
+      }
+      if (struct.isSetQueryByteRate()) {
+        oprot.writeDouble(struct.queryByteRate);
+      }
+      if (struct.isSetMinor()) {
+        struct.minor.write(oprot);
+      }
+      if (struct.isSetMajor()) {
+        struct.major.write(oprot);
+      }
+      if (struct.isSetScans()) {
+        struct.scans.write(oprot);
+      }
+      if (struct.isSetScanRate()) {
+        oprot.writeDouble(struct.scanRate);
+      }
+    }
+
+    @Override
+    public void read(org.apache.thrift.protocol.TProtocol prot, TableInfo struct) throws org.apache.thrift.TException {
+      TTupleProtocol iprot = (TTupleProtocol) prot;
+      BitSet incoming = iprot.readBitSet(12);
+      if (incoming.get(0)) {
+        struct.recs = iprot.readI64();
+        struct.setRecsIsSet(true);
+      }
+      if (incoming.get(1)) {
+        struct.recsInMemory = iprot.readI64();
+        struct.setRecsInMemoryIsSet(true);
+      }
+      if (incoming.get(2)) {
+        struct.tablets = iprot.readI32();
+        struct.setTabletsIsSet(true);
+      }
+      if (incoming.get(3)) {
+        struct.onlineTablets = iprot.readI32();
+        struct.setOnlineTabletsIsSet(true);
+      }
+      if (incoming.get(4)) {
+        struct.ingestRate = iprot.readDouble();
+        struct.setIngestRateIsSet(true);
+      }
+      if (incoming.get(5)) {
+        struct.ingestByteRate = iprot.readDouble();
+        struct.setIngestByteRateIsSet(true);
+      }
+      if (incoming.get(6)) {
+        struct.queryRate = iprot.readDouble();
+        struct.setQueryRateIsSet(true);
+      }
+      if (incoming.get(7)) {
+        struct.queryByteRate = iprot.readDouble();
+        struct.setQueryByteRateIsSet(true);
+      }
+      if (incoming.get(8)) {
+        struct.minor = new Compacting();
+        struct.minor.read(iprot);
+        struct.setMinorIsSet(true);
+      }
+      if (incoming.get(9)) {
+        struct.major = new Compacting();
+        struct.major.read(iprot);
+        struct.setMajorIsSet(true);
+      }
+      if (incoming.get(10)) {
+        struct.scans = new Compacting();
+        struct.scans.read(iprot);
+        struct.setScansIsSet(true);
+      }
+      if (incoming.get(11)) {
+        struct.scanRate = iprot.readDouble();
+        struct.setScanRateIsSet(true);
+      }
+    }
+  }
+
+}
+

http://git-wip-us.apache.org/repos/asf/accumulo/blob/7bdbfccb/1.5/core/src/main/java/org/apache/accumulo/core/master/thrift/TableOperation.java
----------------------------------------------------------------------
diff --git a/1.5/core/src/main/java/org/apache/accumulo/core/master/thrift/TableOperation.java b/1.5/core/src/main/java/org/apache/accumulo/core/master/thrift/TableOperation.java
new file mode 100644
index 0000000..f4e3ccb
--- /dev/null
+++ b/1.5/core/src/main/java/org/apache/accumulo/core/master/thrift/TableOperation.java
@@ -0,0 +1,75 @@
+/**
+ * Autogenerated by Thrift Compiler (0.8.0)
+ *
+ * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
+ *  @generated
+ */
+package org.apache.accumulo.core.master.thrift;
+
+
+import java.util.Map;
+import java.util.HashMap;
+import org.apache.thrift.TEnum;
+
+public enum TableOperation implements org.apache.thrift.TEnum {
+  CREATE(0),
+  CLONE(1),
+  DELETE(2),
+  RENAME(3),
+  ONLINE(4),
+  OFFLINE(5),
+  MERGE(6),
+  DELETE_RANGE(7),
+  BULK_IMPORT(8),
+  COMPACT(9),
+  IMPORT(10),
+  EXPORT(11);
+
+  private final int value;
+
+  private TableOperation(int value) {
+    this.value = value;
+  }
+
+  /**
+   * Get the integer value of this enum value, as defined in the Thrift IDL.
+   */
+  public int getValue() {
+    return value;
+  }
+
+  /**
+   * Find a the enum type by its integer value, as defined in the Thrift IDL.
+   * @return null if the value is not found.
+   */
+  public static TableOperation findByValue(int value) { 
+    switch (value) {
+      case 0:
+        return CREATE;
+      case 1:
+        return CLONE;
+      case 2:
+        return DELETE;
+      case 3:
+        return RENAME;
+      case 4:
+        return ONLINE;
+      case 5:
+        return OFFLINE;
+      case 6:
+        return MERGE;
+      case 7:
+        return DELETE_RANGE;
+      case 8:
+        return BULK_IMPORT;
+      case 9:
+        return COMPACT;
+      case 10:
+        return IMPORT;
+      case 11:
+        return EXPORT;
+      default:
+        return null;
+    }
+  }
+}

http://git-wip-us.apache.org/repos/asf/accumulo/blob/7bdbfccb/1.5/core/src/main/java/org/apache/accumulo/core/master/thrift/TabletLoadState.java
----------------------------------------------------------------------
diff --git a/1.5/core/src/main/java/org/apache/accumulo/core/master/thrift/TabletLoadState.java b/1.5/core/src/main/java/org/apache/accumulo/core/master/thrift/TabletLoadState.java
new file mode 100644
index 0000000..62d3103
--- /dev/null
+++ b/1.5/core/src/main/java/org/apache/accumulo/core/master/thrift/TabletLoadState.java
@@ -0,0 +1,57 @@
+/**
+ * Autogenerated by Thrift Compiler (0.8.0)
+ *
+ * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
+ *  @generated
+ */
+package org.apache.accumulo.core.master.thrift;
+
+
+import java.util.Map;
+import java.util.HashMap;
+import org.apache.thrift.TEnum;
+
+public enum TabletLoadState implements org.apache.thrift.TEnum {
+  LOADED(0),
+  LOAD_FAILURE(1),
+  UNLOADED(2),
+  UNLOAD_FAILURE_NOT_SERVING(3),
+  UNLOAD_ERROR(4),
+  CHOPPED(5);
+
+  private final int value;
+
+  private TabletLoadState(int value) {
+    this.value = value;
+  }
+
+  /**
+   * Get the integer value of this enum value, as defined in the Thrift IDL.
+   */
+  public int getValue() {
+    return value;
+  }
+
+  /**
+   * Find a the enum type by its integer value, as defined in the Thrift IDL.
+   * @return null if the value is not found.
+   */
+  public static TabletLoadState findByValue(int value) { 
+    switch (value) {
+      case 0:
+        return LOADED;
+      case 1:
+        return LOAD_FAILURE;
+      case 2:
+        return UNLOADED;
+      case 3:
+        return UNLOAD_FAILURE_NOT_SERVING;
+      case 4:
+        return UNLOAD_ERROR;
+      case 5:
+        return CHOPPED;
+      default:
+        return null;
+    }
+  }
+}


Mime
View raw message